diff --git a/.gitignore b/.gitignore
index 7ecae2875..2022398b1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -58,6 +58,7 @@ artifacts/
 **/Properties/launchSettings.json
 !**/*.Host/Properties/launchSettings.json
 !**/*.AppHost/Properties/launchSettings.json
+!memex/aspire/Memex.Database.Migration/Properties/launchSettings.json
 
 # StyleCop
 StyleCopReport.xml
@@ -367,8 +368,5 @@ samples/Graph/Data/VUser/
 # User activity data
 **/_useractivity/
 
-# Claude Code personal settings
-.claude/settings.local.json
-
-# Claude Code scheduled tasks lock file
-.claude/scheduled_tasks.lock
+# Claude Code per-user local state (settings.local.json, plans/, scheduled_tasks.lock, etc.)
+.claude/
diff --git a/MeshWeaver.slnx b/MeshWeaver.slnx
index e9a5a7021..ff9776e06 100644
--- a/MeshWeaver.slnx
+++ b/MeshWeaver.slnx
@@ -143,6 +143,7 @@
     <Project Path="test/MeshWeaver.Todo.Test/MeshWeaver.Todo.Test.csproj" />
     <Project Path="test/MeshWeaver.PathResolution.Test/MeshWeaver.PathResolution.Test.csproj" />
     <Project Path="test/MeshWeaver.Persistence.Test/MeshWeaver.Persistence.Test.csproj" />
+    <Project Path="test/MeshWeaver.Autocomplete.Test/MeshWeaver.Autocomplete.Test.csproj" />
     <Project Path="test/MeshWeaver.Query.Test/MeshWeaver.Query.Test.csproj" />
   </Folder>
   <Project Path="test/MeshWeaver.MemexTemplate.Test/MeshWeaver.MemexTemplate.Test.csproj" />
diff --git a/memex/Memex.Portal.Monolith/Program.cs b/memex/Memex.Portal.Monolith/Program.cs
index 08c6a1ce2..7327e6da5 100644
--- a/memex/Memex.Portal.Monolith/Program.cs
+++ b/memex/Memex.Portal.Monolith/Program.cs
@@ -58,7 +58,9 @@
                 .AddFileSystemDataSource("Cornerstone", "Cornerstone",
                     Path.Combine(graphBasePath, "Cornerstone"), "Sample Cornerstone data")
                 .AddFileSystemDataSource("FutuRe", "FutuRe",
-                    Path.Combine(graphBasePath, "FutuRe"), "Sample FutuRe reinsurance data");
+                    Path.Combine(graphBasePath, "FutuRe"), "Sample FutuRe reinsurance data")
+                .AddFileSystemDataSource("SocialMedia", "Social Media",
+                    Path.Combine(graphBasePath, "SocialMedia"), "Social media post planning demo");
         }
 
         return config.UseMonolithMesh();
diff --git a/memex/Memex.Portal.Shared/Authentication/OAuthCodeStore.cs b/memex/Memex.Portal.Shared/Authentication/OAuthCodeStore.cs
new file mode 100644
index 000000000..0e2dadb0f
--- /dev/null
+++ b/memex/Memex.Portal.Shared/Authentication/OAuthCodeStore.cs
@@ -0,0 +1,121 @@
+using System.Collections.Concurrent;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Memex.Portal.Shared.Authentication;
+
+/// <summary>
+/// In-memory store for OAuth authorization codes with PKCE support.
+/// Codes expire after 5 minutes and are single-use (consumed on exchange).
+/// Uses ConcurrentDictionary for thread-safe mutation (per CLAUDE.md exception).
+/// </summary>
+internal class OAuthCodeStore
+{
+    private readonly ConcurrentDictionary<string, AuthorizationCode> _codes = new();
+    private static readonly TimeSpan CodeLifetime = TimeSpan.FromMinutes(5);
+
+    /// <summary>
+    /// Generates a new authorization code and stores it with the given parameters.
+    /// </summary>
+    public string GenerateCode(
+        string userId,
+        string userName,
+        string userEmail,
+        string clientId,
+        string redirectUri,
+        string? codeChallenge,
+        string? codeChallengeMethod)
+    {
+        // Clean up expired codes opportunistically
+        CleanupExpired();
+
+        var code = Convert.ToBase64String(RandomNumberGenerator.GetBytes(32))
+            .Replace("+", "-").Replace("/", "_").TrimEnd('=');
+
+        var entry = new AuthorizationCode
+        {
+            Code = code,
+            UserId = userId,
+            UserName = userName,
+            UserEmail = userEmail,
+            ClientId = clientId,
+            RedirectUri = redirectUri,
+            CodeChallenge = codeChallenge,
+            CodeChallengeMethod = codeChallengeMethod,
+            CreatedAt = DateTimeOffset.UtcNow,
+        };
+
+        _codes[code] = entry;
+        return code;
+    }
+
+    /// <summary>
+    /// Exchanges an authorization code for the stored entry.
+    /// Returns null if the code is invalid, expired, or already consumed.
+    /// Validates PKCE code_verifier if a code_challenge was stored.
+    /// </summary>
+    public AuthorizationCode? ExchangeCode(string code, string clientId, string redirectUri, string? codeVerifier)
+    {
+        if (!_codes.TryRemove(code, out var entry))
+            return null;
+
+        // Check expiry
+        if (DateTimeOffset.UtcNow - entry.CreatedAt > CodeLifetime)
+            return null;
+
+        // Validate client_id and redirect_uri match
+        if (!string.Equals(entry.ClientId, clientId, StringComparison.Ordinal))
+            return null;
+        if (!string.Equals(entry.RedirectUri, redirectUri, StringComparison.Ordinal))
+            return null;
+
+        // Validate PKCE
+        if (!string.IsNullOrEmpty(entry.CodeChallenge))
+        {
+            if (string.IsNullOrEmpty(codeVerifier))
+                return null;
+
+            if (!VerifyPkce(codeVerifier, entry.CodeChallenge, entry.CodeChallengeMethod))
+                return null;
+        }
+
+        return entry;
+    }
+
+    private static bool VerifyPkce(string codeVerifier, string codeChallenge, string? method)
+    {
+        if (string.Equals(method, "S256", StringComparison.OrdinalIgnoreCase))
+        {
+            var hash = SHA256.HashData(Encoding.ASCII.GetBytes(codeVerifier));
+            var computed = Convert.ToBase64String(hash)
+                .Replace("+", "-").Replace("/", "_").TrimEnd('=');
+            return string.Equals(computed, codeChallenge, StringComparison.Ordinal);
+        }
+
+        // plain method (or no method specified)
+        return string.Equals(codeVerifier, codeChallenge, StringComparison.Ordinal);
+    }
+
+    private void CleanupExpired()
+    {
+        var cutoff = DateTimeOffset.UtcNow - CodeLifetime;
+        foreach (var kvp in _codes)
+        {
+            if (kvp.Value.CreatedAt < cutoff)
+                _codes.TryRemove(kvp.Key, out _);
+        }
+    }
+}
+
+internal record AuthorizationCode
+{
+    public required string Code { get; init; }
+    public required string UserId { get; init; }
+    public required string UserName { get; init; }
+    public required string UserEmail { get; init; }
+    public required string ClientId { get; init; }
+    public required string RedirectUri { get; init; }
+    public string? CodeChallenge { get; init; }
+    public string? CodeChallengeMethod { get; init; }
+    public DateTimeOffset CreatedAt { get; init; }
+}
diff --git a/memex/Memex.Portal.Shared/Authentication/OAuthConnectController.cs b/memex/Memex.Portal.Shared/Authentication/OAuthConnectController.cs
new file mode 100644
index 000000000..c2f12aa05
--- /dev/null
+++ b/memex/Memex.Portal.Shared/Authentication/OAuthConnectController.cs
@@ -0,0 +1,159 @@
+using System.Security.Claims;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Memex.Portal.Shared.Authentication;
+
+/// <summary>
+/// Minimal OAuth 2.0 authorization server for MCP clients (claude.ai Connectors, Claude Desktop).
+/// Implements authorization code flow with PKCE. Issues mw_ API tokens as access tokens,
+/// reusing the existing ApiTokenService infrastructure.
+/// </summary>
+[ApiController]
+public class OAuthConnectController(
+    IServiceProvider serviceProvider,
+    ILogger<OAuthConnectController> logger) : ControllerBase
+{
+    private OAuthCodeStore CodeStore => serviceProvider.GetRequiredService<OAuthCodeStore>();
+    private ApiTokenService TokenService => serviceProvider.GetRequiredService<ApiTokenService>();
+
+    /// <summary>
+    /// RFC 8414 — OAuth Authorization Server Metadata.
+    /// MCP clients discover this via the authorization_servers URL from the protected resource metadata.
+    /// </summary>
+    [HttpGet("/.well-known/oauth-authorization-server")]
+    [AllowAnonymous]
+    public IActionResult GetServerMetadata()
+    {
+        var origin = $"{Request.Scheme}://{Request.Host}";
+        return Ok(new
+        {
+            issuer = $"{origin}/connect",
+            authorization_endpoint = $"{origin}/connect/authorize",
+            token_endpoint = $"{origin}/connect/token",
+            response_types_supported = new[] { "code" },
+            grant_types_supported = new[] { "authorization_code" },
+            code_challenge_methods_supported = new[] { "S256" },
+        });
+    }
+
+    /// <summary>
+    /// OAuth Authorization Endpoint — redirects authenticated users to the client's redirect_uri
+    /// with an authorization code. Unauthenticated users are sent to /login first.
+    /// </summary>
+    [HttpGet("connect/authorize")]
+    public IActionResult Authorize(
+        [FromQuery] string response_type,
+        [FromQuery] string client_id,
+        [FromQuery] string redirect_uri,
+        [FromQuery] string? state,
+        [FromQuery] string? scope,
+        [FromQuery] string? code_challenge,
+        [FromQuery] string? code_challenge_method)
+    {
+        if (response_type != "code")
+            return BadRequest(new { error = "unsupported_response_type" });
+
+        if (string.IsNullOrEmpty(client_id) || string.IsNullOrEmpty(redirect_uri))
+            return BadRequest(new { error = "invalid_request", error_description = "client_id and redirect_uri are required" });
+
+        // If user is not authenticated, redirect to login with return URL
+        if (User?.Identity?.IsAuthenticated != true)
+        {
+            var authorizeUrl = $"{Request.Scheme}://{Request.Host}{Request.Path}{Request.QueryString}";
+            var loginUrl = $"/login?returnUrl={Uri.EscapeDataString(authorizeUrl)}";
+            return Redirect(loginUrl);
+        }
+
+        // Extract user identity from cookie claims
+        var email = User.FindFirstValue(ClaimTypes.Email)
+                    ?? User.FindFirstValue("email")
+                    ?? User.FindFirstValue("preferred_username")
+                    ?? "";
+        var name = User.FindFirstValue(ClaimTypes.Name)
+                   ?? User.FindFirstValue("name")
+                   ?? email;
+        var userId = User.FindFirstValue("preferred_username")
+                     ?? email;
+
+        if (string.IsNullOrEmpty(email))
+            return BadRequest(new { error = "invalid_request", error_description = "Unable to determine user identity" });
+
+        // Generate authorization code
+        var code = CodeStore.GenerateCode(
+            userId: userId,
+            userName: name,
+            userEmail: email,
+            clientId: client_id,
+            redirectUri: redirect_uri,
+            codeChallenge: code_challenge,
+            codeChallengeMethod: code_challenge_method);
+
+        logger.LogInformation("Issued OAuth authorization code for user {Email}, client {ClientId}", email, client_id);
+
+        // Redirect to client with code (and state if provided)
+        var callbackUrl = string.IsNullOrEmpty(state)
+            ? $"{redirect_uri}?code={Uri.EscapeDataString(code)}"
+            : $"{redirect_uri}?code={Uri.EscapeDataString(code)}&state={Uri.EscapeDataString(state)}";
+
+        return Redirect(callbackUrl);
+    }
+
+    /// <summary>
+    /// OAuth Token Endpoint — exchanges an authorization code for an API token.
+    /// The issued token is a standard mw_ API token, indistinguishable from manually created ones.
+    /// </summary>
+    [HttpPost("connect/token")]
+    [AllowAnonymous]
+    public async Task<IActionResult> ExchangeToken([FromForm] TokenRequest request)
+    {
+        if (request.grant_type != "authorization_code")
+            return BadRequest(new { error = "unsupported_grant_type" });
+
+        if (string.IsNullOrEmpty(request.code) || string.IsNullOrEmpty(request.client_id) || string.IsNullOrEmpty(request.redirect_uri))
+            return BadRequest(new { error = "invalid_request" });
+
+        var entry = CodeStore.ExchangeCode(
+            request.code,
+            request.client_id,
+            request.redirect_uri,
+            request.code_verifier);
+
+        if (entry == null)
+        {
+            logger.LogWarning("OAuth token exchange failed: invalid or expired code for client {ClientId}", request.client_id);
+            return BadRequest(new { error = "invalid_grant" });
+        }
+
+        // Create an mw_ API token via the existing token service
+        var (rawToken, _) = await TokenService.CreateTokenAsync(
+            userId: entry.UserId,
+            userName: entry.UserName,
+            userEmail: entry.UserEmail,
+            label: $"OAuth: {request.client_id}",
+            expiresAt: DateTimeOffset.UtcNow.AddDays(30));
+
+        logger.LogInformation("Issued OAuth access token for user {Email}, client {ClientId}", entry.UserEmail, request.client_id);
+
+        return Ok(new
+        {
+            access_token = rawToken,
+            token_type = "Bearer",
+            expires_in = (int)TimeSpan.FromDays(30).TotalSeconds,
+        });
+    }
+}
+
+/// <summary>
+/// Binds the form-encoded token request body.
+/// </summary>
+public class TokenRequest
+{
+    public string grant_type { get; set; } = "";
+    public string? code { get; set; }
+    public string? client_id { get; set; }
+    public string? redirect_uri { get; set; }
+    public string? code_verifier { get; set; }
+}
diff --git a/memex/Memex.Portal.Shared/Memex.Portal.Shared.csproj b/memex/Memex.Portal.Shared/Memex.Portal.Shared.csproj
index 271494c04..74f5b3aa5 100644
--- a/memex/Memex.Portal.Shared/Memex.Portal.Shared.csproj
+++ b/memex/Memex.Portal.Shared/Memex.Portal.Shared.csproj
@@ -31,6 +31,7 @@
 
   <ItemGroup>
     <PackageReference Include="Azure.Identity" />
+    <PackageReference Include="ModelContextProtocol.AspNetCore" />
     <PackageReference Include="Microsoft.FluentUI.AspNetCore.Components" />
     <PackageReference Include="Microsoft.FluentUI.AspNetCore.Components.Icons" />
     <PackageReference Include="Microsoft.Identity.Web" />
diff --git a/memex/Memex.Portal.Shared/MemexConfiguration.cs b/memex/Memex.Portal.Shared/MemexConfiguration.cs
index 267713855..83fcaef1e 100644
--- a/memex/Memex.Portal.Shared/MemexConfiguration.cs
+++ b/memex/Memex.Portal.Shared/MemexConfiguration.cs
@@ -42,6 +42,8 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Identity.Web;
 using Microsoft.Identity.Web.UI;
+using ModelContextProtocol.AspNetCore.Authentication;
+using ModelContextProtocol.Authentication;
 using PortalAuthOptions = MeshWeaver.Blazor.Portal.Authentication.AuthenticationOptions;
 
 namespace Memex.Portal.Shared;
@@ -117,8 +119,9 @@ public static void ConfigureMemexServices(this WebApplicationBuilder builder)
         services.Configure<StylesConfiguration>(
             builder.Configuration.GetSection("Styles"));
 
-        // Register API token service for MCP bearer auth
+        // Register API token service for MCP bearer auth and OAuth code store
         services.AddSingleton<ApiTokenService>();
+        services.AddSingleton<OAuthCodeStore>();
 
         // Configure authentication
         var authSection = builder.Configuration.GetSection(PortalAuthOptions.SectionName);
@@ -163,7 +166,8 @@ public static void ConfigureMemexServices(this WebApplicationBuilder builder)
                 .AddMicrosoftIdentityWebApp(entraIdConfig);
             services.AddAuthentication()
                 .AddScheme<AuthenticationSchemeOptions, ApiTokenAuthenticationHandler>(
-                    ApiTokenAuthenticationHandler.SchemeName, _ => { });
+                    ApiTokenAuthenticationHandler.SchemeName, _ => { })
+                .AddMcp(ConfigureMcpResourceMetadata);
             services.AddControllersWithViews()
                 .AddMicrosoftIdentityUI();
         }
@@ -196,20 +200,67 @@ public static void ConfigureMemexServices(this WebApplicationBuilder builder)
 
             // Add API token auth scheme for MCP bearer authentication
             authBuilder.AddScheme<AuthenticationSchemeOptions, ApiTokenAuthenticationHandler>(
-                ApiTokenAuthenticationHandler.SchemeName, _ => { });
+                ApiTokenAuthenticationHandler.SchemeName, _ => { })
+                .AddMcp(ConfigureMcpResourceMetadata);
         }
 
-        // Add authorization with McpAuth policy (ApiToken scheme only — no cookie redirects for API clients)
+        // Add authorization with McpAuth policy (MCP scheme forwards to ApiToken or Cookie)
         services.AddAuthorization(options =>
         {
             options.AddPolicy("McpAuth", policy =>
             {
-                policy.AddAuthenticationSchemes(ApiTokenAuthenticationHandler.SchemeName);
+                policy.AddAuthenticationSchemes(McpAuthenticationDefaults.AuthenticationScheme);
                 policy.RequireAuthenticatedUser();
             });
         });
     }
 
+    /// <summary>
+    /// Configures the MCP authentication scheme with OAuth resource metadata discovery
+    /// and request-based forwarding to the appropriate authentication handler.
+    /// </summary>
+    private static void ConfigureMcpResourceMetadata(McpAuthenticationOptions options)
+    {
+        // CRITICAL: SDK constructor sets ForwardAuthenticate = "Bearer" which takes
+        // priority over ForwardDefaultSelector in ASP.NET Core's ResolveTarget().
+        // Clear it so our selector works.
+        options.ForwardAuthenticate = null;
+
+        // Route Bearer tokens to ApiToken handler, everything else to Cookie
+        options.ForwardDefaultSelector = ctx =>
+        {
+            var authHeader = ctx.Request.Headers.Authorization.ToString();
+            if (!string.IsNullOrEmpty(authHeader) &&
+                authHeader.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase))
+                return ApiTokenAuthenticationHandler.SchemeName;
+            return CookieAuthenticationDefaults.AuthenticationScheme;
+        };
+
+        // Fallback resource metadata (overridden per-request by Events)
+        options.ResourceMetadata = new ProtectedResourceMetadata
+        {
+            BearerMethodsSupported = { "header" },
+            ScopesSupported = { "mcp" },
+        };
+
+        options.Events = new McpAuthenticationEvents
+        {
+            OnResourceMetadataRequest = ctx =>
+            {
+                var req = ctx.HttpContext.Request;
+                var origin = $"{req.Scheme}://{req.Host}";
+                ctx.ResourceMetadata = new ProtectedResourceMetadata
+                {
+                    Resource = $"{origin}/mcp",
+                    BearerMethodsSupported = { "header" },
+                    ScopesSupported = { "mcp" },
+                    AuthorizationServers = { $"{origin}/connect" },
+                };
+                return Task.CompletedTask;
+            }
+        };
+    }
+
     extension<TBuilder>(TBuilder builder) where TBuilder : MeshBuilder
     {
         /// <summary>
@@ -330,7 +381,11 @@ public TBuilder ConfigureMemexMesh(IConfiguration configuration, bool isDevelopm
                         config = config.AddContentCollection(_ => nodeContentConfig);
                     }
 
-                    return config.AddDefaultLayoutAreas().AddThreadsLayoutArea().AddApiTokensSettingsTab();
+                    return config
+                        .WithHeartBeatHandler() // silently ack heartbeats on every per-node hub
+                        .AddDefaultLayoutAreas()
+                        .AddThreadsLayoutArea()
+                        .AddApiTokensSettingsTab();
                 })
                 // Add activity tracking to record user access patterns via ActivityLogBundler
                 .AddActivityTracking();
diff --git a/memex/Memex.Portal.Shared/Pages/Onboarding.razor b/memex/Memex.Portal.Shared/Pages/Onboarding.razor
index 7036bf697..96b5ebab1 100644
--- a/memex/Memex.Portal.Shared/Pages/Onboarding.razor
+++ b/memex/Memex.Portal.Shared/Pages/Onboarding.razor
@@ -134,6 +134,7 @@
                 Email = model.Email.Trim(),
                 Bio = string.IsNullOrWhiteSpace(model.Bio) ? null : model.Bio.Trim(),
                 Role = string.IsNullOrWhiteSpace(model.Role) ? null : model.Role.Trim(),
+                PinnedPaths = ["Doc"],
             };
 
             // Use ImpersonateAsHub so the portal hub identity is recognized
diff --git a/memex/aspire/Memex.AppHost/Program.cs b/memex/aspire/Memex.AppHost/Program.cs
index 674ff47ad..4c536b79a 100644
--- a/memex/aspire/Memex.AppHost/Program.cs
+++ b/memex/aspire/Memex.AppHost/Program.cs
@@ -137,10 +137,10 @@
     .WithEnvironment("Anthropic__Endpoint", "https://s-meshweaver.services.ai.azure.com/anthropic/")
     .WithEnvironment("Anthropic__ApiKey", azureFoundryKey)
     .WithEnvironment("Anthropic__Models__0", "claude-sonnet-4-6")
-    .WithEnvironment("Anthropic__Models__1", "claude-opus-4-6")
+    .WithEnvironment("Anthropic__Models__1", "claude-opus-4-7")
     .WithEnvironment("Anthropic__Models__2", "claude-haiku-4-5")
     // Model tiers: map agent tiers to concrete models
-    .WithEnvironment("ModelTier__Heavy", "claude-opus-4-6")
+    .WithEnvironment("ModelTier__Heavy", "claude-opus-4-7")
     .WithEnvironment("ModelTier__Standard", "claude-sonnet-4-6")
     .WithEnvironment("ModelTier__Light", "claude-haiku-4-5")
     // LLM: Azure OpenAI
diff --git a/memex/aspire/Memex.Database.Migration/Properties/launchSettings.json b/memex/aspire/Memex.Database.Migration/Properties/launchSettings.json
new file mode 100644
index 000000000..ad7baef75
--- /dev/null
+++ b/memex/aspire/Memex.Database.Migration/Properties/launchSettings.json
@@ -0,0 +1,11 @@
+{
+  "profiles": {
+    "Migration": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}
diff --git a/memex/aspire/Memex.Portal.Distributed/appsettings.Development.json b/memex/aspire/Memex.Portal.Distributed/appsettings.Development.json
index 6e539eb49..a1139b132 100644
--- a/memex/aspire/Memex.Portal.Distributed/appsettings.Development.json
+++ b/memex/aspire/Memex.Portal.Distributed/appsettings.Development.json
@@ -4,8 +4,9 @@
     "LogLevel": {
       "Default": "Warning",
       "Microsoft.AspNetCore": "Warning",
-      "MeshWeaver": "Warning",
+      "MeshWeaver": "Information",
       "MeshWeaver.AI": "Information",
+      "MeshWeaver.Graph.Configuration": "Information",
       "MeshWeaver.Layout.ConvertJson": "Warning",
       "MeshWeaver.Messaging.Hub.MessageHub": "Warning",
       "Azure.Core": "Warning",
diff --git a/samples/Graph/Data/SocialMedia/Post.json b/samples/Graph/Data/SocialMedia/Post.json
new file mode 100644
index 000000000..ae79018b4
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post.json
@@ -0,0 +1,19 @@
+{
+  "id": "Post",
+  "namespace": "SocialMedia",
+  "name": "Social Media Post",
+  "nodeType": "NodeType",
+  "category": "Types",
+  "description": "A social media post (scheduled, published, with engagement stats)",
+  "icon": "/static/NodeTypeIcons/document.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "NodeTypeDefinition",
+    "id": "Post",
+    "namespace": "SocialMedia",
+    "displayName": "Social Media Post",
+    "iconName": "DocumentText",
+    "description": "A social media post (scheduled, published, with engagement stats)",
+    "configuration": "config => config.WithContentType<SocialMediaPost>().AddData(data => data.AddSource(source => source.WithType<Platform>(t => t.WithInitialData(Platform.All)))).AddDefaultLayoutAreas().AddLayout(layout => layout.AddSocialMediaPostLayoutAreas().WithDefaultArea(\"Calendar\"))"
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Post/Post-001.json b/samples/Graph/Data/SocialMedia/Post/Post-001.json
new file mode 100644
index 000000000..c6fc7e1d3
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post/Post-001.json
@@ -0,0 +1,22 @@
+{
+  "id": "Post-001",
+  "namespace": "SocialMedia/Post",
+  "path": "SocialMedia/Post/Post-001",
+  "name": "Why we bet on the actor model",
+  "nodeType": "SocialMedia/Post",
+  "icon": "/static/NodeTypeIcons/document.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaPost",
+    "title": "Why we bet on the actor model",
+    "body": "Reactive systems live or die on isolation. After years of fighting threadpools, we leaned into the actor model with Orleans \u2014 and never looked back.\n\nWhat surprised us most? **The debugging story is dramatically better.**",
+    "profilePath": "SocialMedia/Profile/Roland-LinkedIn",
+    "platform": "LinkedIn",
+    "scheduledAt": "2026-04-05T09:00:00+02:00",
+    "publishedAt": "2026-04-05T09:01:42+02:00",
+    "impressions": 4321,
+    "likes": 187,
+    "comments": 24,
+    "mediaUrl": "https://picsum.photos/seed/meshweaver-actors/800/450"
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Post/Post-002.json b/samples/Graph/Data/SocialMedia/Post/Post-002.json
new file mode 100644
index 000000000..7c4121811
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post/Post-002.json
@@ -0,0 +1,21 @@
+{
+  "id": "Post-002",
+  "namespace": "SocialMedia/Post",
+  "path": "SocialMedia/Post/Post-002",
+  "name": "Three rules for building reactive UIs that scale",
+  "nodeType": "SocialMedia/Post",
+  "icon": "/static/NodeTypeIcons/document.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaPost",
+    "title": "Three rules for building reactive UIs that scale",
+    "body": "1. Never await in a hub handler.\n2. State changes flow through immutable streams.\n3. Click handlers are projections, not orchestrations.\n\nThis took us a while to internalize \u2014 worth a thread.",
+    "profilePath": "SocialMedia/Profile/Roland-LinkedIn",
+    "platform": "LinkedIn",
+    "scheduledAt": "2026-04-12T08:30:00+02:00",
+    "publishedAt": "2026-04-12T08:31:18+02:00",
+    "impressions": 6890,
+    "likes": 312,
+    "comments": 41
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Post/Post-003.json b/samples/Graph/Data/SocialMedia/Post/Post-003.json
new file mode 100644
index 000000000..6bc2572eb
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post/Post-003.json
@@ -0,0 +1,22 @@
+{
+  "id": "Post-003",
+  "namespace": "SocialMedia/Post",
+  "path": "SocialMedia/Post/Post-003",
+  "name": "Customer story: how Northwind cut reporting latency 10x",
+  "nodeType": "SocialMedia/Post",
+  "icon": "/static/NodeTypeIcons/document.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaPost",
+    "title": "Customer story: how Northwind cut reporting latency 10x",
+    "body": "When the analytics team at Northwind moved their pricing dashboards onto MeshWeaver, page renders dropped from 4.1s to 380ms.\n\nFull case study in comments.",
+    "profilePath": "SocialMedia/Profile/Sarah-LinkedIn",
+    "platform": "LinkedIn",
+    "scheduledAt": "2026-04-08T14:00:00+02:00",
+    "publishedAt": "2026-04-08T14:00:51+02:00",
+    "impressions": 9120,
+    "likes": 421,
+    "comments": 67,
+    "mediaUrl": "https://picsum.photos/seed/northwind-case/800/450"
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Post/Post-004.json b/samples/Graph/Data/SocialMedia/Post/Post-004.json
new file mode 100644
index 000000000..23b217175
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post/Post-004.json
@@ -0,0 +1,20 @@
+{
+  "id": "Post-004",
+  "namespace": "SocialMedia/Post",
+  "path": "SocialMedia/Post/Post-004",
+  "name": "Live demo Thursday: agentic data exploration",
+  "nodeType": "SocialMedia/Post",
+  "icon": "/static/NodeTypeIcons/document.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaPost",
+    "title": "Live demo Thursday: agentic data exploration",
+    "body": "Join us this Thursday for a 30-minute live demo of our new Navigator agent. Bring questions \u2014 we'll answer them on a real dataset.\n\nRegister via the link in comments.",
+    "profilePath": "SocialMedia/Profile/Roland-LinkedIn",
+    "platform": "LinkedIn",
+    "scheduledAt": "2026-04-22T17:00:00+02:00",
+    "impressions": 0,
+    "likes": 0,
+    "comments": 0
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Post/Post-005.json b/samples/Graph/Data/SocialMedia/Post/Post-005.json
new file mode 100644
index 000000000..a37ab25da
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post/Post-005.json
@@ -0,0 +1,20 @@
+{
+  "id": "Post-005",
+  "namespace": "SocialMedia/Post",
+  "path": "SocialMedia/Post/Post-005",
+  "name": "We're hiring: Senior Backend Engineer",
+  "nodeType": "SocialMedia/Post",
+  "icon": "/static/NodeTypeIcons/document.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaPost",
+    "title": "We're hiring: Senior Backend Engineer",
+    "body": "We are growing the platform team. Looking for someone who loves distributed systems, reactive design and shipping frequently.\n\nDM me or apply via the careers page.",
+    "profilePath": "SocialMedia/Profile/Sarah-LinkedIn",
+    "platform": "LinkedIn",
+    "scheduledAt": "2026-04-25T10:00:00+02:00",
+    "impressions": 0,
+    "likes": 0,
+    "comments": 0
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Post/Post-006.json b/samples/Graph/Data/SocialMedia/Post/Post-006.json
new file mode 100644
index 000000000..b356aec45
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post/Post-006.json
@@ -0,0 +1,20 @@
+{
+  "id": "Post-006",
+  "namespace": "SocialMedia/Post",
+  "path": "SocialMedia/Post/Post-006",
+  "name": "April recap: what shipped and what's next",
+  "nodeType": "SocialMedia/Post",
+  "icon": "/static/NodeTypeIcons/document.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaPost",
+    "title": "April recap: what shipped and what's next",
+    "body": "A quick look back at April:\n\n- Annotation system: \u2705\n- MCP OAuth discovery: \u2705\n- Aggregating providers: \u2705\n\nNext month we open up the social media planner publicly. Stay tuned.",
+    "profilePath": "SocialMedia/Profile/Roland-LinkedIn",
+    "platform": "LinkedIn",
+    "scheduledAt": "2026-04-29T08:00:00+02:00",
+    "impressions": 0,
+    "likes": 0,
+    "comments": 0
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Post/_Source/Platform.cs b/samples/Graph/Data/SocialMedia/Post/_Source/Platform.cs
new file mode 100644
index 000000000..ae7655974
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post/_Source/Platform.cs
@@ -0,0 +1,39 @@
+// <meshweaver>
+// Id: Platform
+// DisplayName: Social Media Platform
+// </meshweaver>
+
+public record Platform
+{
+    [Key]
+    public string Id { get; init; } = string.Empty;
+
+    [Required]
+    public string Name { get; init; } = string.Empty;
+
+    public string Emoji { get; init; } = string.Empty;
+
+    public string Color { get; init; } = "#0a66c2";
+
+    public int Order { get; init; }
+
+    public static readonly Platform LinkedIn = new()
+    {
+        Id = "LinkedIn", Name = "LinkedIn", Emoji = "\ud83d\udcbc", Color = "#0a66c2", Order = 0
+    };
+
+    public static readonly Platform Twitter = new()
+    {
+        Id = "Twitter", Name = "X / Twitter", Emoji = "\ud83d\udc26", Color = "#000000", Order = 1
+    };
+
+    public static readonly Platform Instagram = new()
+    {
+        Id = "Instagram", Name = "Instagram", Emoji = "\ud83d\udcf7", Color = "#e1306c", Order = 2
+    };
+
+    public static readonly Platform[] All = [LinkedIn, Twitter, Instagram];
+
+    public static Platform GetById(string? id) =>
+        All.FirstOrDefault(p => p.Id == id) ?? LinkedIn;
+}
diff --git a/samples/Graph/Data/SocialMedia/Post/_Source/SocialMediaPost.cs b/samples/Graph/Data/SocialMedia/Post/_Source/SocialMediaPost.cs
new file mode 100644
index 000000000..223b048a8
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post/_Source/SocialMediaPost.cs
@@ -0,0 +1,40 @@
+// <meshweaver>
+// Id: SocialMediaPost
+// DisplayName: Social Media Post
+// </meshweaver>
+
+using MeshWeaver.Domain;
+
+public record SocialMediaPost
+{
+    [Required]
+    [MeshNodeProperty(nameof(MeshNode.Name))]
+    [UiControl(Style = "width: 100%;")]
+    public string Title { get; init; } = string.Empty;
+
+    [Markdown(EditorHeight = "200px")]
+    public string? Body { get; init; }
+
+    [Required]
+    [DisplayName("Profile path")]
+    public string ProfilePath { get; init; } = string.Empty;
+
+    [Dimension<Platform>]
+    [UiControl(Style = "width: 200px;")]
+    public string Platform { get; init; } = "LinkedIn";
+
+    [DisplayName("Scheduled at")]
+    public DateTimeOffset? ScheduledAt { get; init; }
+
+    [DisplayName("Published at")]
+    public DateTimeOffset? PublishedAt { get; init; }
+
+    public int Impressions { get; init; }
+
+    public int Likes { get; init; }
+
+    public int Comments { get; init; }
+
+    [DisplayName("Media URL")]
+    public string? MediaUrl { get; init; }
+}
diff --git a/samples/Graph/Data/SocialMedia/Post/_Source/SocialMediaPostLayoutAreas.cs b/samples/Graph/Data/SocialMedia/Post/_Source/SocialMediaPostLayoutAreas.cs
new file mode 100644
index 000000000..39f169598
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Post/_Source/SocialMediaPostLayoutAreas.cs
@@ -0,0 +1,327 @@
+// <meshweaver>
+// Id: SocialMediaPostLayoutAreas
+// DisplayName: Social Media Post Views
+// </meshweaver>
+
+using System.Collections.Immutable;
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+using System.Web;
+using MeshWeaver.Layout.Composition;
+using MeshWeaver.Mesh.Services;
+
+public static class SocialMediaPostLayoutAreas
+{
+    public const string CalendarArea = "Calendar";
+    public const string DetailArea = "Detail";
+
+    public static LayoutDefinition AddSocialMediaPostLayoutAreas(this LayoutDefinition layout) =>
+        layout
+            .WithView(CalendarArea, Calendar)
+            .WithView(DetailArea, Detail);
+
+    private static Dictionary<string, MeshNode> ApplyChanges(
+        Dictionary<string, MeshNode> current, QueryResultChange<MeshNode> change)
+    {
+        var result = change.ChangeType == QueryChangeType.Initial || change.ChangeType == QueryChangeType.Reset
+            ? new Dictionary<string, MeshNode>(StringComparer.OrdinalIgnoreCase)
+            : new Dictionary<string, MeshNode>(current, StringComparer.OrdinalIgnoreCase);
+        foreach (var item in change.Items)
+        {
+            if (change.ChangeType == QueryChangeType.Removed) result.Remove(item.Path);
+            else result[item.Path] = item;
+        }
+        return result;
+    }
+
+    private static string? GetProp(MeshNode node, string prop)
+    {
+        if (node.Content is not JsonElement json) return null;
+        if (json.TryGetProperty(prop, out var p) && p.ValueKind == JsonValueKind.String) return p.GetString();
+        var pascal = char.ToUpperInvariant(prop[0]) + prop.Substring(1);
+        return json.TryGetProperty(pascal, out var pp) && pp.ValueKind == JsonValueKind.String ? pp.GetString() : null;
+    }
+
+    private static int GetInt(MeshNode node, string prop)
+    {
+        if (node.Content is not JsonElement json) return 0;
+        var name = prop;
+        if (!json.TryGetProperty(name, out var p))
+        {
+            name = char.ToUpperInvariant(prop[0]) + prop.Substring(1);
+            if (!json.TryGetProperty(name, out p)) return 0;
+        }
+        return p.ValueKind == JsonValueKind.Number && p.TryGetInt32(out var v) ? v : 0;
+    }
+
+    private static DateTimeOffset? GetDate(MeshNode node, string prop)
+    {
+        if (node.Content is not JsonElement json) return null;
+        var name = prop;
+        if (!json.TryGetProperty(name, out var p))
+        {
+            name = char.ToUpperInvariant(prop[0]) + prop.Substring(1);
+            if (!json.TryGetProperty(name, out p)) return null;
+        }
+        return p.ValueKind == JsonValueKind.String && DateTimeOffset.TryParse(p.GetString(), out var dt) ? dt : null;
+    }
+
+    private const string FilterMy = "my";
+    private const string FilterAll = "all";
+
+    public static IObservable<UiControl?> Calendar(LayoutAreaHost host, RenderingContext _)
+    {
+        var meshService = host.Hub.ServiceProvider.GetRequiredService<IMeshService>();
+        var hubAddress = host.Hub.Address;
+        var currentEmail = host.Hub.ServiceProvider.GetService<AccessService>()?.Context?.Email ?? "";
+
+        var idStr = host.Reference.Id?.ToString() ?? "";
+        var monthPart = idStr.Split('?')[0];
+        var month = TryParseMonth(monthPart, out var parsed) ? parsed : new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
+        var filter = host.Reference.GetParameterValue("profile") ?? FilterMy;
+
+        var posts = meshService
+            .ObserveQuery<MeshNode>(MeshQueryRequest.FromQuery("namespace:SocialMedia/Post"))
+            .Scan(new Dictionary<string, MeshNode>(StringComparer.OrdinalIgnoreCase), ApplyChanges);
+        var profiles = meshService
+            .ObserveQuery<MeshNode>(MeshQueryRequest.FromQuery("namespace:SocialMedia/Profile"))
+            .Scan(new Dictionary<string, MeshNode>(StringComparer.OrdinalIgnoreCase), ApplyChanges);
+
+        return posts.CombineLatest(profiles, (postDict, profileDict) =>
+            (UiControl?)BuildCalendar(hubAddress, month, filter, currentEmail, postDict.Values.ToImmutableList(), profileDict.Values.ToImmutableList()));
+    }
+
+    private static UiControl BuildCalendar(
+        object hubAddress, DateTime month, string filter, string currentEmail,
+        ImmutableList<MeshNode> allPosts, ImmutableList<MeshNode> allProfiles)
+    {
+        var profilesByPath = allProfiles.ToImmutableDictionary(p => p.Path, p => p, StringComparer.OrdinalIgnoreCase);
+        var myProfilePaths = allProfiles
+            .Where(p => string.Equals(GetProp(p, "owner"), currentEmail, StringComparison.OrdinalIgnoreCase))
+            .Select(p => p.Path)
+            .ToImmutableHashSet(StringComparer.OrdinalIgnoreCase);
+
+        bool MatchesFilter(MeshNode post)
+        {
+            var profilePath = GetProp(post, "profilePath") ?? "";
+            return filter switch
+            {
+                FilterAll => true,
+                FilterMy => myProfilePaths.Contains(profilePath),
+                _ => string.Equals(profilePath, filter, StringComparison.OrdinalIgnoreCase)
+                     || string.Equals(profilePath.Split('/').Last(), filter, StringComparison.OrdinalIgnoreCase)
+            };
+        }
+
+        var monthPosts = allPosts
+            .Where(p => GetDate(p, "scheduledAt") is { } d && d.Year == month.Year && d.Month == month.Month)
+            .Where(MatchesFilter)
+            .OrderBy(p => GetDate(p, "scheduledAt"))
+            .ToImmutableList();
+
+        var prev = month.AddMonths(-1);
+        var next = month.AddMonths(1);
+        var prevHref = BuildHref(hubAddress, prev, filter);
+        var nextHref = BuildHref(hubAddress, next, filter);
+
+        var toolbar = Controls.Stack
+            .WithOrientation(Orientation.Horizontal)
+            .WithStyle("align-items: center; gap: 12px; flex-wrap: wrap; padding: 8px 0;")
+            .WithView(Controls.Button("\u2039")
+                .WithAppearance(Appearance.Outline)
+                .WithNavigateToHref(prevHref))
+            .WithView(Controls.Html($"<h2 style=\"margin:0;min-width:180px;text-align:center;\">{HttpUtility.HtmlEncode(month.ToString("MMMM yyyy", CultureInfo.InvariantCulture))}</h2>"))
+            .WithView(Controls.Button("\u203a")
+                .WithAppearance(Appearance.Outline)
+                .WithNavigateToHref(nextHref))
+            .WithView(Controls.Html("<div style=\"width:24px;\"></div>"))
+            .WithView(FilterButton(hubAddress, month, "My profiles", FilterMy, filter))
+            .WithView(FilterButton(hubAddress, month, "All", FilterAll, filter));
+
+        foreach (var profile in allProfiles.OrderBy(p => p.Name))
+        {
+            var label = profile.Name ?? profile.Path;
+            toolbar = toolbar.WithView(FilterButton(hubAddress, month, label, profile.Path, filter));
+        }
+
+        var grid = Controls.Html(BuildMonthGridHtml(month, monthPosts, profilesByPath));
+
+        var emptyHint = monthPosts.Count == 0
+            ? Controls.Markdown($"*No posts scheduled in {month:MMMM yyyy} for this filter.*")
+            : null;
+
+        var stack = Controls.Stack
+            .WithStyle("padding: 16px; gap: 12px;")
+            .WithView(toolbar)
+            .WithView(grid);
+        if (emptyHint != null)
+            stack = stack.WithView(emptyHint);
+        return stack;
+    }
+
+    private static ButtonControl FilterButton(object hubAddress, DateTime month, string label, string filterValue, string activeFilter)
+    {
+        var isActive = string.Equals(filterValue, activeFilter, StringComparison.OrdinalIgnoreCase);
+        var btn = Controls.Button(label)
+            .WithAppearance(isActive ? Appearance.Accent : Appearance.Stealth)
+            .WithNavigateToHref(BuildHref(hubAddress, month, filterValue));
+        return btn;
+    }
+
+    private static string BuildHref(object hubAddress, DateTime month, string filter)
+    {
+        var id = $"{month:yyyy-MM}";
+        if (!string.Equals(filter, FilterMy, StringComparison.OrdinalIgnoreCase))
+            id += $"?profile={Uri.EscapeDataString(filter)}";
+        return new LayoutAreaReference(CalendarArea) { Id = id }.ToHref(hubAddress.ToString()!);
+    }
+
+    private static string BuildMonthGridHtml(
+        DateTime month,
+        ImmutableList<MeshNode> monthPosts,
+        ImmutableDictionary<string, MeshNode> profilesByPath)
+    {
+        var firstOfMonth = new DateTime(month.Year, month.Month, 1);
+        // Monday = 1, Sunday = 0; we want week to start Monday
+        var dayOffset = ((int)firstOfMonth.DayOfWeek + 6) % 7;
+        var gridStart = firstOfMonth.AddDays(-dayOffset);
+        var daysInMonth = DateTime.DaysInMonth(month.Year, month.Month);
+
+        var postsByDay = monthPosts
+            .GroupBy(p => GetDate(p, "scheduledAt")!.Value.Date)
+            .ToImmutableDictionary(g => g.Key, g => g.ToImmutableList());
+
+        var sb = new StringBuilder();
+        sb.Append("<div style=\"display:grid;grid-template-columns:repeat(7,1fr);gap:4px;font-family:var(--body-font);\">");
+
+        // Day-of-week header
+        string[] dayNames = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+        foreach (var d in dayNames)
+            sb.Append($"<div style=\"font-weight:600;color:#666;padding:4px 8px;font-size:12px;text-transform:uppercase;\">{d}</div>");
+
+        var today = DateTime.Today;
+        for (var i = 0; i < 42; i++)
+        {
+            var date = gridStart.AddDays(i);
+            var isCurrentMonth = date.Month == month.Month && date.Year == month.Year;
+            var isToday = date == today;
+            var bg = isCurrentMonth ? "#ffffff" : "#f7f7f7";
+            var fg = isCurrentMonth ? "#222" : "#aaa";
+            var border = isToday ? "2px solid var(--accent-fill-rest, #0a66c2)" : "1px solid #e5e5e5";
+
+            sb.Append($"<div style=\"min-height:96px;background:{bg};border:{border};border-radius:6px;padding:6px;display:flex;flex-direction:column;gap:4px;\">");
+            sb.Append($"<div style=\"color:{fg};font-weight:{(isToday ? "700" : "500")};font-size:13px;\">{date.Day}</div>");
+
+            if (postsByDay.TryGetValue(date, out var dayPosts))
+            {
+                foreach (var post in dayPosts.Take(3))
+                {
+                    var title = post.Name ?? GetProp(post, "title") ?? "(untitled)";
+                    var profilePath = GetProp(post, "profilePath") ?? "";
+                    var profile = profilesByPath.GetValueOrDefault(profilePath);
+                    var platformId = GetProp(post, "platform") ?? GetProp(profile ?? new MeshNode(""), "platform") ?? "LinkedIn";
+                    var platform = Platform.GetById(platformId);
+                    var isPublished = GetDate(post, "publishedAt") is not null;
+                    var icon = isPublished ? "\u2705" : "\ud83d\udcc5";
+                    var href = "/" + post.Path;
+                    sb.Append($"<a href=\"{HttpUtility.HtmlAttributeEncode(href)}\" title=\"{HttpUtility.HtmlAttributeEncode(title)}\" style=\"display:block;padding:3px 6px;background:{platform.Color};color:white;border-radius:3px;font-size:11px;text-decoration:none;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;\">{icon} {HttpUtility.HtmlEncode(Truncate(title, 22))}</a>");
+                }
+                if (dayPosts.Count > 3)
+                    sb.Append($"<div style=\"font-size:11px;color:#666;\">+{dayPosts.Count - 3} more</div>");
+            }
+            sb.Append("</div>");
+        }
+
+        sb.Append("</div>");
+        return sb.ToString();
+    }
+
+    private static string Truncate(string s, int max) =>
+        s.Length <= max ? s : s.Substring(0, max - 1) + "\u2026";
+
+    private static bool TryParseMonth(string? s, out DateTime month)
+    {
+        month = default;
+        if (string.IsNullOrWhiteSpace(s)) return false;
+        return DateTime.TryParseExact(s, "yyyy-MM", CultureInfo.InvariantCulture, DateTimeStyles.None, out month);
+    }
+
+    public static IObservable<UiControl?> Detail(LayoutAreaHost host, RenderingContext _)
+    {
+        var hubPath = host.Hub.Address.ToString();
+        var meshService = host.Hub.ServiceProvider.GetRequiredService<IMeshService>();
+
+        var nodeStream = host.Workspace.GetStream<MeshNode>()!
+            .Select(nodes => nodes?.FirstOrDefault(n => n.Path == hubPath));
+        var profiles = meshService
+            .ObserveQuery<MeshNode>(MeshQueryRequest.FromQuery("namespace:SocialMedia/Profile"))
+            .Scan(new Dictionary<string, MeshNode>(StringComparer.OrdinalIgnoreCase), ApplyChanges);
+
+        return nodeStream.CombineLatest(profiles, (node, profileDict) =>
+        {
+            if (node is null) return (UiControl?)Controls.Markdown("*Post not found.*");
+
+            var title = node.Name ?? GetProp(node, "title") ?? "(untitled)";
+            var body = GetProp(node, "body");
+            var profilePath = GetProp(node, "profilePath") ?? "";
+            var profile = profileDict.GetValueOrDefault(profilePath);
+            var profileName = profile?.Name ?? profilePath.Split('/').Last();
+            var platformId = GetProp(node, "platform") ?? (profile is not null ? GetProp(profile, "platform") : null) ?? "LinkedIn";
+            var platform = Platform.GetById(platformId);
+            var scheduled = GetDate(node, "scheduledAt");
+            var published = GetDate(node, "publishedAt");
+            var impressions = GetInt(node, "impressions");
+            var likes = GetInt(node, "likes");
+            var comments = GetInt(node, "comments");
+            var media = GetProp(node, "mediaUrl");
+            var status = published.HasValue ? "Published" : (scheduled.HasValue && scheduled.Value > DateTimeOffset.Now ? "Scheduled" : "Draft");
+            var statusColor = published.HasValue ? "#2e7d32" : "#ed6c02";
+
+            var headerHtml = $$"""
+                <div style="display:flex;align-items:center;gap:12px;flex-wrap:wrap;padding:8px 0;">
+                  <span style="background:{{platform.Color}};color:white;padding:4px 10px;border-radius:12px;font-size:12px;font-weight:600;">{{platform.Emoji}} {{HttpUtility.HtmlEncode(platform.Name)}}</span>
+                  <a href="/{{HttpUtility.HtmlAttributeEncode(profilePath)}}" style="color:#0a66c2;text-decoration:none;">@{{HttpUtility.HtmlEncode(profileName)}}</a>
+                  <span style="background:{{statusColor}};color:white;padding:4px 10px;border-radius:12px;font-size:12px;font-weight:600;">{{status}}</span>
+                </div>
+                """;
+
+            var datesHtml = $$"""
+                <table style="border-collapse:collapse;margin:8px 0;font-size:14px;">
+                  <tr><td style="color:#666;padding:2px 12px 2px 0;">Scheduled</td><td>{{HttpUtility.HtmlEncode(scheduled?.ToString("yyyy-MM-dd HH:mm") ?? "—")}}</td></tr>
+                  <tr><td style="color:#666;padding:2px 12px 2px 0;">Published</td><td>{{HttpUtility.HtmlEncode(published?.ToString("yyyy-MM-dd HH:mm") ?? "—")}}</td></tr>
+                </table>
+                """;
+
+            var statsHtml = $$"""
+                <div style="display:flex;gap:24px;padding:12px;background:#f5f7fa;border-radius:6px;margin:8px 0;">
+                  <div><div style="font-size:11px;color:#666;text-transform:uppercase;">Impressions</div><div style="font-size:20px;font-weight:600;">{{impressions:N0}}</div></div>
+                  <div><div style="font-size:11px;color:#666;text-transform:uppercase;">Likes</div><div style="font-size:20px;font-weight:600;">{{likes:N0}}</div></div>
+                  <div><div style="font-size:11px;color:#666;text-transform:uppercase;">Comments</div><div style="font-size:20px;font-weight:600;">{{comments:N0}}</div></div>
+                </div>
+                """;
+
+            var mediaHtml = "";
+            if (!string.IsNullOrEmpty(media))
+            {
+                var lower = media.ToLowerInvariant();
+                if (lower.EndsWith(".mp4") || lower.EndsWith(".webm") || lower.EndsWith(".mov"))
+                    mediaHtml = $"<video src=\"{HttpUtility.HtmlAttributeEncode(media)}\" controls style=\"max-width:100%;border-radius:6px;margin:8px 0;\"></video>";
+                else
+                    mediaHtml = $"<img src=\"{HttpUtility.HtmlAttributeEncode(media)}\" alt=\"media\" style=\"max-width:100%;border-radius:6px;margin:8px 0;\" />";
+            }
+
+            var headerStack = Controls.Stack.WithStyle("padding: 16px; gap: 4px;")
+                .WithView(Controls.Html($"<h1 style=\"margin:0;\">{HttpUtility.HtmlEncode(title)}</h1>"))
+                .WithView(Controls.Html(headerHtml))
+                .WithView(Controls.Html(datesHtml))
+                .WithView(Controls.Html(statsHtml));
+            if (!string.IsNullOrEmpty(mediaHtml))
+                headerStack = headerStack.WithView(Controls.Html(mediaHtml));
+            if (!string.IsNullOrWhiteSpace(body))
+                headerStack = headerStack.WithView(Controls.Markdown(body));
+            headerStack = headerStack.WithView(Controls.Html($"<a href=\"/SocialMedia/Posts\" style=\"color:#0a66c2;text-decoration:none;\">\u2190 Back to calendar</a>"));
+            return (UiControl?)headerStack;
+        });
+    }
+}
diff --git a/samples/Graph/Data/SocialMedia/Posts.json b/samples/Graph/Data/SocialMedia/Posts.json
new file mode 100644
index 000000000..6249839ca
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Posts.json
@@ -0,0 +1,17 @@
+{
+  "id": "Posts",
+  "namespace": "SocialMedia",
+  "path": "SocialMedia/Posts",
+  "name": "Posts",
+  "nodeType": "Markdown",
+  "category": "SocialMedia",
+  "description": "Calendar overview of scheduled and published social media posts",
+  "icon": "/static/NodeTypeIcons/document.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "MarkdownDocument",
+    "title": "Social Media Calendar",
+    "icon": "/static/NodeTypeIcons/document.svg",
+    "content": "# Social Media Calendar\n\nPlan and review your scheduled LinkedIn posts. Use the arrows to switch months and the filter buttons to narrow down to a single profile. By default the calendar shows posts from your own profiles.\n\n@SocialMedia/Post/Calendar\n"
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Profile.json b/samples/Graph/Data/SocialMedia/Profile.json
new file mode 100644
index 000000000..3d36c72a9
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Profile.json
@@ -0,0 +1,19 @@
+{
+  "id": "Profile",
+  "namespace": "SocialMedia",
+  "name": "Social Media Profile",
+  "nodeType": "NodeType",
+  "category": "Types",
+  "description": "A social media profile owned by a user (LinkedIn, X, Instagram, ...)",
+  "icon": "/static/NodeTypeIcons/person.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "NodeTypeDefinition",
+    "id": "Profile",
+    "namespace": "SocialMedia",
+    "displayName": "Social Media Profile",
+    "iconName": "Person",
+    "description": "A social media profile owned by a user",
+    "configuration": "config => config.WithContentType<SocialMediaProfile>().AddData(data => data.AddSource(source => source.WithType<Platform>(t => t.WithInitialData(Platform.All)))).AddDefaultLayoutAreas().AddLayout(layout => layout.AddSocialMediaProfileLayoutAreas().WithDefaultArea(\"Detail\"))"
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Profile/Roland-LinkedIn.json b/samples/Graph/Data/SocialMedia/Profile/Roland-LinkedIn.json
new file mode 100644
index 000000000..e19d33ba4
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Profile/Roland-LinkedIn.json
@@ -0,0 +1,17 @@
+{
+  "id": "Roland-LinkedIn",
+  "namespace": "SocialMedia/Profile",
+  "path": "SocialMedia/Profile/Roland-LinkedIn",
+  "name": "Roland on LinkedIn",
+  "nodeType": "SocialMedia/Profile",
+  "icon": "/static/NodeTypeIcons/person.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaProfile",
+    "name": "Roland on LinkedIn",
+    "platform": "LinkedIn",
+    "owner": "rbuergi@systemorph.com",
+    "profileUrl": "https://www.linkedin.com/in/rolandbuergi/",
+    "bio": "Building MeshWeaver \u2014 collaborative actor-based runtime for data, AI and reactive UIs."
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Profile/Sarah-LinkedIn.json b/samples/Graph/Data/SocialMedia/Profile/Sarah-LinkedIn.json
new file mode 100644
index 000000000..29c2dbb2f
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Profile/Sarah-LinkedIn.json
@@ -0,0 +1,17 @@
+{
+  "id": "Sarah-LinkedIn",
+  "namespace": "SocialMedia/Profile",
+  "path": "SocialMedia/Profile/Sarah-LinkedIn",
+  "name": "Sarah on LinkedIn",
+  "nodeType": "SocialMedia/Profile",
+  "icon": "/static/NodeTypeIcons/person.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaProfile",
+    "name": "Sarah on LinkedIn",
+    "platform": "LinkedIn",
+    "owner": "sarah@example.com",
+    "profileUrl": "https://www.linkedin.com/in/sarah-example/",
+    "bio": "Marketing lead. Posts about product launches and customer stories."
+  }
+}
diff --git a/samples/Graph/Data/SocialMedia/Profile/_Source/Platform.cs b/samples/Graph/Data/SocialMedia/Profile/_Source/Platform.cs
new file mode 100644
index 000000000..ae7655974
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Profile/_Source/Platform.cs
@@ -0,0 +1,39 @@
+// <meshweaver>
+// Id: Platform
+// DisplayName: Social Media Platform
+// </meshweaver>
+
+public record Platform
+{
+    [Key]
+    public string Id { get; init; } = string.Empty;
+
+    [Required]
+    public string Name { get; init; } = string.Empty;
+
+    public string Emoji { get; init; } = string.Empty;
+
+    public string Color { get; init; } = "#0a66c2";
+
+    public int Order { get; init; }
+
+    public static readonly Platform LinkedIn = new()
+    {
+        Id = "LinkedIn", Name = "LinkedIn", Emoji = "\ud83d\udcbc", Color = "#0a66c2", Order = 0
+    };
+
+    public static readonly Platform Twitter = new()
+    {
+        Id = "Twitter", Name = "X / Twitter", Emoji = "\ud83d\udc26", Color = "#000000", Order = 1
+    };
+
+    public static readonly Platform Instagram = new()
+    {
+        Id = "Instagram", Name = "Instagram", Emoji = "\ud83d\udcf7", Color = "#e1306c", Order = 2
+    };
+
+    public static readonly Platform[] All = [LinkedIn, Twitter, Instagram];
+
+    public static Platform GetById(string? id) =>
+        All.FirstOrDefault(p => p.Id == id) ?? LinkedIn;
+}
diff --git a/samples/Graph/Data/SocialMedia/Profile/_Source/SocialMediaProfile.cs b/samples/Graph/Data/SocialMedia/Profile/_Source/SocialMediaProfile.cs
new file mode 100644
index 000000000..0dd054018
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Profile/_Source/SocialMediaProfile.cs
@@ -0,0 +1,31 @@
+// <meshweaver>
+// Id: SocialMediaProfile
+// DisplayName: Social Media Profile
+// </meshweaver>
+
+using MeshWeaver.Domain;
+
+public record SocialMediaProfile
+{
+    [Required]
+    [MeshNodeProperty(nameof(MeshNode.Name))]
+    public string Name { get; init; } = string.Empty;
+
+    [Required]
+    [Dimension<Platform>]
+    [UiControl(Style = "width: 200px;")]
+    public string Platform { get; init; } = "LinkedIn";
+
+    [Required]
+    [DisplayName("Owner email")]
+    public string Owner { get; init; } = string.Empty;
+
+    [DisplayName("Profile URL")]
+    public string? ProfileUrl { get; init; }
+
+    [DisplayName("Avatar URL")]
+    public string? AvatarUrl { get; init; }
+
+    [Markdown(EditorHeight = "120px")]
+    public string? Bio { get; init; }
+}
diff --git a/samples/Graph/Data/SocialMedia/Profile/_Source/SocialMediaProfileLayoutAreas.cs b/samples/Graph/Data/SocialMedia/Profile/_Source/SocialMediaProfileLayoutAreas.cs
new file mode 100644
index 000000000..d44e33ef9
--- /dev/null
+++ b/samples/Graph/Data/SocialMedia/Profile/_Source/SocialMediaProfileLayoutAreas.cs
@@ -0,0 +1,70 @@
+// <meshweaver>
+// Id: SocialMediaProfileLayoutAreas
+// DisplayName: Social Media Profile Views
+// </meshweaver>
+
+using System.Text.Json;
+using System.Web;
+using MeshWeaver.Layout.Composition;
+using MeshWeaver.Mesh.Services;
+
+public static class SocialMediaProfileLayoutAreas
+{
+    public static LayoutDefinition AddSocialMediaProfileLayoutAreas(this LayoutDefinition layout) =>
+        layout.WithView("Detail", Detail);
+
+    private static string? GetProp(MeshNode node, string prop)
+    {
+        if (node.Content is not JsonElement json) return null;
+        if (json.TryGetProperty(prop, out var p) && p.ValueKind == JsonValueKind.String) return p.GetString();
+        var pascal = char.ToUpperInvariant(prop[0]) + prop.Substring(1);
+        return json.TryGetProperty(pascal, out var pp) && pp.ValueKind == JsonValueKind.String ? pp.GetString() : null;
+    }
+
+    public static IObservable<UiControl?> Detail(LayoutAreaHost host, RenderingContext _)
+    {
+        var hubPath = host.Hub.Address.ToString();
+        var meshService = host.Hub.ServiceProvider.GetRequiredService<IMeshService>();
+
+        return host.Workspace.GetStream<MeshNode>()!
+            .Select(nodes =>
+            {
+                var node = nodes?.FirstOrDefault(n => n.Path == hubPath);
+                if (node is null) return (UiControl?)Controls.Markdown("*Profile not found.*");
+
+                var name = node.Name ?? GetProp(node, "name") ?? "Profile";
+                var platformId = GetProp(node, "platform") ?? "LinkedIn";
+                var platform = Platform.GetById(platformId);
+                var owner = GetProp(node, "owner") ?? "";
+                var profileUrl = GetProp(node, "profileUrl");
+                var avatarUrl = GetProp(node, "avatarUrl");
+                var bio = GetProp(node, "bio");
+
+                var avatar = !string.IsNullOrEmpty(avatarUrl)
+                    ? $"<img src=\"{HttpUtility.HtmlAttributeEncode(avatarUrl)}\" alt=\"avatar\" style=\"width:96px;height:96px;border-radius:50%;object-fit:cover;\" />"
+                    : $"<div style=\"width:96px;height:96px;border-radius:50%;background:{platform.Color};color:white;display:flex;align-items:center;justify-content:center;font-size:36px;\">{platform.Emoji}</div>";
+
+                var link = !string.IsNullOrEmpty(profileUrl)
+                    ? $"<a href=\"{HttpUtility.HtmlAttributeEncode(profileUrl)}\" target=\"_blank\" rel=\"noopener\">Open profile \u2197</a>"
+                    : "<span style=\"color:#888;\">No profile URL</span>";
+
+                var html = $$"""
+                    <div style="display:flex;gap:24px;align-items:center;padding:16px;">
+                      {{avatar}}
+                      <div>
+                        <h2 style="margin:0 0 4px 0;">{{HttpUtility.HtmlEncode(name)}}</h2>
+                        <div style="color:{{platform.Color}};font-weight:600;margin-bottom:4px;">{{platform.Emoji}} {{HttpUtility.HtmlEncode(platform.Name)}}</div>
+                        <div style="color:#666;margin-bottom:8px;">Owner: {{HttpUtility.HtmlEncode(owner)}}</div>
+                        <div>{{link}}</div>
+                      </div>
+                    </div>
+                    """;
+
+                var stack = Controls.Stack.WithStyle("padding: 16px;")
+                    .WithView(Controls.Html(html));
+                if (!string.IsNullOrEmpty(bio))
+                    stack = stack.WithView(Controls.Markdown(bio));
+                return (UiControl?)stack;
+            });
+    }
+}
diff --git a/samples/Graph/Data/User/Alice.json b/samples/Graph/Data/User/Alice.json
index 941459f5b..a2b8d55cc 100644
--- a/samples/Graph/Data/User/Alice.json
+++ b/samples/Graph/Data/User/Alice.json
@@ -8,6 +8,7 @@
   "content": {
     "$type": "User",
     "email": "alice.chen@meshweaver.io",
-    "bio": "Software engineer and project contributor."
+    "bio": "Software engineer and project contributor.",
+    "pinnedPaths": ["Doc"]
   }
 }
diff --git a/samples/Graph/Data/User/Bob.json b/samples/Graph/Data/User/Bob.json
index 30b66de78..a53f803ed 100644
--- a/samples/Graph/Data/User/Bob.json
+++ b/samples/Graph/Data/User/Bob.json
@@ -8,6 +8,7 @@
   "content": {
     "$type": "User",
     "email": "bob.smith@meshweaver.io",
-    "bio": "Software engineer and project contributor."
+    "bio": "Software engineer and project contributor.",
+    "pinnedPaths": ["Doc"]
   }
 }
diff --git a/samples/Graph/Data/User/Carol.json b/samples/Graph/Data/User/Carol.json
index 273be92dc..e9029f9c1 100644
--- a/samples/Graph/Data/User/Carol.json
+++ b/samples/Graph/Data/User/Carol.json
@@ -8,6 +8,7 @@
   "content": {
     "$type": "User",
     "email": "carol.johnson@meshweaver.io",
-    "bio": "Software engineer and project contributor."
+    "bio": "Software engineer and project contributor.",
+    "pinnedPaths": ["Doc"]
   }
 }
diff --git a/samples/Graph/Data/User/David.json b/samples/Graph/Data/User/David.json
index 25bcf73bc..65812c1e0 100644
--- a/samples/Graph/Data/User/David.json
+++ b/samples/Graph/Data/User/David.json
@@ -8,6 +8,7 @@
   "content": {
     "$type": "User",
     "email": "david.lee@meshweaver.io",
-    "bio": "Software engineer and project contributor."
+    "bio": "Software engineer and project contributor.",
+    "pinnedPaths": ["Doc"]
   }
 }
diff --git a/samples/Graph/Data/User/Emma.json b/samples/Graph/Data/User/Emma.json
index cbcc5ba06..6a542fb39 100644
--- a/samples/Graph/Data/User/Emma.json
+++ b/samples/Graph/Data/User/Emma.json
@@ -8,6 +8,7 @@
   "content": {
     "$type": "User",
     "email": "emma.wilson@meshweaver.io",
-    "bio": "Software engineer and project contributor."
+    "bio": "Software engineer and project contributor.",
+    "pinnedPaths": ["Doc"]
   }
 }
diff --git a/samples/Graph/Data/User/Roland.json b/samples/Graph/Data/User/Roland.json
index 691c0361f..f07375258 100644
--- a/samples/Graph/Data/User/Roland.json
+++ b/samples/Graph/Data/User/Roland.json
@@ -8,6 +8,7 @@
   "content": {
     "$type": "User",
     "email": "rbuergi@systemorph.com",
-    "bio": "Founder of Systemorph and creator of MeshWeaver."
+    "bio": "Founder of Systemorph and creator of MeshWeaver.",
+    "pinnedPaths": ["Doc"]
   }
 }
diff --git a/samples/Graph/Data/User/Samuel.json b/samples/Graph/Data/User/Samuel.json
index d15419703..f626bb32b 100644
--- a/samples/Graph/Data/User/Samuel.json
+++ b/samples/Graph/Data/User/Samuel.json
@@ -8,6 +8,7 @@
   "content": {
     "$type": "User",
     "email": "sglauser@systemorph.com",
-    "bio": "Software engineer and MeshWeaver contributor."
+    "bio": "Software engineer and MeshWeaver contributor.",
+    "pinnedPaths": ["Doc"]
   }
 }
diff --git a/src/MeshWeaver.AI.AzureFoundry/AzureClaudeChatClient.cs b/src/MeshWeaver.AI.AzureFoundry/AzureClaudeChatClient.cs
index b43300f13..a96fc6f7c 100644
--- a/src/MeshWeaver.AI.AzureFoundry/AzureClaudeChatClient.cs
+++ b/src/MeshWeaver.AI.AzureFoundry/AzureClaudeChatClient.cs
@@ -134,6 +134,11 @@ public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
         string? currentToolName = null;
         var currentToolInput = new StringBuilder();
 
+        // Cumulative token counters across the stream (Anthropic emits input-tokens
+        // once on message_start and cumulative output-tokens on message_delta).
+        var inputTokens = 0;
+        var outputTokens = 0;
+
         while ((line = await reader.ReadLineAsync(cancellationToken)) != null)
         {
             if (string.IsNullOrEmpty(line) || !line.StartsWith("data: "))
@@ -160,6 +165,13 @@ public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
             {
                 case "message_start":
                     currentRole = streamEvent.Message?.Role ?? "assistant";
+                    if (streamEvent.Message?.Usage is { } startUsage)
+                    {
+                        inputTokens = startUsage.InputTokens;
+                        // Anthropic reports cumulative output tokens on message_delta;
+                        // seed with any initial value on message_start.
+                        outputTokens = startUsage.OutputTokens;
+                    }
                     break;
 
                 case "content_block_start":
@@ -216,6 +228,12 @@ public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
                     break;
 
                 case "message_delta":
+                    if (streamEvent.Usage is { } deltaUsage)
+                    {
+                        // Anthropic: output_tokens on message_delta is the running cumulative
+                        // count. Keep the latest so the final UsageContent below has the total.
+                        outputTokens = deltaUsage.OutputTokens;
+                    }
                     if (streamEvent.Delta?.StopReason != null)
                     {
                         yield return new ChatResponseUpdate(ChatRole.Assistant, string.Empty)
@@ -224,6 +242,22 @@ public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
                         };
                     }
                     break;
+
+                case "message_stop":
+                    // Final UsageContent carries the totals — ThreadExecution stamps the
+                    // response cell's InputTokens/OutputTokens/TotalTokens from this.
+                    if (inputTokens > 0 || outputTokens > 0)
+                    {
+                        yield return new ChatResponseUpdate(ChatRole.Assistant, [
+                            new UsageContent(new UsageDetails
+                            {
+                                InputTokenCount = inputTokens,
+                                OutputTokenCount = outputTokens,
+                                TotalTokenCount = inputTokens + outputTokens
+                            })
+                        ]);
+                    }
+                    break;
             }
         }
     }
@@ -578,6 +612,8 @@ private class ClaudeStreamEvent
         public ClaudeStreamDelta? Delta { get; set; }
         public ClaudeStreamContentBlock? ContentBlock { get; set; }
         public int? Index { get; set; }
+        /// <summary>Populated on the <c>message_delta</c> event — cumulative output-token count.</summary>
+        public ClaudeUsage? Usage { get; set; }
     }
 
     private class ClaudeStreamMessage
@@ -586,6 +622,8 @@ private class ClaudeStreamMessage
         public string? Type { get; set; }
         public string? Role { get; set; }
         public string? Model { get; set; }
+        /// <summary>Populated on the <c>message_start</c> event — input-token count for the turn.</summary>
+        public ClaudeUsage? Usage { get; set; }
     }
 
     private class ClaudeStreamContentBlock
diff --git a/src/MeshWeaver.AI/AgentChatClient.cs b/src/MeshWeaver.AI/AgentChatClient.cs
index 7fd7753c3..fbcb05f92 100644
--- a/src/MeshWeaver.AI/AgentChatClient.cs
+++ b/src/MeshWeaver.AI/AgentChatClient.cs
@@ -652,6 +652,15 @@ public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
                             AuthorName = currentAgentName ?? "Assistant"
                         };
                     }
+                    else if (content is UsageContent)
+                    {
+                        // Forward token-usage content so ThreadExecution can record
+                        // InputTokens / OutputTokens / TotalTokens on the response cell.
+                        yield return new ChatResponseUpdate(ChatRole.Assistant, [content])
+                        {
+                            AuthorName = currentAgentName ?? "Assistant"
+                        };
+                    }
                 }
             }
 
@@ -722,6 +731,13 @@ public async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
                                 AuthorName = currentAgentName ?? "Assistant"
                             };
                         }
+                        else if (content is UsageContent)
+                        {
+                            yield return new ChatResponseUpdate(ChatRole.Assistant, [content])
+                            {
+                                AuthorName = currentAgentName ?? "Assistant"
+                            };
+                        }
                     }
                 }
 
diff --git a/src/MeshWeaver.AI/AgentView.cs b/src/MeshWeaver.AI/AgentView.cs
index 77222032e..323b3d83e 100644
--- a/src/MeshWeaver.AI/AgentView.cs
+++ b/src/MeshWeaver.AI/AgentView.cs
@@ -447,7 +447,28 @@ private static UiControl BuildEditLayout(LayoutAreaHost host, AgentConfiguration
                     new DataChangeRequest { ChangedBy = actx.Host.Stream.ClientId }.WithUpdates(updatedAgent),
                     o => o.WithTarget(hubAddress))!;
                 var callbackResponse = await actx.Host.Hub.RegisterCallback(delivery, (d, _) => Task.FromResult(d), cts.Token);
-                var responseMsg = ((IMessageDelivery<DataChangeResponse>)callbackResponse).Message;
+
+                // Handle routing failures (e.g., agent hub unreachable) and unexpected
+                // response shapes before touching the DataChangeResponse fields.
+                if (callbackResponse is IMessageDelivery<DeliveryFailure> deliveryFailure)
+                {
+                    var dialog = Controls.Dialog(
+                        Controls.Markdown($"**Error saving:**\n\n{deliveryFailure.Message.Message ?? "Delivery failed"}"),
+                        "Save Failed"
+                    ).WithSize("M");
+                    actx.Host.UpdateArea(DialogControl.DialogArea, dialog);
+                    return;
+                }
+                if (callbackResponse is not IMessageDelivery<DataChangeResponse> dataChange)
+                {
+                    var dialog = Controls.Dialog(
+                        Controls.Markdown($"**Error saving:** Unexpected response `{callbackResponse.Message?.GetType().Name ?? "null"}`."),
+                        "Save Failed"
+                    ).WithSize("M");
+                    actx.Host.UpdateArea(DialogControl.DialogArea, dialog);
+                    return;
+                }
+                var responseMsg = dataChange.Message;
 
                 if (responseMsg.Log.Status != ActivityStatus.Succeeded)
                 {
diff --git a/src/MeshWeaver.AI/ChatClientAgentFactory.cs b/src/MeshWeaver.AI/ChatClientAgentFactory.cs
index 5a92a08dc..bae7758c7 100644
--- a/src/MeshWeaver.AI/ChatClientAgentFactory.cs
+++ b/src/MeshWeaver.AI/ChatClientAgentFactory.cs
@@ -256,185 +256,8 @@ protected virtual IEnumerable<AITool> GetAgentTools(
             var delegationTool = DelegationTool.CreateUnifiedDelegationTool(
                 agentConfig,
                 hierarchyAgents,
-                executeAsync: (agentName, task, context, cancellationToken) =>
-                {
-                    // Resolve the target agent by name (strip path prefix if present)
-                    var targetId = agentName.Split('/').Last();
-                    if (!allAgents.TryGetValue(targetId, out var targetAgent))
-                    {
-                        return Task.FromResult(new DelegationResult
-                        {
-                            AgentName = agentName,
-                            Task = task,
-                            Result = $"Agent '{agentName}' not found",
-                            Success = false
-                        });
-                    }
-
-                    var execCtx = chat.ExecutionContext;
-                    var userIdentity = execCtx?.UserAccessContext?.ObjectId ?? "(no-user)";
-
-                    // Guard: limit delegation depth to prevent recursive delegation.
-                    // Count segments after _Thread/ — each delegation adds msgId/subThreadId (2 segments per level).
-                    // Root thread: Org/_Thread/threadId → 0 extra segments → depth 0
-                    // 1st delegation: Org/_Thread/threadId/msgId/subId → 2 extra → depth 1
-                    // 2nd delegation: Org/_Thread/threadId/msgId/subId/msgId2/subId2 → 4 extra → depth 2
-                    var threadPath = execCtx?.ThreadPath ?? "";
-                    var threadIdx = threadPath.IndexOf("/_Thread/");
-                    var depth = 0;
-                    if (threadIdx >= 0)
-                    {
-                        var afterThread = threadPath[(threadIdx + "/_Thread/".Length)..];
-                        var segments = afterThread.Split('/').Length;
-                        depth = (segments - 1) / 2; // subtract the thread id, each delegation = 2 segments
-                    }
-                    if (depth >= 2)
-                    {
-                        Logger.LogWarning("[Delegation] Max delegation depth ({Depth}) reached at {ThreadPath} for {Source} → {Target}",
-                            depth, threadPath, agentConfig.Id, targetId);
-                        return Task.FromResult(new DelegationResult
-                        {
-                            AgentName = targetId, Task = task,
-                            Result = $"Maximum delegation depth reached ({depth}). You must handle this task directly without further delegation.",
-                            Success = false
-                        });
-                    }
-
-                    Logger.LogInformation(
-                        "[Delegation] {Source} → {Target}, user={User}, depth={Depth}, task={Task}",
-                        agentConfig.Id, targetId, userIdentity, depth, task.Length > 100 ? task[..97] + "..." : task);
-
-                    if (execCtx == null)
-                    {
-                        return Task.FromResult(new DelegationResult
-                        {
-                            AgentName = targetId,
-                            Task = task,
-                            Result = "No execution context available for delegation",
-                            Success = false
-                        });
-                    }
-
-                    // TCS completed by subscription callbacks — framework awaits this, not our code
-                    var tcs = new TaskCompletionSource<DelegationResult>();
-                    var meshService = Hub.ServiceProvider.GetRequiredService<IMeshService>();
-                    var workspace = Hub.GetWorkspace();
-
-                    // Access context is restored by WrapToolWithAccessContext — no need to set it here.
-
-                    var parentMsgPath = $"{execCtx.ThreadPath}/{execCtx.ResponseMessageId}";
-                    // MainNode for sub-thread = parent thread's MainNode (content node).
-                    // ContextPath comes from the thread execution context which is set from
-                    // the thread node's MainNode (e.g., "PartnerRe/AIConsulting").
-                    var mainEntityPath = execCtx.ContextPath ?? context ?? execCtx.ThreadPath;
-
-                    // Build sub-thread with pre-populated messages
-                    var (subThreadNode, userMsgId, responseMsgId) = ThreadNodeType.BuildThreadWithMessages(
-                        parentMsgPath, task, createdBy: execCtx.UserAccessContext?.ObjectId,
-                        agentName: targetId);
-                    subThreadNode = subThreadNode with { MainNode = mainEntityPath };
-                    var subThreadPath = subThreadNode.Path!;
-
-                    // Store delegation path keyed by display name for parallel-safe lookup.
-                    var delegationDisplayName = $"Delegating to {targetId}...";
-                    chat.DelegationPaths[delegationDisplayName] = subThreadPath;
-                    chat.LastDelegationPath = subThreadPath;
-                    chat.UpdateDelegationStatus?.Invoke(delegationDisplayName);
-
-                    // Create cells FIRST, then thread. WatchForExecution starts execution
-                    // when it sees IsExecuting=true on the thread.
-                    Logger.LogInformation("[Delegation] Creating cells for sub-thread {Path}: user={UserMsgId}, response={ResponseMsgId}", subThreadPath, userMsgId, responseMsgId);
-                    meshService.CreateNode(new MeshNode(userMsgId, subThreadPath)
-                    {
-                        NodeType = ThreadMessageNodeType.NodeType, MainNode = mainEntityPath,
-                        Content = new ThreadMessage
-                        {
-                            Role = "user", Text = task, Timestamp = DateTime.UtcNow,
-                            Type = ThreadMessageType.ExecutedInput, CreatedBy = execCtx.UserAccessContext?.ObjectId
-                        }
-                    }).Subscribe(_ => { }, error => Logger.LogError(error, "[Delegation] User cell creation failed for {Path}", subThreadPath));
-
-                    meshService.CreateNode(new MeshNode(responseMsgId, subThreadPath)
-                    {
-                        NodeType = ThreadMessageNodeType.NodeType, MainNode = mainEntityPath,
-                        Content = new ThreadMessage
-                        {
-                            Role = "assistant", Text = "", Timestamp = DateTime.UtcNow,
-                            Type = ThreadMessageType.AgentResponse, AgentName = targetId
-                        }
-                    }).Subscribe(_ => { }, error => Logger.LogError(error, "[Delegation] Response cell creation failed for {Path}", subThreadPath));
-
-                    Logger.LogInformation("[Delegation] Creating sub-thread at {Path}", subThreadPath);
-                    meshService.CreateNode(subThreadNode).Subscribe(
-                        _ =>
-                        {
-                            Logger.LogInformation("[Delegation] Sub-thread created at {Path}, watching for completion", subThreadPath);
-
-                            // Watch the sub-thread's state via ObserveQuery — when IsExecuting becomes false, delegation is done.
-                            var meshSvc = Hub.ServiceProvider.GetService<IMeshService>();
-                            bool IsComplete(QueryResultChange<MeshNode> c)
-                            {
-                                foreach (var n in c.Items)
-                                    if (n.Content is MeshThread { IsExecuting: false, PendingUserMessage: null })
-                                        return true;
-                                return false;
-                            }
-                            var filtered = System.Reactive.Linq.Observable.Where(
-                                meshSvc!.ObserveQuery<MeshNode>(MeshQueryRequest.FromQuery($"path:{subThreadPath}")),
-                                IsComplete);
-                            System.Reactive.Linq.Observable.Timeout(
-                                System.Reactive.Linq.Observable.Take(filtered, 1),
-                                TimeSpan.FromSeconds(30))
-                                .Subscribe(
-                                    change =>
-                                    {
-                                        var node = change.Items.FirstOrDefault();
-                                        var thread = node?.Content as MeshThread;
-                                        // Read the response from the response message cell
-                                        var responseText = $"Delegation to {targetId} completed.";
-                                        Logger.LogInformation("[Delegation] Completed: {Path}", subThreadPath);
-                                        tcs.TrySetResult(new DelegationResult
-                                        {
-                                            AgentName = targetId, Task = task,
-                                            Result = responseText,
-                                            Success = true,
-                                            ThreadId = subThreadPath
-                                        });
-                                    },
-                                    ex =>
-                                    {
-                                        Logger.LogWarning(ex, "[Delegation] Watch failed for {Path}", subThreadPath);
-                                        tcs.TrySetResult(new DelegationResult
-                                        {
-                                            AgentName = targetId, Task = task,
-                                            Result = $"Delegation timed out: {ex.Message}",
-                                            Success = false, ThreadId = subThreadPath
-                                        });
-                                    });
-                        },
-                        error =>
-                        {
-                            Logger.LogWarning(error, "[Delegation] Failed to create sub-thread at {Path} for {Target}, Hub={Hub}", subThreadPath, targetId, Hub.Address);
-                            tcs.TrySetResult(new DelegationResult
-                            {
-                                AgentName = targetId, Task = task,
-                                Result = $"Node creation failed: {error.Message}", Success = false
-                            });
-                        });
-
-                    // Register cancellation to prevent infinite hang if sub-thread routing fails
-                    cancellationToken.Register(() =>
-                    {
-                        tcs.TrySetResult(new DelegationResult
-                        {
-                            AgentName = targetId, Task = task,
-                            Result = $"Delegation to {targetId} was cancelled.",
-                            Success = false
-                        });
-                    });
-
-                    return tcs.Task;
-                },
+                executeAsync: (agentName, task, context, ct) =>
+                    ExecuteDelegationAsync(agentConfig, allAgents, chat, agentName, task, context, ct),
                 Logger);
 
             Logger.LogInformation("Created unified delegation tool for agent {AgentName} with {HierarchyCount} hierarchy agents",
@@ -459,6 +282,168 @@ bool IsComplete(QueryResultChange<MeshNode> c)
         }
     }
 
+    /// <summary>
+    /// Dispatches a sub-thread and yields its streaming text deltas as <see cref="IAsyncEnumerable{string}"/>.
+    ///
+    /// The sub-thread is created fire-and-forget via <c>IMeshService.CreateNode</c> (no await on
+    /// completion). Its response-message cell is observed through a workspace remote stream; each
+    /// incremental delta is yielded up to the <see cref="FunctionInvokingChatClient"/>, and via
+    /// that — through the parent agent's streaming response — into the parent's response bubble.
+    ///
+    /// No <see cref="Task{string}"/>, no <see cref="TaskCompletionSource{T}"/>, no
+    /// <c>ObserveQuery</c>. The only awaits here are on the channel reader which drains on
+    /// cancellation or on the sub-thread's CompletedAt flip — neither touches the hub scheduler
+    /// (both run on the Task.Run thread pool).
+    /// </summary>
+    private async IAsyncEnumerable<string> ExecuteDelegationAsync(
+        AgentConfiguration agentConfig,
+        IReadOnlyDictionary<string, ChatClientAgent> allAgents,
+        IAgentChat chat,
+        string agentName,
+        string task,
+        string? context,
+        [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        // Resolve target agent (strip path prefix if present).
+        var targetId = agentName.Split('/').Last();
+        if (!allAgents.TryGetValue(targetId, out _))
+        {
+            yield return $"Agent '{agentName}' not found";
+            yield break;
+        }
+
+        var execCtx = chat.ExecutionContext;
+        if (execCtx == null)
+        {
+            yield return "No execution context available for delegation";
+            yield break;
+        }
+
+        // Guard: limit delegation depth. See comment on original version for segment math.
+        var threadPath = execCtx.ThreadPath;
+        var threadIdx = threadPath.IndexOf("/_Thread/", StringComparison.Ordinal);
+        var depth = 0;
+        if (threadIdx >= 0)
+        {
+            var afterThread = threadPath[(threadIdx + "/_Thread/".Length)..];
+            var segments = afterThread.Split('/').Length;
+            depth = (segments - 1) / 2;
+        }
+        if (depth >= 2)
+        {
+            Logger.LogWarning("[Delegation] Max depth reached at {ThreadPath}: {Source} → {Target}",
+                threadPath, agentConfig.Id, targetId);
+            yield return $"Maximum delegation depth reached ({depth}). Handle this task directly.";
+            yield break;
+        }
+
+        Logger.LogInformation("[Delegation] {Source} → {Target}, depth={Depth}, task={Task}",
+            agentConfig.Id, targetId, depth, task.Length > 100 ? task[..97] + "..." : task);
+
+        var meshService = Hub.ServiceProvider.GetRequiredService<IMeshService>();
+        var parentMsgPath = $"{threadPath}/{execCtx.ResponseMessageId}";
+        var mainEntityPath = execCtx.ContextPath ?? context ?? threadPath;
+
+        // Build the sub-thread with IsExecuting=true + PendingUserMessage so its hub's
+        // WatchForExecution starts streaming on activation.
+        var (subThreadNode, userMsgId, responseMsgId) = ThreadNodeType.BuildThreadWithMessages(
+            parentMsgPath, task,
+            createdBy: execCtx.UserAccessContext?.ObjectId,
+            agentName: targetId);
+        subThreadNode = subThreadNode with { MainNode = mainEntityPath };
+        var subThreadPath = subThreadNode.Path!;
+        var responsePath = $"{subThreadPath}/{responseMsgId}";
+
+        // Stamp the delegation path so the parent's bubble can render the inline link.
+        var delegationDisplayName = $"Delegating to {targetId}...";
+        chat.DelegationPaths[delegationDisplayName] = subThreadPath;
+        chat.LastDelegationPath = subThreadPath;
+        chat.UpdateDelegationStatus?.Invoke(delegationDisplayName);
+
+        Logger.LogInformation("[Delegation] Dispatch sub-thread {Path}: user={UserMsgId}, response={ResponseMsgId}",
+            subThreadPath, userMsgId, responseMsgId);
+
+        // Create satellite cells + thread node reactively (no await).
+        meshService.CreateNode(new MeshNode(userMsgId, subThreadPath)
+        {
+            NodeType = ThreadMessageNodeType.NodeType,
+            MainNode = mainEntityPath,
+            Content = new ThreadMessage
+            {
+                Role = "user", Text = task, Timestamp = DateTime.UtcNow,
+                Type = ThreadMessageType.ExecutedInput,
+                CreatedBy = execCtx.UserAccessContext?.ObjectId
+            }
+        }).Subscribe(_ => { },
+            error => Logger.LogDebug(error, "[Delegation] User cell create for {Path} returned error", subThreadPath));
+
+        meshService.CreateNode(new MeshNode(responseMsgId, subThreadPath)
+        {
+            NodeType = ThreadMessageNodeType.NodeType,
+            MainNode = mainEntityPath,
+            Content = new ThreadMessage
+            {
+                Role = "assistant", Text = "", Timestamp = DateTime.UtcNow,
+                Type = ThreadMessageType.AgentResponse, AgentName = targetId
+            }
+        }).Subscribe(_ => { },
+            error => Logger.LogDebug(error, "[Delegation] Response cell create for {Path} returned error", subThreadPath));
+
+        meshService.CreateNode(subThreadNode).Subscribe(
+            _ => Logger.LogInformation("[Delegation] Sub-thread created at {Path}", subThreadPath),
+            error => Logger.LogWarning(error, "[Delegation] Sub-thread create failed at {Path}", subThreadPath));
+
+        yield return $"\n\n**Delegating to {targetId}…**\n\n";
+
+        // Open a channel fed by the sub-thread's response-cell remote stream. We yield
+        // each text delta as it arrives (computed against lastText so we never double-emit).
+        var channel = System.Threading.Channels.Channel.CreateUnbounded<string>(
+            new System.Threading.Channels.UnboundedChannelOptions
+            {
+                SingleReader = true,
+                SingleWriter = false
+            });
+
+        var workspace = Hub.GetWorkspace();
+        var lastText = "";
+        var subscription = workspace.GetRemoteStream<MeshNode, MeshNodeReference>(
+                new Address(responsePath), new MeshNodeReference())
+            ?.Subscribe(
+                change =>
+                {
+                    var msg = change.Value?.Content as ThreadMessage;
+                    if (msg == null) return;
+                    var current = msg.Text ?? "";
+                    if (current.Length > lastText.Length)
+                    {
+                        var delta = current[lastText.Length..];
+                        lastText = current;
+                        channel.Writer.TryWrite(delta);
+                    }
+                    if (msg.CompletedAt is not null)
+                        channel.Writer.TryComplete();
+                },
+                ex => channel.Writer.TryComplete(ex),
+                () => channel.Writer.TryComplete());
+
+        // Safety timeout so a never-completing sub-thread can't pin this iterator forever.
+        using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(5));
+        using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeout.Token);
+
+        try
+        {
+            await foreach (var delta in channel.Reader.ReadAllAsync(linked.Token))
+            {
+                yield return delta;
+            }
+        }
+        finally
+        {
+            subscription?.Dispose();
+            Logger.LogInformation("[Delegation] Stream closed for sub-thread {Path}", subThreadPath);
+        }
+    }
+
     /// <summary>
     /// Resolves a plugin reference to AITool instances.
     /// Built-in plugin "Mesh" is resolved directly; custom plugins are resolved from DI.
diff --git a/src/MeshWeaver.AI/Completion/AutocompleteClient.cs b/src/MeshWeaver.AI/Completion/AutocompleteClient.cs
index c9220e55c..070d76f8d 100644
--- a/src/MeshWeaver.AI/Completion/AutocompleteClient.cs
+++ b/src/MeshWeaver.AI/Completion/AutocompleteClient.cs
@@ -41,11 +41,13 @@ public async Task<AutocompleteResponse> GetCompletionsAsync(
                     new AutocompleteRequest(query, context?.Context),
                     o => o.WithTarget(address))!;
                 var callbackResponse = await hub.RegisterCallback(delivery, (d, _) => Task.FromResult(d), timeoutCts.Token);
-                var responseMsg = ((IMessageDelivery<AutocompleteResponse>)callbackResponse).Message;
 
-                if (responseMsg?.Items != null)
+                // Tolerate hub-level failures (target unreachable, timeout as DeliveryFailure)
+                // and any unexpected response type — skipping is the historical behaviour.
+                if (callbackResponse is IMessageDelivery<AutocompleteResponse> ok
+                    && ok.Message?.Items != null)
                 {
-                    allItems = allItems.AddRange(responseMsg.Items);
+                    allItems = allItems.AddRange(ok.Message.Items);
                 }
             }
             catch
diff --git a/src/MeshWeaver.AI/Data/Agent/Coder.md b/src/MeshWeaver.AI/Data/Agent/Coder.md
index cba425421..647ad458e 100644
--- a/src/MeshWeaver.AI/Data/Agent/Coder.md
+++ b/src/MeshWeaver.AI/Data/Agent/Coder.md
@@ -16,6 +16,24 @@ delegations:
 
 You are **Coder**, the node type engineering agent. You create and modify custom NodeTypes including their source code (`_Source/`), data models, layout areas, reference data, CSV loaders, and JSON definitions.
 
+# Decision Rule: NodeType vs Markdown
+
+When the user describes a **data model, object type, custom entity, or interactive view** — e.g. "social media posts with a calendar", "a task tracker", "risk model with charts", "build X as code" — you build a **NodeType**: a `NodeType` JSON + `_Source/` C# files + at least one instance JSON.
+
+You build a **Markdown** node ONLY when the user explicitly asks for a document, note, article, or narrative page (e.g. "write a doc about X", "draft a changelog", "add an FAQ page").
+
+**Never** use a Markdown node as a shortcut for something that should be typed data. If in doubt, build a NodeType — a user who wanted Markdown will say so.
+
+## Canonical Example
+
+The walkthrough at [SocialMedia model node type](@@Doc/DataMesh/SocialMedia) is the reference implementation. It has exactly the shape you should produce:
+
+- `Post.json`, `Profile.json` — NodeType definitions with a `configuration` lambda
+- `Post/_Source/*.cs`, `Profile/_Source/*.cs` — content record, reference data (`Platform`), layout areas
+- `Post/Post-001.json`, `Profile/Roland-LinkedIn.json` — instances alongside (IDs are meaningful — never `SamplePost`/`SampleProfile`)
+
+When asked to build "X as code" or "X as a model", open that example, mirror its shape, then adapt to the user's domain.
+
 # How Node Types Work
 
 A NodeType is a MeshNode with `nodeType: "NodeType"` whose `content` contains a `NodeTypeDefinition` with a `configuration` field. The configuration is a C# lambda expression compiled at startup.
@@ -234,7 +252,11 @@ When asked to create a node type:
    - CSV loaders if loading external data
 5. **Create the NodeType JSON** with the configuration lambda
 6. **Upload CSV files** to the content collection if needed
-7. **Verify** by getting the created nodes
+7. **Verify compilation** — this step is NOT optional:
+   - Call `GetDiagnostics('@{nodeTypePath}')` after every NodeType create/update.
+   - If `status: "Error"` → read `error`, fix the broken source or the NodeType JSON (often the fix is adding a `sources` entry pointing at another NodeType's `_Source` via `$self` or an absolute path), write the fix with `Update`/`Patch`, and re-check.
+   - Repeat until `status: "Ok"`. Only then is the NodeType "done".
+   - Alternative: a plain `Get('@{path}')` on any instance (or the NodeType itself) wraps the JSON with a `compilationError` field when the type failed to compile — useful when you want the node data and the compile status together.
 
 # Business Rules & Calculations
 
@@ -244,7 +266,7 @@ For domain-specific logic (financial models, reinsurance cession, risk analysis,
 2. **Business Rules** — pure C# calculation engines with no framework dependencies
 3. **Layout Areas** — reactive charts with `Chart.Create(DataSet.Bar(...))`, filter toolbars via `host.Toolbar(model, id)`, and `host.GetDataStream<T>(id).Select(...)` for reactive updates
 
-See the full walkthrough with a reinsurance cession example: [Business Rules & Calculations](@@Doc/Architecture/BusinessRules)
+See [SocialMedia](@@Doc/DataMesh/SocialMedia) for a plain-CRUD reference example, and [Business Rules & Calculations](@@Doc/Architecture/BusinessRules) for a chart/calculation-heavy reinsurance-cession example.
 
 For a production implementation, see:
 - [CededCashflows.cs](https://github.com/Systemorph/MeshWeaver.Reinsurance/blob/main/src/MeshWeaver.Reinsurance/Cession/CededCashflows.cs) — cession calculation engine
@@ -311,18 +333,25 @@ When asked to create an interactive document, create a Markdown node with the ex
 
 **NEVER just describe what you would create. ALWAYS call Create, Update, or Patch to write the actual content.** If you didn't call a write tool, nothing was produced. The user expects to see a real node with real content after your work — not a description of what could be created.
 
-- Asked to create a Markdown document? → Call `Create` with the full markdown content.
-- Asked to create a NodeType? → Call `Create` for each source file and the JSON definition.
+- Asked for a data model, type, or view? → Create a **NodeType**: JSON + `_Source/` `.cs` files + at least one sample instance. **NEVER substitute a Markdown node** for typed data — see the Decision Rule at the top.
+- Asked for a document, article, or narrative page? → Create a Markdown node with the full content.
+- Asked to create a NodeType? → Call `Create` for each source file and the JSON definition, **then call `GetDiagnostics` and don't stop until `status: "Ok"`**.
 - Asked to modify a node? → Call `Get` first, then `Update` with the modified content.
 
 **Every delegation MUST end with at least one write tool call.**
 
+**A NodeType is not "created" until `GetDiagnostics` says `Ok`.** Stopping after
+`Create` when compilation is failing leaves the user with a broken type and no
+way to use it. Iterate on the source files / `Sources` list until it compiles.
+
 # Tools
 
 Use the standard Mesh tools (Get, Search, Create, Update, Delete) to manage nodes.
 Use ContentCollection tools to upload CSV/data files.
 
 When creating `_Source/` files, create them as MeshNodes with:
-- `nodeType: "Code"`
+- `nodeType: "Code"` (NOT `"Markdown"` — source code files are always Code nodes)
 - `namespace: "{typePath}/_Source"`
-- `content` containing the C# source code
+- `content` shaped as `{ "$type": "CodeConfiguration", "code": "…", "language": "csharp" }` containing the C# source
+
+See [SocialMedia/Post/_Source](@@Doc/DataMesh/SocialMedia) for the concrete file naming and content shape to mirror.
diff --git a/src/MeshWeaver.AI/Data/Agent/NodeInitializer.md b/src/MeshWeaver.AI/Data/Agent/NodeInitializer.md
new file mode 100644
index 000000000..77f976f6f
--- /dev/null
+++ b/src/MeshWeaver.AI/Data/Agent/NodeInitializer.md
@@ -0,0 +1,59 @@
+---
+nodeType: Agent
+name: Node Initializer
+description: Generates a Name, PascalCase Id, and inline SVG icon from a short description. Used by the New-Node dialog and the Settings icon editor.
+icon: Sparkle
+category: Agents
+exposedInNavigator: false
+modelTier: light
+order: 998
+---
+
+You are **Node Initializer**. Given a short free-text description of a new knowledge-graph node, produce a concise display Name, a PascalCase Id, and a minimal inline SVG icon that represents the node.
+
+# Output format — strict
+
+Respond with EXACTLY these three labelled blocks in this order, nothing else:
+
+```
+Name: <3-8 word human-readable display name, no quotes, no trailing punctuation>
+Id: <PascalCase identifier, alphanumeric only, no spaces, no dashes, no underscores>
+Svg: <inline SVG source on one line, see rules below>
+```
+
+# SVG rules
+
+- Root element: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">…</svg>`
+- 24×24 viewBox; strokes only (no filled fills unless essential to meaning); use `currentColor` so the icon inherits theme colors.
+- Single line, no line breaks, no XML comments, no `<?xml?>` prolog, no external references (no `xlink:href` to URLs, no `<image>`, no fonts).
+- Keep the markup compact — aim for under ~400 characters. Prefer 2-6 primitive shapes (path, circle, rect, line, polyline) that clearly evoke the concept.
+- The icon should be recognizable at 16×16 — avoid tiny details.
+
+# Examples
+
+Input: "Quarterly sales review presentation for the European team"
+```
+Name: European Quarterly Sales Review
+Id: EuropeanQuarterlySalesReview
+Svg: <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="12" rx="1"/><line x1="8" y1="20" x2="16" y2="20"/><line x1="12" y1="16" x2="12" y2="20"/><polyline points="7 12 10 9 13 12 17 7"/></svg>
+```
+
+Input: "A checklist of onboarding tasks for new hires"
+```
+Name: New Hire Onboarding Checklist
+Id: NewHireOnboardingChecklist
+Svg: <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="3" width="16" height="18" rx="2"/><polyline points="8 10 10 12 14 8"/><line x1="8" y1="16" x2="16" y2="16"/></svg>
+```
+
+Input: "Notes from today's architecture design discussion"
+```
+Name: Architecture Design Discussion Notes
+Id: ArchitectureDesignDiscussionNotes
+Svg: <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 4h12l4 4v12H4z"/><line x1="8" y1="12" x2="16" y2="12"/><line x1="8" y1="16" x2="14" y2="16"/></svg>
+```
+
+# Guidelines
+
+- If the description is empty or nonsensical, still return the three blocks with generic but valid content (e.g. a document icon, a placeholder name like "Untitled Document", Id "UntitledDocument").
+- Do **not** add extra commentary, markdown fences, code blocks, or explanations around the three labelled lines. The caller parses by label prefix and anything extra breaks the parse.
+- The Id must start with an uppercase letter. It must not lowercase the first letter.
diff --git a/src/MeshWeaver.AI/MeshOperations.cs b/src/MeshWeaver.AI/MeshOperations.cs
index 91df54a00..0663d670b 100644
--- a/src/MeshWeaver.AI/MeshOperations.cs
+++ b/src/MeshWeaver.AI/MeshOperations.cs
@@ -22,6 +22,7 @@ public class MeshOperations
     private readonly IMessageHub hub;
     private readonly ILogger<MeshOperations> logger;
     private readonly IMeshService mesh;
+    private readonly INodeTypeService? nodeTypeService;
 
     /// <summary>
     /// Callback invoked when a node is created, updated, or patched.
@@ -34,16 +35,49 @@ public MeshOperations(IMessageHub hub)
         this.hub = hub;
         this.logger = hub.ServiceProvider.GetRequiredService<ILogger<MeshOperations>>();
         this.mesh = hub.ServiceProvider.GetRequiredService<IMeshService>();
+        this.nodeTypeService = hub.ServiceProvider.GetService<INodeTypeService>();
     }
 
     /// <summary>
-    /// Resolves @ prefix and quotes from path. Example: @graph/org1 -> graph/org1, "@content/My File.md" -> content/My File.md
+    /// Looks up the cached compilation error for the owning NodeType of <paramref name="node"/>.
+    /// - If <paramref name="node"/> is a NodeType definition, checks its own path.
+    /// - Otherwise checks the NodeType's path.
+    /// Returns <c>null</c> if no error is recorded.
+    /// </summary>
+    private string? LookupCompilationError(MeshNode node)
+    {
+        if (nodeTypeService == null) return null;
+        var nodeTypePath = node.Content is Graph.Configuration.NodeTypeDefinition
+            ? node.Path
+            : node.NodeType;
+        return !string.IsNullOrEmpty(nodeTypePath)
+            ? nodeTypeService.GetCompilationError(nodeTypePath)
+            : null;
+    }
+
+    /// <summary>
+    /// Resolves @ prefix and normalises agent-emitted formatting noise.
+    /// Models / autocomplete frequently wrap spaced filenames in quotes ("foo bar.docx",
+    /// 'foo bar.docx'), put quotes around different segments, or include surrounding
+    /// whitespace. None of those characters are legal mesh-path content, so we strip
+    /// them regardless of position. Examples:
+    ///   @graph/org1                                  → graph/org1
+    ///   "@content/My File.md"                        → content/My File.md
+    ///   @/Org/content/"My File.docx"                 → /Org/content/My File.docx
+    ///   @/Org/"content/My File.docx"                 → /Org/content/My File.docx
+    ///   @"/Org/content/My File.docx"                 → /Org/content/My File.docx
+    ///   @/Org/content/'My File.docx'                 → /Org/content/My File.docx
+    ///   "   @/Org/content/My File.docx   "           → /Org/content/My File.docx
     /// </summary>
     public static string ResolvePath(string path)
     {
-        // Strip surrounding quotes (autocomplete wraps spaced paths in quotes)
-        if (path.Length >= 2 && path[0] == '"' && path[^1] == '"')
-            path = path[1..^1];
+        if (string.IsNullOrEmpty(path))
+            return path;
+
+        // Strip surrounding/inner whitespace and quote characters in one pass.
+        path = path.Trim();
+        if (path.IndexOfAny(['"', '\'']) >= 0)
+            path = path.Replace("\"", string.Empty).Replace("'", string.Empty);
 
         if (path.StartsWith("@"))
             return path[1..];
@@ -155,6 +189,11 @@ public async Task<string> Get(string path)
             await foreach (var node in mesh.QueryAsync<MeshNode>(
                 MeshQueryRequest.FromQuery($"path:{resolvedPath}")))
             {
+                var compileError = LookupCompilationError(node);
+                if (compileError != null)
+                    return JsonSerializer.Serialize(
+                        new { node, compilationError = compileError },
+                        hub.JsonSerializerOptions);
                 return JsonSerializer.Serialize(node, hub.JsonSerializerOptions);
             }
 
@@ -841,4 +880,136 @@ internal async Task<string> BuildNullContentErrorAsync(string path, string nodeT
             return Task.FromResult<string?>(null);
         }
     }
+
+    /// <summary>
+    /// Recycles the hub at <paramref name="path"/> by posting a
+    /// <see cref="DisposeRequest"/>. The next access re-initialises the hub — which
+    /// means a fresh NodeType compile and fresh data loads. Useful after fixing a
+    /// broken NodeType or when something is stuck in an inconsistent cached state.
+    /// Returns a JSON <c>{status, path}</c> envelope. The caller should wait ~100ms
+    /// before re-accessing so the grain teardown completes.
+    /// </summary>
+    public Task<string> Recycle(string path)
+    {
+        logger.LogInformation("Recycle called with path={Path}", path);
+
+        if (string.IsNullOrWhiteSpace(path))
+            return Task.FromResult(JsonSerializer.Serialize(
+                new { status = "Error", message = "path is required" },
+                hub.JsonSerializerOptions));
+
+        var resolvedPath = ResolvePath(path);
+        if (string.IsNullOrWhiteSpace(resolvedPath))
+            return Task.FromResult(JsonSerializer.Serialize(
+                new { status = "Error", message = "path is required" },
+                hub.JsonSerializerOptions));
+
+        try
+        {
+            // 1. Flush LOCAL NodeTypeService caches so a fresh compile runs on next access.
+            //    Disposing the hub alone is not enough — NodeTypeService._compilationErrors
+            //    and _compilationTasks survive hub teardown and would keep serving stale
+            //    errors.
+            nodeTypeService?.InvalidateCache(resolvedPath);
+
+            // 2. Broadcast the invalidation across silos via IMeshChangeFeed. Every silo's
+            //    NodeTypeService subscribes to this feed and calls InvalidateCache locally
+            //    when it sees an event for a tracked NodeType path.
+            var changeFeed = hub.ServiceProvider.GetService<IMeshChangeFeed>();
+            if (changeFeed != null)
+            {
+                var segments = resolvedPath.Split('/');
+                var id = segments.Length > 0 ? segments[^1] : resolvedPath;
+                var ns = segments.Length > 1 ? string.Join("/", segments[..^1]) : "";
+                changeFeed.Publish(new MeshChangeEvent(
+                    Namespace: ns,
+                    Id: id,
+                    Path: resolvedPath,
+                    Kind: MeshChangeKind.Updated,
+                    NodeType: MeshNode.NodeTypePath,
+                    Version: 0,
+                    Timestamp: DateTimeOffset.UtcNow));
+            }
+
+            // 3. Dispose the hub so the next request re-initialises with fresh config.
+            hub.Post(new DisposeRequest(), o => o.WithTarget(new Address(resolvedPath)));
+            return Task.FromResult(JsonSerializer.Serialize(
+                new
+                {
+                    status = "Recycled",
+                    path = resolvedPath,
+                    message = "DisposeRequest posted + cache invalidation broadcast via MeshChangeFeed. Wait ~100ms before the next access."
+                },
+                hub.JsonSerializerOptions));
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Error recycling {Path}", resolvedPath);
+            return Task.FromResult(JsonSerializer.Serialize(
+                new { status = "Error", path = resolvedPath, message = ex.Message },
+                hub.JsonSerializerOptions));
+        }
+    }
+
+    /// <summary>
+    /// Returns compilation diagnostics for a NodeType or an instance of one.
+    /// The response is JSON with <c>status</c> (<c>Error</c> / <c>Ok</c> /
+    /// <c>Unknown</c>) and, when relevant, the error text from the last compile.
+    /// Used by the Coder agent's self-verification loop after creating / updating
+    /// a NodeType.
+    /// </summary>
+    public async Task<string> GetDiagnostics(string path)
+    {
+        logger.LogInformation("GetDiagnostics called with path={Path}", path);
+
+        if (string.IsNullOrWhiteSpace(path))
+            return JsonSerializer.Serialize(
+                new { status = "Error", message = "path is required" },
+                hub.JsonSerializerOptions);
+
+        var resolvedPath = ResolvePath(path);
+        if (nodeTypeService == null)
+            return JsonSerializer.Serialize(
+                new { status = "Unknown", message = "INodeTypeService not registered on this hub" },
+                hub.JsonSerializerOptions);
+
+        // Resolve the owning NodeType path: either the path itself (if it IS a NodeType)
+        // or the NodeType of the instance at that path.
+        string? nodeTypePath = null;
+        await foreach (var node in mesh.QueryAsync<MeshNode>(MeshQueryRequest.FromQuery($"path:{resolvedPath}")))
+        {
+            nodeTypePath = node.Content is Graph.Configuration.NodeTypeDefinition
+                ? node.Path
+                : node.NodeType;
+            break;
+        }
+
+        if (string.IsNullOrEmpty(nodeTypePath))
+            return JsonSerializer.Serialize(
+                new { status = "Unknown", message = $"Not found: {resolvedPath}" },
+                hub.JsonSerializerOptions);
+
+        // Compiling has priority over any prior error — the error we're seeing is stale
+        // and a fresh result is on its way. Tell the caller to wait and retry.
+        if (nodeTypeService.IsCompiling(nodeTypePath))
+        {
+            var startedAt = nodeTypeService.GetCompilationStartedAt(nodeTypePath);
+            var elapsedMs = startedAt is null
+                ? (long?)null
+                : (long)(DateTimeOffset.UtcNow - startedAt.Value).TotalMilliseconds;
+            return JsonSerializer.Serialize(
+                new { status = "Compiling", nodeTypePath, elapsedMs },
+                hub.JsonSerializerOptions);
+        }
+
+        var err = nodeTypeService.GetCompilationError(nodeTypePath);
+        if (string.IsNullOrEmpty(err))
+            return JsonSerializer.Serialize(
+                new { status = "Ok", nodeTypePath },
+                hub.JsonSerializerOptions);
+
+        return JsonSerializer.Serialize(
+            new { status = "Error", nodeTypePath, error = err },
+            hub.JsonSerializerOptions);
+    }
 }
diff --git a/src/MeshWeaver.AI/MeshPlugin.cs b/src/MeshWeaver.AI/MeshPlugin.cs
index 231bf58ab..17c38bcce 100644
--- a/src/MeshWeaver.AI/MeshPlugin.cs
+++ b/src/MeshWeaver.AI/MeshPlugin.cs
@@ -68,6 +68,22 @@ public Task<string> Delete(
         return ops.Delete(paths);
     }
 
+    [Description("Returns compilation diagnostics for a NodeType or an instance of one. Status is 'Ok' when the type compiled cleanly, 'Error' with a detailed message when it failed, or 'Unknown' when no compile has happened yet. Use this after creating/updating a NodeType to verify it actually compiles — a NodeType that doesn't compile is not 'done'.")]
+    public Task<string> GetDiagnostics(
+        [Description("Path to a NodeType (e.g., @Systemorph/SocialMedia/Profile) or to any instance of one")] string path)
+    {
+        RestoreAccessContext();
+        return ops.GetDiagnostics(ResolveContextPath(path));
+    }
+
+    [Description("Recycles the hub at the given path by posting DisposeRequest. Forces a fresh hub initialization on the next access — use this after fixing a broken NodeType, after editing the `sources` list, or whenever a grain is stuck. Returns {status:'Recycled', path}. Wait ~100ms before the next access so the grain teardown completes.")]
+    public Task<string> Recycle(
+        [Description("Path to the node (e.g., @Systemorph/SocialMedia/Profile). Use the NodeType path to recycle the whole type; use an instance path to recycle just that instance's hub.")] string path)
+    {
+        RestoreAccessContext();
+        return ops.Recycle(ResolveContextPath(path));
+    }
+
     /// <summary>
     /// Restores the user's AccessContext from <see cref="IAgentChat.ExecutionContext"/>.
     /// AsyncLocal doesn't flow reliably through the AI framework's streaming + tool
@@ -108,6 +124,7 @@ public IList<AITool> CreateTools()
             AIFunctionFactory.Create(Get),
             AIFunctionFactory.Create(Search),
             AIFunctionFactory.Create(NavigateTo),
+            AIFunctionFactory.Create(GetDiagnostics),
         ];
     }
 
@@ -125,6 +142,8 @@ public IList<AITool> CreateAllTools()
             AIFunctionFactory.Create(Update),
             AIFunctionFactory.Create(Patch),
             AIFunctionFactory.Create(Delete),
+            AIFunctionFactory.Create(GetDiagnostics),
+            AIFunctionFactory.Create(Recycle),
         ];
     }
 }
diff --git a/src/MeshWeaver.AI/Plugins/DelegationTool.cs b/src/MeshWeaver.AI/Plugins/DelegationTool.cs
index 1a283a12e..61ea93e73 100644
--- a/src/MeshWeaver.AI/Plugins/DelegationTool.cs
+++ b/src/MeshWeaver.AI/Plugins/DelegationTool.cs
@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using System.ComponentModel;
+using System.Runtime.CompilerServices;
 using System.Text.Json;
 using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Logging;
@@ -7,33 +8,16 @@
 namespace MeshWeaver.AI.Plugins;
 
 /// <summary>
-/// Represents a delegation result that can be expanded in the UI.
+/// Result record preserved for tests + <see cref="ThreadExecution.ExtractToolResult"/>.
+/// No longer used as the delegation tool return shape — the tool now yields
+/// <see cref="IAsyncEnumerable{string}"/> chunks directly.
 /// </summary>
 public record DelegationResult
 {
-    /// <summary>
-    /// The agent that was delegated to.
-    /// </summary>
     public required string AgentName { get; init; }
-
-    /// <summary>
-    /// The task that was delegated.
-    /// </summary>
     public required string Task { get; init; }
-
-    /// <summary>
-    /// The result from the delegated agent.
-    /// </summary>
     public required string Result { get; init; }
-
-    /// <summary>
-    /// Whether the delegation was successful.
-    /// </summary>
     public bool Success { get; init; } = true;
-
-    /// <summary>
-    /// The thread ID used for the delegation (for isolated context).
-    /// </summary>
     public string? ThreadId { get; init; }
 }
 
@@ -46,86 +30,27 @@ public record DelegationInfo(string AgentPath, string Description);
 
 /// <summary>
 /// Creates delegation tools for agents that support isolated context per delegation.
-/// Each delegation creates a new thread for the target agent, and the result
-/// is returned to the parent agent as a tool result.
+///
+/// The tool signature is <see cref="IAsyncEnumerable{string}"/> so that the sub-thread's
+/// streaming text flows back as incremental chunks. Microsoft.Extensions.AI aggregates
+/// the yielded chunks as the tool result; meanwhile, a side-channel delta push keeps the
+/// parent's response bubble updated in real time so the user sees sub-thread progress
+/// inline without waiting for completion.
+///
+/// No more <see cref="Task{String}"/> — the previous Task-returning shape forced the
+/// FunctionInvokingChatClient to block on sub-thread completion, which deadlocks under
+/// Orleans when the child's completion patch queues behind the parent hub scheduler.
 /// </summary>
 public static class DelegationTool
 {
-    /// <summary>
-    /// Creates a delegation tool that delegates to a specific agent with an isolated thread.
-    /// The delegation is visible in the UI as a tool invocation.
-    /// </summary>
-    /// <param name="targetAgentName">Name of the agent to delegate to</param>
-    /// <param name="targetAgentDescription">Description of when to use this agent</param>
-    /// <param name="executeAsync">Function to execute the delegation</param>
-    /// <param name="logger">Optional logger</param>
-    /// <returns>An AITool for delegation</returns>
-    public static AITool CreateDelegationTool(
-        string targetAgentName,
-        string targetAgentDescription,
-        Func<string, CancellationToken, Task<DelegationResult>> executeAsync,
-        ILogger? logger = null)
-    {
-        async Task<string> DelegateToAgent(
-            [Description("The task or instructions to send to the specialized agent. Be specific about what you need.")] string task,
-            CancellationToken cancellationToken)
-        {
-            logger?.LogInformation("Delegating to {TargetAgent}: {Task}", targetAgentName, task);
-
-            try
-            {
-                var result = await executeAsync(task, cancellationToken);
-
-                if (result.Success)
-                {
-                    logger?.LogInformation("Delegation to {TargetAgent} completed successfully", targetAgentName);
-                    return result.Result;
-                }
-                else
-                {
-                    logger?.LogWarning("Delegation to {TargetAgent} failed: {Result}", targetAgentName, result.Result);
-                    return $"Delegation to {targetAgentName} failed: {result.Result}";
-                }
-            }
-            catch (OperationCanceledException)
-            {
-                logger?.LogInformation("Delegation to {TargetAgent} was cancelled", targetAgentName);
-                throw;
-            }
-            catch (Exception ex)
-            {
-                logger?.LogError(ex, "Error during delegation to {TargetAgent}", targetAgentName);
-                return $"Error delegating to {targetAgentName}: {ex.Message}";
-            }
-        }
-
-        var description = $"""
-            {targetAgentDescription}
-
-            This tool delegates the task to the {targetAgentName} agent, which has specialized capabilities.
-            The agent will execute the task in its own isolated context and return the result.
-            Wait for the result before continuing with your response.
-            """;
-
-        return AIFunctionFactory.Create(
-            DelegateToAgent,
-            name: $"delegate_to_{targetAgentName}",
-            description: description);
-    }
-
     /// <summary>
     /// Creates a unified delegation tool that can delegate to any available agent.
     /// Each delegation uses an isolated thread for the target agent.
     /// </summary>
-    /// <param name="currentAgent">The current agent's configuration</param>
-    /// <param name="hierarchyAgents">All agents in the namespace hierarchy</param>
-    /// <param name="executeAsync">Function to execute delegations</param>
-    /// <param name="logger">Optional logger</param>
-    /// <returns>An AITool for unified delegation</returns>
     public static AITool CreateUnifiedDelegationTool(
         AgentConfiguration currentAgent,
         IReadOnlyList<AgentConfiguration> hierarchyAgents,
-        Func<string, string, string?, CancellationToken, Task<DelegationResult>> executeAsync,
+        Func<string, string, string?, CancellationToken, IAsyncEnumerable<string>> executeAsync,
         ILogger? logger = null)
     {
         var delegationInfo = ImmutableList<DelegationInfo>.Empty;
@@ -158,45 +83,28 @@ public static AITool CreateUnifiedDelegationTool(
             PropertyNamingPolicy = JsonNamingPolicy.CamelCase
         });
 
-        async Task<string> Delegate(
+        async IAsyncEnumerable<string> Delegate(
             [Description("The name of the agent to delegate to. Use the agentPath from the available agents.")] string agentName,
             [Description("The task or instructions for the delegated agent. Be specific about what you need.")] string task,
             [Description("Optional: the node path to use as context for this delegation (e.g., 'OrgA/my-doc'). When omitted, inherits the parent context. Set explicitly when delegating parallel work on different documents.")] string? context = null,
-            CancellationToken cancellationToken = default)
+            [EnumeratorCancellation] CancellationToken cancellationToken = default)
         {
-            logger?.LogInformation("Delegating to {AgentName}: {Task}, context={Context}", agentName, task, context ?? "(inherited)");
-
-            try
-            {
-                var result = await executeAsync(agentName, task, context, cancellationToken);
+            logger?.LogInformation("Delegating to {AgentName}: {Task}, context={Context}",
+                agentName, task, context ?? "(inherited)");
 
-                if (result.Success)
-                {
-                    logger?.LogInformation("Delegation to {AgentName} completed successfully", agentName);
-                    return result.Result;
-                }
-                else
-                {
-                    logger?.LogWarning("Delegation to {AgentName} failed: {Result}", agentName, result.Result);
-                    return $"Delegation to {agentName} failed: {result.Result}";
-                }
-            }
-            catch (OperationCanceledException)
+            await foreach (var chunk in executeAsync(agentName, task, context, cancellationToken)
+                .WithCancellation(cancellationToken))
             {
-                logger?.LogInformation("Delegation to {AgentName} was cancelled", agentName);
-                throw;
-            }
-            catch (Exception ex)
-            {
-                logger?.LogError(ex, "Error during delegation to {AgentName}", agentName);
-                return $"Error delegating to {agentName}: {ex.Message}";
+                yield return chunk;
             }
+
+            logger?.LogInformation("Delegation to {AgentName} stream completed", agentName);
         }
 
         var description = $"""
             Delegate to a specialized agent when the request matches their expertise.
             Each delegation runs in an isolated context - the agent won't see previous conversation history.
-            Wait for the result before continuing with your response.
+            The delegated agent's output streams back as it generates.
 
             When delegating parallel work on different documents, set the 'context' parameter to the
             specific node path for each delegation. This ensures each agent sees the correct document.
diff --git a/src/MeshWeaver.AI/Thread.cs b/src/MeshWeaver.AI/Thread.cs
index 98e59d9c2..628c117da 100644
--- a/src/MeshWeaver.AI/Thread.cs
+++ b/src/MeshWeaver.AI/Thread.cs
@@ -135,17 +135,26 @@ public record Thread
     /// </summary>
     public DateTime? ExecutionStartedAt { get; init; }
 
-    /// <summary>
-    /// Streaming text buffer — transient, never persisted.
-    /// Used only in-memory during active execution for the status bar preview.
-    /// </summary>
     /// <summary>
     /// Pending user message text — set at thread creation to auto-start execution.
     /// When the thread grain activates and sees this, it immediately starts streaming.
     /// Cleared after execution starts.
+    /// Legacy: still used by the auto-execute-on-creation path. New submissions
+    /// from the GUI populate <see cref="PendingUserMessages"/> instead.
     /// </summary>
     public string? PendingUserMessage { get; init; }
 
+    /// <summary>
+    /// User messages submitted by the client but not yet ingested into a round.
+    /// Keyed by user message id. The server-side submission watcher creates
+    /// satellite ThreadMessage cells from these entries and clears them once
+    /// the round is dispatched. Lets us do the entire submission as a single
+    /// atomic <c>stream.Update</c> on this thread node — no separate
+    /// CreateNodeRequest, no AppendUserMessageRequest.
+    /// </summary>
+    public ImmutableDictionary<string, ThreadMessage> PendingUserMessages { get; init; }
+        = ImmutableDictionary<string, ThreadMessage>.Empty;
+
     /// <summary>Agent name for pending execution.</summary>
     public string? PendingAgentName { get; init; }
 
@@ -264,4 +273,21 @@ public record ThreadMessage
     /// The server watcher truncates the thread after this id and re-ingests.
     /// </summary>
     public bool IsResubmit { get; init; }
+
+    /// <summary>
+    /// Token usage reported by the model provider. Populated for AgentResponse cells
+    /// when the streaming finishes. Null while streaming or when the provider didn't
+    /// report usage (e.g., some local models). Sum of <see cref="InputTokens"/> +
+    /// <see cref="OutputTokens"/> may differ from <see cref="TotalTokens"/> if the
+    /// provider includes cached / reasoning tokens.
+    /// </summary>
+    public int? InputTokens { get; init; }
+    public int? OutputTokens { get; init; }
+    public int? TotalTokens { get; init; }
+
+    /// <summary>
+    /// Wall-clock time when the assistant response finished streaming. Null while
+    /// streaming. <c>CompletedAt - Timestamp</c> is the per-message duration.
+    /// </summary>
+    public DateTime? CompletedAt { get; init; }
 }
diff --git a/src/MeshWeaver.AI/ThreadExecution.cs b/src/MeshWeaver.AI/ThreadExecution.cs
index 644118ed0..b27ff26e8 100644
--- a/src/MeshWeaver.AI/ThreadExecution.cs
+++ b/src/MeshWeaver.AI/ThreadExecution.cs
@@ -429,11 +429,15 @@ void RespondWithError(string error)
     /// Async handler on the _Exec hosted hub.
     /// Prepares agent and await-streams the response.
     /// Uses UpdateMeshNode on a remote stream to push text to the response node.
-    /// </summary>
-    /// <summary>
-    /// Fully reactive execution handler — zero await, zero QueryAsync.
-    /// Subscribes to chatClient.Initialize() observable, then runs streaming in the callback.
-    /// The AI API streaming (GetStreamingResponseAsync) runs via hub.InvokeAsync for async I/O.
+    ///
+    /// User input received while a round is in progress is held in
+    /// <see cref="MeshThread.PendingUserMessages"/>. The submission watcher dispatches
+    /// a NEW round (with its own response cell) as soon as this one completes — so
+    /// follow-up typed input is naturally queued without cancelling the current
+    /// model turn. Mid-iteration drain (injecting new user input into the same
+    /// response without round-boundary tear-down) would require manually orchestrating
+    /// the tool loop instead of relying on Microsoft.Extensions.AI's auto-invocation;
+    /// that's intentionally NOT done here.
     /// </summary>
     internal static IMessageDelivery ExecuteMessageAsync(
         IMessageHub hub,
@@ -690,6 +694,9 @@ void UpdateThreadExecution(Func<MeshThread, MeshThread> mutate)
                     var ct = executionCts.Token;
                     var responseText = new StringBuilder();
                     capturedResponseText = responseText;
+                    int? inputTokens = null;
+                    int? outputTokens = null;
+                    int? totalTokens = null;
                     try
                     {
                     logger.LogInformation("[ThreadExec] STREAMING_LOOP_ENTRY: {Time:HH:mm:ss.fff} threadPath={ThreadPath} (on thread pool)", DateTime.UtcNow, threadPath);
@@ -697,6 +704,7 @@ void UpdateThreadExecution(Func<MeshThread, MeshThread> mutate)
                     // and delegations where the streaming loop is blocked.
                     using var heartbeatSubscription = parentHub.BeginAsyncOperation();
                     var lastUpdate = DateTimeOffset.MinValue;
+                    var lastPushedTextLength = 0;
                     var pendingCalls = ImmutableDictionary<string, FunctionCallContent>.Empty;
                     string? lastCallKey = null;
 
@@ -735,6 +743,18 @@ void UpdateThreadExecution(Func<MeshThread, MeshThread> mutate)
                             });
                         }
                     }
+                    else if (content is UsageContent usage)
+                    {
+                        // Aggregate token usage across stream chunks. Providers vary —
+                        // some report once at the end, others on every chunk; sum either way.
+                        var d = usage.Details;
+                        if (d?.InputTokenCount is { } it)
+                            inputTokens = (inputTokens ?? 0) + (int)it;
+                        if (d?.OutputTokenCount is { } ot)
+                            outputTokens = (outputTokens ?? 0) + (int)ot;
+                        if (d?.TotalTokenCount is { } tt)
+                            totalTokens = (totalTokens ?? 0) + (int)tt;
+                    }
                     else if (content is FunctionResultContent functionResult)
                     {
                         logger.LogDebug("[ThreadExec] TOOL_RESULT: {Time:HH:mm:ss.fff} callId={CallId}, success={Success}, resultLen={Length}",
@@ -790,6 +810,9 @@ void UpdateThreadExecution(Func<MeshThread, MeshThread> mutate)
 
                 // Push streaming content at ~1/3sec — reduced frequency to avoid
                 // overloading the grain scheduler (messages expire if queue backs up).
+                // Push as a TEXT DELTA: we send only the new characters since the last
+                // push (tracked by lastPushedTextLength). The response cell appends it,
+                // so we never ship the whole growing string every tick.
                 if (DateTimeOffset.UtcNow - lastUpdate > TimeSpan.FromMilliseconds(3000))
                 {
                     // Stamp delegation paths on any unmatched delegation tool calls
@@ -802,19 +825,47 @@ void UpdateThreadExecution(Func<MeshThread, MeshThread> mutate)
                         return e;
                     }).ToImmutableList();
 
-                    PushToResponseMessage(responseText.ToString(), toolCallLog, nodeChangeLog,
-                        request.AgentName, request.ModelName);
+                    var delta = responseText.Length > lastPushedTextLength
+                        ? responseText.ToString(lastPushedTextLength, responseText.Length - lastPushedTextLength)
+                        : null;
+                    // First push replaces the "Generating response…" placeholder; subsequent
+                    // pushes append deltas only.
+                    var isFirstPush = lastPushedTextLength == 0;
+                    lastPushedTextLength = responseText.Length;
+                    parentHub.Post(new UpdateThreadMessageContent
+                    {
+                        Text = isFirstPush ? responseText.ToString() : null,
+                        TextDelta = isFirstPush ? null : delta,
+                        ToolCalls = toolCallLog,
+                        UpdatedNodes = nodeChangeLog,
+                        AgentName = request.AgentName,
+                        ModelName = request.ModelName
+                    }, o => o.WithTarget(new Address(responsePath)));
                     lastUpdate = DateTimeOffset.UtcNow;
                 }
             }
 
-                    // Final update — aggregate node changes (merges sub-thread changes with min/max versions)
+                    // Final update — aggregate node changes (merges sub-thread changes with min/max versions),
+                    // include token usage + completion timestamp so the cell can show duration / tokens.
                     var aggregatedChanges = AggregateNodeChanges(nodeChangeLog);
-                    logger.LogInformation("[ThreadExec] EXECUTION_COMPLETE: {Time:HH:mm:ss.fff} threadPath={ThreadPath}, responseLength={Length}, toolCalls={ToolCalls}",
-                        DateTime.UtcNow, threadPath, responseText.Length, toolCallLog.Count);
+                    if (totalTokens is null && (inputTokens.HasValue || outputTokens.HasValue))
+                        totalTokens = (inputTokens ?? 0) + (outputTokens ?? 0);
+                    logger.LogInformation("[ThreadExec] EXECUTION_COMPLETE: {Time:HH:mm:ss.fff} threadPath={ThreadPath}, responseLength={Length}, toolCalls={ToolCalls}, tokens={In}/{Out}/{Total}",
+                        DateTime.UtcNow, threadPath, responseText.Length, toolCallLog.Count,
+                        inputTokens, outputTokens, totalTokens);
                     var finalText = responseText.ToString();
-                    PushToResponseMessage(finalText, toolCallLog, aggregatedChanges,
-                        request.AgentName, request.ModelName);
+                    parentHub.Post(new UpdateThreadMessageContent
+                    {
+                        Text = finalText,
+                        ToolCalls = toolCallLog,
+                        UpdatedNodes = aggregatedChanges,
+                        AgentName = request.AgentName,
+                        ModelName = request.ModelName,
+                        InputTokens = inputTokens,
+                        OutputTokens = outputTokens,
+                        TotalTokens = totalTokens,
+                        CompletedAt = DateTime.UtcNow
+                    }, o => o.WithTarget(new Address(responsePath)));
                     // Clear streaming state
                     UpdateThreadExecution(t => t with
                     {
diff --git a/src/MeshWeaver.AI/ThreadInput.cs b/src/MeshWeaver.AI/ThreadInput.cs
new file mode 100644
index 000000000..cea3b6943
--- /dev/null
+++ b/src/MeshWeaver.AI/ThreadInput.cs
@@ -0,0 +1,107 @@
+using MeshWeaver.Data;
+using MeshWeaver.Graph;
+using MeshWeaver.Mesh;
+using MeshWeaver.Messaging;
+using MeshThread = MeshWeaver.AI.Thread;
+
+namespace MeshWeaver.AI;
+
+/// <summary>
+/// Testable, Blazor-free helpers for appending user input into a thread.
+///
+/// The whole submission is one atomic <c>workspace.UpdateMeshNode</c> on the
+/// thread node — adding the new id to <c>UserMessageIds</c> and stashing the
+/// message payload in <see cref="Thread.PendingUserMessages"/>. The server
+/// watcher creates the satellite cell and dispatches the next round.
+///
+/// This replaces the legacy two-message dance (CreateNodeRequest +
+/// AppendUserMessageRequest), eliminating the duplicate-dispatch races caused
+/// by interleaved fire-and-forget posts.
+/// </summary>
+public static class ThreadInput
+{
+    private static string NewId() => Guid.NewGuid().ToString("N")[..8];
+
+    /// <summary>
+    /// Pure: builds a user <see cref="ThreadMessage"/> record. No I/O.
+    /// </summary>
+    public static ThreadMessage CreateUserMessage(
+        string text,
+        string? createdBy = null,
+        string? authorName = null,
+        string? agentName = null,
+        string? modelName = null,
+        string? contextPath = null,
+        IReadOnlyList<string>? attachments = null) =>
+        new()
+        {
+            Role = "user",
+            Text = text,
+            AuthorName = authorName,
+            CreatedBy = createdBy,
+            AgentName = agentName,
+            ModelName = modelName,
+            ContextPath = contextPath,
+            Attachments = attachments,
+            Timestamp = DateTime.UtcNow,
+            Type = ThreadMessageType.ExecutedInput
+        };
+
+    /// <summary>
+    /// Atomically appends a user message to <paramref name="threadPath"/> via a
+    /// single <c>workspace.UpdateMeshNode</c> on the thread's MeshNode. Returns
+    /// the generated message id. The server-side submission watcher creates the
+    /// satellite cell from <see cref="Thread.PendingUserMessages"/> and
+    /// dispatches the next round.
+    /// </summary>
+    public static string AppendUserInput(
+        IWorkspace workspace,
+        string threadPath,
+        ThreadMessage message)
+    {
+        if (string.IsNullOrEmpty(threadPath))
+            throw new ArgumentException("threadPath is required", nameof(threadPath));
+        ArgumentNullException.ThrowIfNull(workspace);
+        ArgumentNullException.ThrowIfNull(message);
+
+        var msgId = NewId();
+
+        // Append the message to PendingUserMessages + UserMessageIds only.
+        //
+        // We deliberately do NOT add to Thread.Messages here — the GUI renders one
+        // LayoutAreaControl per id in Messages, and rendering a control before its
+        // satellite ThreadMessage node has been created on the hub triggers
+        // "Cannot access a disposed object" + spurious area-stream errors. The
+        // server-side submission watcher creates the satellite cell first via
+        // IMeshService.CreateNode and only after CreateNode confirms success does
+        // it add the id into Messages (in the same atomic update that flips
+        // IsExecuting=true alongside the response cell id).
+        //
+        // Using the no-address overload (FirstOrDefault) avoids a pre-existing
+        // path-vs-id key mismatch in the address-aware overload. This call expects
+        // to run on the thread's own hub (e.g., from the AppendUserMessageRequest
+        // handler) where there's exactly one node in the collection.
+        workspace.UpdateMeshNode(node =>
+        {
+            var thread = node.Content as MeshThread ?? new MeshThread();
+            var userIds = thread.UserMessageIds.Contains(msgId)
+                ? thread.UserMessageIds
+                : thread.UserMessageIds.Add(msgId);
+            var pending = thread.PendingUserMessages.SetItem(msgId, message);
+            return node with
+            {
+                Content = thread with
+                {
+                    UserMessageIds = userIds,
+                    PendingUserMessages = pending,
+                    PendingAgentName = message.AgentName ?? thread.PendingAgentName,
+                    PendingModelName = message.ModelName ?? thread.PendingModelName,
+                    PendingContextPath = message.ContextPath ?? thread.PendingContextPath,
+                    PendingAttachments = message.Attachments ?? thread.PendingAttachments
+                }
+            };
+        });
+
+        return msgId;
+    }
+}
diff --git a/src/MeshWeaver.AI/ThreadLayoutAreas.cs b/src/MeshWeaver.AI/ThreadLayoutAreas.cs
index 6c870330f..81ac18aa1 100644
--- a/src/MeshWeaver.AI/ThreadLayoutAreas.cs
+++ b/src/MeshWeaver.AI/ThreadLayoutAreas.cs
@@ -45,6 +45,7 @@ public static MessageHubConfiguration AddThreadLayoutAreas(this MessageHubConfig
                 .WithView(ThreadNodeType.ThreadChatArea, ThreadChatView)
                 .WithView(ThreadNodeType.StreamingArea, StreamingView)
                 .WithView(ThreadNodeType.HistoryArea, HistoryView)
+                .WithView(ThreadNodeType.HeaderArea, HeaderView)
                 .WithView(MeshNodeLayoutAreas.ThumbnailArea, Thumbnail)
                 .WithView(MeshNodeLayoutAreas.ThreadsArea, ThreadsCatalog));
 
@@ -518,4 +519,301 @@ private static UiControl ThreadsView(LayoutAreaHost host, RenderingContext _)
             .WithRenderMode(MeshSearchRenderMode.Flat)
             .WithCreateNodeType("Thread");
     }
+
+    /// <summary>
+    /// Header area shown above the chat. Renders, when applicable:
+    ///   • A back-link to the parent thread (if this is a delegation sub-thread —
+    ///     detected by path nesting under another thread's response message id).
+    ///   • A summary of nodes modified during this thread's runs, aggregated across
+    ///     every <see cref="ThreadMessage.UpdatedNodes"/> entry, with version-before/
+    ///     version-after. Each entry links to the node's Versions area where the
+    ///     existing compare/restore UI lives.
+    /// Pure subscription on the thread MeshNode; no awaits, no QueryAsync.
+    /// </summary>
+    public static IObservable<UiControl?> HeaderView(LayoutAreaHost host, RenderingContext _)
+    {
+        var threadPath = host.Hub.Address.ToString();
+        var parentLink = TryBuildParentLink(threadPath);
+
+        var stream = host.Workspace.GetStream(new MeshNodeReference());
+        if (stream is null)
+            return Observable.Return<UiControl?>(parentLink);
+
+        // Emit an immediate starting value so the LayoutAreaView never shows a skeleton
+        // for this area — the header is ancillary and should never block the chat view.
+        // Subsequent emissions fold in the aggregated UpdatedNodes summary.
+        var initial = Observable.Return<UiControl?>(BuildHeader(parentLink, ImmutableList<NodeChangeEntry>.Empty, threadPath));
+
+        var aggregated = stream
+            .Select(change => (change.Value?.Content as MeshThread)?.Messages ?? ImmutableList<string>.Empty)
+            .Where(ids => ids.Count > 0)
+            .Select(ids => (ids, key: string.Join("|", ids)))
+            .DistinctUntilChanged(p => p.key)
+            .Select(p => CollectUpdatedNodes(host.Hub, threadPath, p.ids))
+            .Switch()
+            .Select(updates => BuildHeader(parentLink, updates, threadPath));
+
+        return initial.Concat(aggregated);
+    }
+
+    /// <summary>
+    /// Walks <paramref name="messageIds"/>, requests each satellite ThreadMessage via
+    /// GetDataRequest (Post + RegisterCallback wrapped as an Observable), accumulates
+    /// their UpdatedNodes, and emits the aggregated list once all responses arrive.
+    /// </summary>
+    private static IObservable<ImmutableList<NodeChangeEntry>> CollectUpdatedNodes(
+        IMessageHub hub, string threadPath, ImmutableList<string> messageIds)
+    {
+        if (messageIds.IsEmpty) return Observable.Return(ImmutableList<NodeChangeEntry>.Empty);
+
+        var subjects = messageIds.Select(id =>
+        {
+            var subject = new System.Reactive.Subjects.AsyncSubject<ImmutableList<NodeChangeEntry>>();
+            var del = hub.Post(new GetDataRequest(new MeshNodeReference()),
+                o => o.WithTarget(new Address($"{threadPath}/{id}")));
+            if (del is null)
+            {
+                subject.OnNext(ImmutableList<NodeChangeEntry>.Empty);
+                subject.OnCompleted();
+            }
+            else
+            {
+                hub.RegisterCallback((IMessageDelivery)del, resp =>
+                {
+                    var msg = resp is IMessageDelivery<GetDataResponse> gdr
+                        ? (gdr.Message.Data as MeshNode)?.Content as ThreadMessage
+                        : null;
+                    subject.OnNext(msg?.UpdatedNodes ?? ImmutableList<NodeChangeEntry>.Empty);
+                    subject.OnCompleted();
+                    return resp;
+                });
+            }
+            return subject.AsObservable();
+        }).ToList();
+
+        return Observable.CombineLatest(subjects)
+            .Select(parts => ThreadExecution.AggregateNodeChanges(
+                parts.SelectMany(p => p).ToImmutableList()))
+            .Take(1)
+            .Timeout(TimeSpan.FromSeconds(5))
+            .Catch<ImmutableList<NodeChangeEntry>, Exception>(_ =>
+                Observable.Return(ImmutableList<NodeChangeEntry>.Empty));
+    }
+
+    private static UiControl? TryBuildParentLink(string threadPath)
+    {
+        // Sub-thread paths nest under a parent response message:
+        //   {parentThreadPath}/{parentResponseMsgId}/{thisThreadId}
+        // If we can find a ".../<8-hex-id>/<id>" pattern we treat this as a delegation.
+        var segments = threadPath.Split('/');
+        if (segments.Length < 3) return null;
+        var parentMsgId = segments[^2];
+        if (parentMsgId.Length != 8) return null;
+        var parentThreadPath = string.Join('/', segments[..^2]);
+        if (string.IsNullOrEmpty(parentThreadPath)) return null;
+
+        var encoded = System.Web.HttpUtility.HtmlEncode(parentThreadPath);
+        var html =
+            $"<a href=\"/{encoded}\" style=\"display:inline-flex; align-items:center; gap:6px; " +
+            $"font-size:0.78rem; color:var(--accent-fill-rest); text-decoration:none; " +
+            $"padding:4px 10px; border:1px solid var(--neutral-stroke-rest); border-radius:14px;\">" +
+            $"<span>&#8592;</span> Delegated from <code style=\"font-size:0.72rem;\">{encoded}</code></a>";
+        return Controls.Html(html);
+    }
+
+    private static UiControl? BuildHeader(UiControl? parentLink, ImmutableList<NodeChangeEntry> updates, string threadPath)
+    {
+        if (parentLink is null && updates.IsEmpty) return null;
+
+        var stack = Controls.Stack
+            .WithStyle("gap:6px; padding:8px 12px; margin-bottom:8px; " +
+                       "background:var(--neutral-layer-1); border:1px solid var(--neutral-stroke-rest); " +
+                       "border-radius:8px;");
+
+        if (parentLink is not null)
+            stack = stack.WithView(parentLink);
+
+        if (!updates.IsEmpty)
+            stack = stack.WithView(Controls.Html(BuildModifiedNodesHtml(updates, threadPath)));
+
+        return stack;
+    }
+
+    /// <summary>
+    /// Git-like panel for the aggregated UpdatedNodes list:
+    /// - Tabular layout (CSS grid): path · old-ver · → · new-ver · Diff · Restore v{old} · Restore v{new}.
+    /// - All action links visible inline on each row (no hidden ⋯ menu).
+    /// - Theme-safe colours that work in dark + light mode (no white-on-light-blue).
+    /// - Paths rendered relative to the thread's parent namespace so the most
+    ///   interesting segment (leaf) stays visible when the table narrows.
+    /// - On screens &lt; 720 px the whole section collapses behind a summary row.
+    /// </summary>
+    private static string BuildModifiedNodesHtml(ImmutableList<NodeChangeEntry> updates, string threadPath)
+    {
+        // Derive the ancestor prefix we can strip from each node path to produce a
+        // shorter display form. For a thread at "Org/_Thread/abc", the interesting
+        // prefix to strip is "Org/" (the thread's root namespace, above _Thread).
+        var threadIdx = threadPath.IndexOf("/_Thread/", StringComparison.Ordinal);
+        var shortenPrefix = threadIdx > 0 ? threadPath[..(threadIdx + 1)] : null;
+
+        static string Shorten(string path, string? prefix) =>
+            prefix is not null && path.StartsWith(prefix, StringComparison.Ordinal)
+                ? path[prefix.Length..]
+                : path;
+
+        var sb = new System.Text.StringBuilder();
+
+        // Inline <style> block scoped by a unique class so the grid + media-query
+        // rules apply to the rendered HTML. Lives inside the injected markdown; Blazor
+        // passes it through untouched.
+        sb.Append("""
+            <style>
+            .thread-mod-nodes { width:100%; }
+            .thread-mod-nodes > summary {
+                list-style:none; cursor:pointer;
+                font-size:0.8rem; font-weight:600;
+                color:var(--neutral-foreground-hint);
+                padding:4px 0;
+            }
+            .thread-mod-nodes > summary::-webkit-details-marker { display:none; }
+            .thread-mod-grid {
+                display:grid;
+                grid-template-columns: minmax(0,1fr) auto auto auto auto auto auto;
+                align-items:center;
+                gap:6px 10px;
+                margin-top:6px;
+                font-size:0.78rem;
+                color:var(--neutral-foreground-rest);
+            }
+            .thread-mod-grid a {
+                text-decoration:none;
+                color:var(--accent-fill-rest);
+            }
+            .thread-mod-grid a:hover { text-decoration:underline; }
+            .thread-mod-row {
+                display:contents;
+            }
+            .thread-mod-path {
+                min-width:0;
+                overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
+                padding:4px 6px;
+                border-radius:4px;
+            }
+            .thread-mod-path:hover { background:var(--neutral-layer-2); }
+            .thread-mod-chip {
+                padding:1px 6px; border-radius:10px;
+                background:var(--neutral-layer-3);
+                color:var(--neutral-foreground-rest) !important;
+                font-family:monospace; font-size:0.72rem;
+                border:1px solid var(--neutral-stroke-rest);
+            }
+            .thread-mod-chip-new {
+                color:var(--accent-fill-rest) !important;
+                border-color:var(--accent-fill-rest);
+                font-weight:600;
+            }
+            .thread-mod-arrow { color:var(--neutral-foreground-hint); }
+            .thread-mod-action {
+                padding:2px 8px; border-radius:4px;
+                font-size:0.74rem;
+                color:var(--accent-fill-rest) !important;
+                white-space:nowrap;
+            }
+            .thread-mod-action:hover { background:var(--neutral-layer-2); }
+            .thread-mod-action-muted {
+                color:var(--neutral-foreground-hint) !important;
+            }
+            .thread-mod-marker {
+                font-size:0.72rem; color:var(--neutral-foreground-hint); font-style:italic;
+            }
+            /* Small-screen: collapse the whole section under its summary. */
+            @media (max-width: 720px) {
+                .thread-mod-nodes[data-wide-inline="true"] > .thread-mod-grid { display:none; }
+                .thread-mod-nodes[data-wide-inline="true"][open] > .thread-mod-grid { display:grid; }
+                .thread-mod-grid {
+                    grid-template-columns: minmax(0,1fr) auto auto;
+                }
+                .thread-mod-action-mobile-hide { display:none; }
+            }
+            /* Wide-screen: the <details> is always open (summary acts as header). */
+            @media (min-width: 721px) {
+                .thread-mod-nodes[data-wide-inline="true"] > .thread-mod-grid { display:grid; }
+                .thread-mod-nodes[data-wide-inline="true"] > summary { pointer-events:none; }
+            }
+            </style>
+            """);
+
+        sb.Append("<details class=\"thread-mod-nodes\" data-wide-inline=\"true\" open>");
+        sb.Append($"<summary><span style=\"display:inline-block; width:10px;\">&#9656;</span> Modified nodes ({updates.Count})</summary>");
+
+        sb.Append("<div class=\"thread-mod-grid\">");
+
+        foreach (var entry in updates)
+        {
+            var path = entry.Path;
+            var pathEnc = System.Web.HttpUtility.HtmlEncode(path);
+            var displayEnc = System.Web.HttpUtility.HtmlEncode(Shorten(path, shortenPrefix));
+            var op = entry.Operation ?? "";
+
+            sb.Append("<div class=\"thread-mod-row\">");
+
+            // Column 1: path (truncates on narrow layouts)
+            sb.Append(
+                $"<a href=\"/{pathEnc}\" title=\"{pathEnc}\" class=\"thread-mod-path\">{displayEnc}</a>");
+
+            // Column 2: old version chip or "new" marker
+            if (entry.VersionBefore is { } vb)
+                sb.Append(
+                    $"<a href=\"/{pathEnc}/Versions?version={vb}\" class=\"thread-mod-chip\" title=\"View v{vb}\">v{vb}</a>");
+            else if (op.Equals("Created", StringComparison.OrdinalIgnoreCase))
+                sb.Append("<span class=\"thread-mod-marker\">new</span>");
+            else
+                sb.Append("<span></span>");
+
+            // Column 3: arrow
+            sb.Append("<span class=\"thread-mod-arrow\">&#8594;</span>");
+
+            // Column 4: new version chip or "deleted" marker
+            if (entry.VersionAfter is { } va)
+                sb.Append(
+                    $"<a href=\"/{pathEnc}/Versions?version={va}\" class=\"thread-mod-chip thread-mod-chip-new\" title=\"View v{va}\">v{va}</a>");
+            else if (op.Equals("Deleted", StringComparison.OrdinalIgnoreCase))
+                sb.Append("<span class=\"thread-mod-marker\">deleted</span>");
+            else
+                sb.Append("<span></span>");
+
+            // Column 5: Diff (old ↔ new) — points to VersionDiff with from/to params.
+            if (entry.VersionBefore.HasValue && entry.VersionAfter.HasValue)
+                sb.Append(
+                    $"<a href=\"/{pathEnc}/VersionDiff?from={entry.VersionBefore.Value}&to={entry.VersionAfter.Value}\" " +
+                    $"class=\"thread-mod-action thread-mod-action-mobile-hide\" " +
+                    $"title=\"Compare v{entry.VersionBefore.Value} to v{entry.VersionAfter.Value}\">Diff</a>");
+            else
+                sb.Append("<span class=\"thread-mod-action-mobile-hide\"></span>");
+
+            // Column 6: Restore to old — opens VersionDiff (which has the Restore button).
+            if (entry.VersionBefore.HasValue)
+                sb.Append(
+                    $"<a href=\"/{pathEnc}/VersionDiff?version={entry.VersionBefore.Value}\" " +
+                    $"class=\"thread-mod-action thread-mod-action-muted thread-mod-action-mobile-hide\" " +
+                    $"title=\"Revert to v{entry.VersionBefore.Value}\">Restore v{entry.VersionBefore.Value}</a>");
+            else
+                sb.Append("<span class=\"thread-mod-action-mobile-hide\"></span>");
+
+            // Column 7: Restore to new — opens VersionDiff (which has the Restore button).
+            if (entry.VersionAfter.HasValue)
+                sb.Append(
+                    $"<a href=\"/{pathEnc}/VersionDiff?version={entry.VersionAfter.Value}\" " +
+                    $"class=\"thread-mod-action thread-mod-action-muted thread-mod-action-mobile-hide\" " +
+                    $"title=\"Restore v{entry.VersionAfter.Value}\">Restore v{entry.VersionAfter.Value}</a>");
+            else
+                sb.Append("<span class=\"thread-mod-action-mobile-hide\"></span>");
+
+            sb.Append("</div>");
+        }
+
+        sb.Append("</div>");
+        sb.Append("</details>");
+        return sb.ToString();
+    }
 }
diff --git a/src/MeshWeaver.AI/ThreadMessageLayoutAreas.cs b/src/MeshWeaver.AI/ThreadMessageLayoutAreas.cs
index 1e07c28ca..66b72033b 100644
--- a/src/MeshWeaver.AI/ThreadMessageLayoutAreas.cs
+++ b/src/MeshWeaver.AI/ThreadMessageLayoutAreas.cs
@@ -119,15 +119,24 @@ private static IMessageDelivery HandleUpdateContent(
         hub.GetWorkspace().UpdateMeshNode(node =>
         {
             var current = node.Content as ThreadMessage ?? new ThreadMessage { Role = "assistant", Text = "" };
+            // Prefer incremental append (TextDelta). Full Text replacement is only used
+            // for final/terminal writes (completion, error, cancel markers).
+            var newText = msg.Text ?? (msg.TextDelta is { Length: > 0 } d
+                ? (current.Text ?? "") + d
+                : current.Text);
             return node with
             {
                 Content = current with
                 {
-                    Text = msg.Text ?? current.Text,
+                    Text = newText,
                     ToolCalls = msg.ToolCalls ?? current.ToolCalls,
                     UpdatedNodes = msg.UpdatedNodes ?? current.UpdatedNodes,
                     AgentName = msg.AgentName ?? current.AgentName,
-                    ModelName = msg.ModelName ?? current.ModelName
+                    ModelName = msg.ModelName ?? current.ModelName,
+                    InputTokens = msg.InputTokens ?? current.InputTokens,
+                    OutputTokens = msg.OutputTokens ?? current.OutputTokens,
+                    TotalTokens = msg.TotalTokens ?? current.TotalTokens,
+                    CompletedAt = msg.CompletedAt ?? current.CompletedAt
                 }
             };
         });
@@ -290,6 +299,7 @@ private static UiControl BuildMessageOverview(
             .WithTimestamp(msg.Timestamp)
             .WithText(new JsonPointerReference($"{dataPointer}/text"))
             .WithToolCalls(new JsonPointerReference($"{dataPointer}/toolCalls"))
+            .WithUpdatedNodes(new JsonPointerReference($"{dataPointer}/updatedNodes"))
             .WithThreadPath(threadPath)
             .WithMessageId(messageId);
 
@@ -352,56 +362,115 @@ private static UiControl BuildMessageOverview(
             .WithStyle(isUser ? "align-items: flex-end;" : "")
             .WithView(bubble);
 
-        // For assistant messages: show delegation sub-threads as clickable links
+        // Reactive metadata row for assistant cells: model · duration · tokens.
+        // Re-renders whenever CompletedAt or token fields change on the underlying message.
         if (!isUser)
         {
-            var messagePath = $"{threadPath}/{messageId}";
             container = container.WithView((h, c) =>
             {
-                var meshService = h.Hub.ServiceProvider.GetService<IMeshService>();
-                if (meshService == null) return Observable.Return<UiControl?>(null);
-
-                return Observable.FromAsync(async () =>
-                {
-                    try
-                    {
-                        var subs = await meshService
-                            .QueryAsync<MeshNode>($"namespace:{messagePath} nodeType:{ThreadNodeType.NodeType}")
-                            .ToListAsync();
-                        if (subs.Count == 0) return (UiControl?)null;
-                        return (UiControl?)BuildDelegationLinks(subs);
-                    }
-                    catch { return (UiControl?)null; }
-                });
+                var stream = h.Workspace.GetStream(new MeshNodeReference());
+                if (stream is null) return Observable.Return<UiControl?>(null);
+
+                return stream
+                    .Select(change => change.Value?.Content as ThreadMessage)
+                    .Where(m => m is not null)
+                    .Select(m => (
+                        Started: m!.Timestamp,
+                        Completed: m.CompletedAt,
+                        Model: m.ModelName,
+                        In: m.InputTokens,
+                        Out: m.OutputTokens,
+                        Total: m.TotalTokens))
+                    .DistinctUntilChanged()
+                    .Select(meta => BuildAssistantMetaRow(meta.Started, meta.Completed, meta.Model,
+                        meta.In, meta.Out, meta.Total));
             });
         }
 
+        // Delegation sub-threads are already shown inline inside the bubble (via the bubble's
+        // tool-calls data binding). An extra embedded LayoutAreaControl here produced a
+        // duplicate line with the same "Delegating to …" chip — redundant, so removed.
+        // To see full sub-thread progress, click through the delegation chip inside the bubble.
+
         container = container.WithView(actionRow);
         return container;
     }
 
     /// <summary>
-    /// Builds simple navigation links for delegation sub-threads.
-    /// Each sub-thread is rendered as a clickable link showing its name.
+    /// Formats a TimeSpan as compact h/m/s: e.g. "120ms", "1.8s", "42s", "1m 23s",
+    /// "1h 5m 30s". Zero components are dropped.
     /// </summary>
-    private static UiControl BuildDelegationLinks(IReadOnlyList<MeshNode> subThreads)
+    private static string FormatDurationHms(TimeSpan d)
     {
-        var sb = new System.Text.StringBuilder();
-        sb.Append("<div style=\"margin: 4px 0 8px 0;\">");
+        if (d.TotalMilliseconds < 1000) return $"{d.TotalMilliseconds:F0}ms";
+        if (d.TotalSeconds < 10) return $"{d.TotalSeconds:F1}s";
+        var parts = new List<string>();
+        var h = (int)d.TotalHours;
+        if (h > 0) parts.Add($"{h}h");
+        var m = d.Minutes;
+        if (m > 0 || h > 0) parts.Add($"{m}m");
+        parts.Add($"{d.Seconds}s");
+        return string.Join(' ', parts);
+    }
 
-        foreach (var st in subThreads)
+    /// <summary>
+    /// Builds the muted one-line metadata row shown below an assistant cell:
+    /// <c>HH:mm:ss · model · 1.8s · 1,247 in / 392 out (1,639 total)</c>. Returns
+    /// null when there's nothing to show (e.g. response still streaming and no model
+    /// yet known).
+    /// </summary>
+    private static UiControl? BuildAssistantMetaRow(
+        DateTime started, DateTime? completed, string? model,
+        int? input, int? output, int? total)
+    {
+        var parts = new List<string>();
+        parts.Add(started.ToLocalTime().ToString("HH:mm:ss"));
+        if (!string.IsNullOrEmpty(model))
+            parts.Add(System.Web.HttpUtility.HtmlEncode(model));
+        if (completed.HasValue)
+        {
+            parts.Add(FormatDurationHms(completed.Value - started));
+        }
+        if (input.HasValue || output.HasValue || total.HasValue)
         {
-            var name = System.Web.HttpUtility.HtmlEncode(
-                st.Name?.Length > 80 ? st.Name[..77] + "..." : st.Name ?? st.Id);
-            var href = $"/{st.Path}";
+            var inS = input?.ToString("N0") ?? "?";
+            var outS = output?.ToString("N0") ?? "?";
+            var totS = total?.ToString("N0");
+            var tokens = totS is null
+                ? $"{inS} in / {outS} out"
+                : $"{inS} in / {outS} out ({totS} total)";
+            parts.Add(tokens);
+        }
+        if (parts.Count == 0) return null;
+
+        var line = string.Join(" &middot; ", parts);
+        return Controls.Html(
+            $"<div style=\"font-size:0.72rem; color:var(--neutral-foreground-hint); margin:2px 0 6px 4px;\">{line}</div>");
+    }
 
-            sb.Append($"<a href=\"{href}\" style=\"display: flex; align-items: center; gap: 6px; padding: 2px 0; " +
-                       $"font-size: 0.8rem; color: var(--accent-fill-rest); text-decoration: none;\">" +
-                       $"<span style=\"font-size: 10px;\">&#8618;</span> {name}</a>");
+    /// <summary>
+    /// Builds an embedded stack of <see cref="LayoutAreaControl"/>s pointing at the
+    /// sub-thread's compact <c>Streaming</c> view. Each control opens its own
+    /// subscription against the sub-thread hub — the parent's execution loop never
+    /// reads or awaits the sub-thread's stream. Returns null when there are no
+    /// delegations.
+    /// </summary>
+    private static UiControl? BuildEmbeddedSubThreadAreas(IReadOnlyList<string> subThreadPaths)
+    {
+        if (subThreadPaths.Count == 0) return null;
+
+        var stack = Controls.Stack
+            .WithStyle("gap: 6px; margin: 6px 0 4px 8px; padding-left: 8px; " +
+                       "border-left: 2px solid var(--accent-fill-rest);");
+
+        foreach (var path in subThreadPaths)
+        {
+            var area = new LayoutAreaControl(path, new LayoutAreaReference("Streaming"))
+                .WithSpinnerType(SpinnerType.Skeleton);
+            stack = stack.WithView(area);
         }
 
-        sb.Append("</div>");
-        return Controls.Html(sb.ToString());
+        return stack;
     }
 
     /// <summary>
@@ -426,8 +495,9 @@ private static string ConvertReferencesToLinks(string text)
                 // Don't convert email addresses
                 if (path.Contains('@'))
                     return match.Value;
-                // Use @prefix in href — LinkUrlCleanupExtension will strip @ and resolve
-                return $"[`@{path}`](@{path})";
+                // Emit absolute href — @references from agents are always full paths
+                var href = path.StartsWith('/') ? path : $"/{path}";
+                return $"[`@{path}`]({href})";
             });
     }
 
diff --git a/src/MeshWeaver.AI/ThreadMessageViewModel.cs b/src/MeshWeaver.AI/ThreadMessageViewModel.cs
index be8668ed9..edf290514 100644
--- a/src/MeshWeaver.AI/ThreadMessageViewModel.cs
+++ b/src/MeshWeaver.AI/ThreadMessageViewModel.cs
@@ -16,6 +16,12 @@ public record ThreadMessageViewModel
     public string? Timestamp { get; init; }
     public string Text { get; init; } = "";
     public ImmutableList<ToolCallEntry> ToolCalls { get; init; } = [];
+    /// <summary>
+    /// Nodes this message's execution created / updated / deleted. The bubble cross-
+    /// references tool-call target paths against this list to render inline Diff and
+    /// Restore links next to each "Creating / Updating / Deleting X" chip.
+    /// </summary>
+    public ImmutableList<NodeChangeEntry> UpdatedNodes { get; init; } = [];
 
     public static ThreadMessageViewModel FromMessage(ThreadMessage msg) => new()
     {
@@ -24,7 +30,8 @@ public record ThreadMessageViewModel
         ModelName = msg.ModelName,
         Timestamp = msg.Timestamp.ToString("HH:mm:ss"),
         Text = msg.Text ?? "",
-        ToolCalls = msg.ToolCalls
+        ToolCalls = msg.ToolCalls,
+        UpdatedNodes = msg.UpdatedNodes
     };
 
     public virtual bool Equals(ThreadMessageViewModel? other)
@@ -35,7 +42,8 @@ public virtual bool Equals(ThreadMessageViewModel? other)
                && AuthorName == other.AuthorName
                && ModelName == other.ModelName
                && Text == other.Text
-               && ToolCalls.SequenceEqual(other.ToolCalls);
+               && ToolCalls.SequenceEqual(other.ToolCalls)
+               && UpdatedNodes.SequenceEqual(other.UpdatedNodes);
     }
 
     public override int GetHashCode()
@@ -44,6 +52,7 @@ public override int GetHashCode()
         hash.Add(Role);
         hash.Add(Text);
         hash.Add(ToolCalls.Count);
+        hash.Add(UpdatedNodes.Count);
         return hash.ToHashCode();
     }
 }
diff --git a/src/MeshWeaver.AI/ThreadNodeType.cs b/src/MeshWeaver.AI/ThreadNodeType.cs
index e82720c69..c1e5e979e 100644
--- a/src/MeshWeaver.AI/ThreadNodeType.cs
+++ b/src/MeshWeaver.AI/ThreadNodeType.cs
@@ -18,6 +18,14 @@ public static class ThreadNodeType
     /// </summary>
     public const string NodeType = "Thread";
 
+    /// <summary>
+    /// Default Icon for Thread instances. Must match <see cref="CreateMeshNode"/>.
+    /// Applied explicitly in <see cref="BuildThreadNode"/>/<see cref="BuildThreadWithMessages"/>
+    /// because thread creation goes via <c>CreateNodeRequest</c> on arbitrary parent hubs,
+    /// some of which don't have <c>INodeTypeService</c> registered to auto-copy the icon.
+    /// </summary>
+    public const string DefaultIcon = "/static/NodeTypeIcons/chat.svg";
+
     /// <summary>
     /// Satellite partition name for threads (like _Comment for comments).
     /// Threads are created at {contextPath}/_Thread/{speakingId}.
@@ -46,6 +54,13 @@ public static class ThreadNodeType
     /// </summary>
     public const string HistoryArea = "History";
 
+    /// <summary>
+    /// Layout area shown above the chat: parent-thread origin link (when this thread
+    /// is a delegation), aggregated list of nodes modified by this thread's execution
+    /// with version-before / version-after, and click-through to the version compare view.
+    /// </summary>
+    public const string HeaderArea = "Header";
+
     /// <summary>
     /// Generates a human-readable speaking ID from message text.
     /// Takes the first few words, lowercases, replaces non-alphanumeric with hyphens,
@@ -91,6 +106,7 @@ public static MeshNode BuildThreadNode(string contextPath, string messageText, s
         {
             Name = name,
             NodeType = NodeType,
+            Icon = DefaultIcon,
             MainNode = contextPath,
             Content = new Thread { CreatedBy = createdBy }
         };
@@ -124,6 +140,7 @@ public static (MeshNode Thread, string UserMsgId, string ResponseMsgId) BuildThr
         {
             Name = name,
             NodeType = NodeType,
+            Icon = DefaultIcon,
             MainNode = contextPath,
             Content = new Thread
             {
@@ -175,7 +192,7 @@ public static MeshNode CreateMeshNode(
         Func<MessageHubConfiguration, MessageHubConfiguration>? hubConfiguration = null) => new(NodeType)
         {
             Name = "Thread",
-            Icon = "/static/NodeTypeIcons/chat.svg",
+            Icon = DefaultIcon,
             IsSatelliteType = true,
             ExcludeFromContext = ImmutableHashSet.Create("search"),
             AssemblyLocation = typeof(ThreadNodeType).Assembly.Location,
diff --git a/src/MeshWeaver.AI/ThreadSubmission.cs b/src/MeshWeaver.AI/ThreadSubmission.cs
index aa367e59a..f7fd6a6bc 100644
--- a/src/MeshWeaver.AI/ThreadSubmission.cs
+++ b/src/MeshWeaver.AI/ThreadSubmission.cs
@@ -75,18 +75,113 @@ public static ImmutableList<string> FindUnprocessedUserMessages(MeshThread threa
     // ═════════════════════════════════════════════════════════════════════
 
     /// <summary>
-    /// Submits a user message into an existing thread. Fire-and-forget; the caller
-    /// observes the new user cell appear through the thread's remote MeshNode stream.
+    /// Submits a user message into an existing thread. Posts a single
+    /// <see cref="AppendUserMessageRequest"/> to the thread hub — the handler
+    /// runs <see cref="ThreadInput.AppendUserInput"/> locally (one atomic
+    /// <c>workspace.UpdateMeshNode</c>), and the server watcher then creates the
+    /// satellite cell and dispatches the round. No separate CreateNodeRequest from
+    /// the client — that was the duplicate-dispatch source in the legacy flow.
     /// </summary>
     public static void Submit(SubmitContext ctx)
-        => ThreadSubmissionClient.Submit(ctx);
+    {
+        if (string.IsNullOrEmpty(ctx.ThreadPath))
+        {
+            ctx.OnError?.Invoke("Submit requires ThreadPath. Use CreateThreadAndSubmit for new threads.");
+            return;
+        }
+
+        var delivery = ctx.Hub.Post(
+            new AppendUserMessageRequest
+            {
+                ThreadPath = ctx.ThreadPath!,
+                UserMessageId = Guid.NewGuid().ToString("N")[..8], // ignored by handler — kept for back-compat shape
+                UserText = ctx.UserText,
+                AgentName = ctx.AgentName,
+                ModelName = ctx.ModelName,
+                ContextPath = ctx.ContextPath,
+                Attachments = ctx.Attachments
+            },
+            o => o.WithTarget(new Address(ctx.ThreadPath!)));
+
+        if (delivery == null)
+        {
+            ctx.OnError?.Invoke("Hub.Post returned null");
+            return;
+        }
+
+        ctx.Hub.RegisterCallback((IMessageDelivery)delivery, response =>
+        {
+            if (response is IMessageDelivery<AppendUserMessageResponse> { Message.Success: false } fail)
+                ctx.OnError?.Invoke($"Submit failed: {fail.Message.Error ?? "unknown"}");
+            return response;
+        });
+    }
 
     /// <summary>
-    /// Creates a new thread node and submits the first user message. <see cref="SubmitContext.OnThreadCreated"/>
-    /// fires when the thread node is confirmed so the caller can navigate immediately.
+    /// Creates a new thread node, then submits the first user message via
+    /// <see cref="AppendUserMessageRequest"/> on the new thread.
+    /// <see cref="SubmitContext.OnThreadCreated"/> fires when the thread is confirmed.
     /// </summary>
     public static void CreateThreadAndSubmit(SubmitContext ctx)
-        => ThreadSubmissionClient.CreateThreadAndSubmit(ctx);
+    {
+        if (string.IsNullOrEmpty(ctx.Namespace))
+        {
+            ctx.OnError?.Invoke("CreateThreadAndSubmit requires Namespace.");
+            return;
+        }
+
+        var threadNode = ThreadNodeType.BuildThreadNode(ctx.Namespace!, ctx.UserText, ctx.CreatedBy);
+        var fallbackPath = threadNode.Path!;
+
+        var delivery = ctx.Hub.Post(
+            new CreateNodeRequest(threadNode),
+            o => o.WithTarget(new Address(ctx.Namespace!)));
+
+        if (delivery == null)
+        {
+            ctx.OnError?.Invoke("Hub.Post returned null");
+            return;
+        }
+
+        ctx.Hub.RegisterCallback((IMessageDelivery)delivery, response =>
+        {
+            if (response is not IMessageDelivery<CreateNodeResponse> { Message.Success: true } cnr)
+            {
+                var err = (response as IMessageDelivery<CreateNodeResponse>)?.Message.Error ?? "unknown";
+                ctx.OnError?.Invoke($"Thread creation failed: {err}");
+                return response;
+            }
+
+            var createdNode = cnr.Message.Node ?? threadNode;
+            var createdPath = createdNode.Path ?? fallbackPath;
+            ctx.OnThreadCreated?.Invoke(createdNode);
+
+            var append = ctx.Hub.Post(
+                new AppendUserMessageRequest
+                {
+                    ThreadPath = createdPath,
+                    UserMessageId = Guid.NewGuid().ToString("N")[..8],
+                    UserText = ctx.UserText,
+                    AgentName = ctx.AgentName,
+                    ModelName = ctx.ModelName,
+                    ContextPath = ctx.ContextPath,
+                    Attachments = ctx.Attachments
+                },
+                o => o.WithTarget(new Address(createdPath)));
+
+            if (append != null)
+            {
+                ctx.Hub.RegisterCallback((IMessageDelivery)append, appendResp =>
+                {
+                    if (appendResp is IMessageDelivery<AppendUserMessageResponse> { Message.Success: false } fail)
+                        ctx.OnError?.Invoke($"Append after thread create failed: {fail.Message.Error ?? "unknown"}");
+                    return appendResp;
+                });
+            }
+
+            return response;
+        });
+    }
 
     /// <summary>
     /// Resubmits an existing user message: truncates <c>Messages</c> and <c>IngestedMessageIds</c>
@@ -94,7 +189,37 @@ public static void CreateThreadAndSubmit(SubmitContext ctx)
     /// creates a new output cell.
     /// </summary>
     public static void Resubmit(ResubmitContext ctx)
-        => ThreadSubmissionClient.Resubmit(ctx);
+    {
+        if (string.IsNullOrEmpty(ctx.ThreadPath) || string.IsNullOrEmpty(ctx.UserMessageIdToReplay))
+        {
+            ctx.OnError?.Invoke("Resubmit requires ThreadPath and UserMessageIdToReplay.");
+            return;
+        }
+
+        var delivery = ctx.Hub.Post(
+            new ResubmitUserMessageRequest
+            {
+                ThreadPath = ctx.ThreadPath,
+                UserMessageId = ctx.UserMessageIdToReplay,
+                NewUserText = ctx.NewUserText,
+                AgentName = ctx.AgentName,
+                ModelName = ctx.ModelName
+            },
+            o => o.WithTarget(new Address(ctx.ThreadPath)));
+
+        if (delivery == null)
+        {
+            ctx.OnError?.Invoke("Hub.Post returned null");
+            return;
+        }
+
+        ctx.Hub.RegisterCallback((IMessageDelivery)delivery, response =>
+        {
+            if (response is IMessageDelivery<AppendUserMessageResponse> { Message.Success: false } fail)
+                ctx.OnError?.Invoke($"Resubmit failed: {fail.Message.Error ?? "unknown"}");
+            return response;
+        });
+    }
 
     // ═════════════════════════════════════════════════════════════════════
     // Server-side API — invoked from thread hub initialization
@@ -113,40 +238,36 @@ public static IDisposable InstallServerWatcher(IMessageHub threadHub)
     // ═════════════════════════════════════════════════════════════════════
 
     /// <summary>
-    /// Thread-hub handler: registers a new user message id on the thread, stores Pending*,
-    /// and lets the watcher dispatch. Runs on the thread hub's scheduler — only one
-    /// AppendUserMessageRequest is processed at a time, so the state update is atomic
-    /// and patch-safe.
+    /// Thread-hub handler kept as a back-compat shim: re-routes legacy
+    /// <see cref="AppendUserMessageRequest"/> through the new <see cref="ThreadInput.AppendUserInput"/>
+    /// path. New callers should write directly to the thread's MeshNode via ThreadInput
+    /// instead of posting this request.
     /// </summary>
     public static IMessageDelivery HandleAppendUserMessage(
         IMessageHub hub,
         IMessageDelivery<AppendUserMessageRequest> delivery)
     {
         var req = delivery.Message;
-        hub.GetWorkspace().UpdateMeshNode(node =>
+        try
         {
-            var t = node.Content as MeshThread ?? new MeshThread();
-            var msgs = t.Messages.Contains(req.UserMessageId) ? t.Messages : t.Messages.Add(req.UserMessageId);
-            var userIds = t.UserMessageIds.Contains(req.UserMessageId) ? t.UserMessageIds : t.UserMessageIds.Add(req.UserMessageId);
-            // Accumulate queued text into PendingUserMessage. DispatchRound reads and clears it.
-            var pending = string.IsNullOrEmpty(t.PendingUserMessage)
-                ? req.UserText
-                : $"{t.PendingUserMessage}\n\n---\n\n{req.UserText}";
-            return node with
-            {
-                Content = t with
-                {
-                    Messages = msgs,
-                    UserMessageIds = userIds,
-                    PendingUserMessage = pending,
-                    PendingAgentName = req.AgentName ?? t.PendingAgentName,
-                    PendingModelName = req.ModelName ?? t.PendingModelName,
-                    PendingContextPath = req.ContextPath ?? t.PendingContextPath,
-                    PendingAttachments = req.Attachments?.ToImmutableList() ?? t.PendingAttachments
-                }
-            };
-        });
-        hub.Post(new AppendUserMessageResponse { Success = true }, o => o.ResponseFor(delivery));
+            var msg = ThreadInput.CreateUserMessage(
+                req.UserText,
+                createdBy: delivery.AccessContext?.ObjectId,
+                authorName: null,
+                agentName: req.AgentName,
+                modelName: req.ModelName,
+                contextPath: req.ContextPath,
+                attachments: req.Attachments);
+            // Note: this shim ignores req.UserMessageId — the new flow allocates its own.
+            // Tests + the legacy client posted the id eagerly; the new flow only uses
+            // server-allocated ids so we don't honour the request's id here.
+            ThreadInput.AppendUserInput(hub.GetWorkspace(), req.ThreadPath, msg);
+            hub.Post(new AppendUserMessageResponse { Success = true }, o => o.ResponseFor(delivery));
+        }
+        catch (Exception ex)
+        {
+            hub.Post(new AppendUserMessageResponse { Success = false, Error = ex.Message }, o => o.ResponseFor(delivery));
+        }
         return delivery.Processed();
     }
 
@@ -340,235 +461,6 @@ public sealed record RoundDispatch(
     string? ContextPath,
     IReadOnlyList<string>? Attachments);
 
-/// <summary>
-/// Client-side submission logic. All methods are void / fire-and-forget.
-/// The client only posts CreateNodeRequest — the server watcher does all Thread-state bookkeeping
-/// (append to Messages/UserMessageIds, set Pending*, dispatch). This avoids remote-stream write
-/// races that produce out-of-bounds JSON patches.
-/// </summary>
-internal static class ThreadSubmissionClient
-{
-    private static string NewId() => Guid.NewGuid().ToString("N")[..8];
-
-    public static void Submit(SubmitContext ctx)
-    {
-        if (string.IsNullOrEmpty(ctx.ThreadPath))
-        {
-            ctx.OnError?.Invoke("Submit requires ThreadPath. Use CreateThreadAndSubmit for new threads.");
-            return;
-        }
-
-        var userMsgId = NewId();
-        var threadAddr = new Address(ctx.ThreadPath);
-        var userCell = BuildUserCell(userMsgId, ctx.ThreadPath, ctx);
-
-        void ReportFailure(string reason)
-        {
-            PostFailureRecord(ctx.Hub, ctx.ThreadPath!, userMsgId, ctx.UserText, reason);
-            ctx.OnError?.Invoke(reason);
-        }
-
-        // 1) Create the user cell.
-        var createDelivery = ctx.Hub.Post(
-            new CreateNodeRequest(userCell),
-            o => o.WithTarget(threadAddr));
-
-        if (createDelivery != null)
-        {
-            ctx.Hub.RegisterCallback((IMessageDelivery)createDelivery, response =>
-            {
-                if (response is IMessageDelivery<CreateNodeResponse> { Message.Success: false } fail)
-                    ReportFailure($"User cell creation failed: {fail.Message.Error ?? "unknown"}");
-                return response;
-            });
-        }
-
-        // 2) Tell the thread hub to register the id and queue it.
-        var appendDelivery = ctx.Hub.Post(
-            new AppendUserMessageRequest
-            {
-                ThreadPath = ctx.ThreadPath,
-                UserMessageId = userMsgId,
-                UserText = ctx.UserText,
-                AgentName = ctx.AgentName,
-                ModelName = ctx.ModelName,
-                ContextPath = ctx.ContextPath,
-                Attachments = ctx.Attachments
-            },
-            o => o.WithTarget(threadAddr));
-
-        if (appendDelivery != null)
-        {
-            ctx.Hub.RegisterCallback((IMessageDelivery)appendDelivery, response =>
-            {
-                if (response is IMessageDelivery<AppendUserMessageResponse> { Message.Success: false } fail)
-                    ReportFailure($"Append failed: {fail.Message.Error ?? "unknown"}");
-                return response;
-            });
-        }
-    }
-
-    public static void CreateThreadAndSubmit(SubmitContext ctx)
-    {
-        if (string.IsNullOrEmpty(ctx.Namespace))
-        {
-            ctx.OnError?.Invoke("CreateThreadAndSubmit requires Namespace.");
-            return;
-        }
-
-        var userMsgId = NewId();
-
-        // Build an empty thread node. The server watcher will populate Messages/UserMessageIds
-        // once the user cell is created.
-        var threadNode = ThreadNodeType.BuildThreadNode(ctx.Namespace, ctx.UserText, ctx.CreatedBy);
-        var threadPath = threadNode.Path!;
-        var userCell = BuildUserCell(userMsgId, threadPath, ctx);
-
-        var delivery = ctx.Hub.Post(
-            new CreateNodeRequest(threadNode),
-            o => o.WithTarget(new Address(ctx.Namespace)));
-
-        if (delivery == null)
-        {
-            ctx.OnError?.Invoke("Hub.Post returned null");
-            return;
-        }
-
-        ctx.Hub.RegisterCallback((IMessageDelivery)delivery, response =>
-        {
-            if (response is not IMessageDelivery<CreateNodeResponse> { Message.Success: true } cnr)
-            {
-                var err = (response as IMessageDelivery<CreateNodeResponse>)?.Message.Error ?? "unknown";
-                ctx.OnError?.Invoke($"Thread creation failed: {err}");
-                return response;
-            }
-
-            var createdNode = cnr.Message.Node ?? threadNode;
-            var createdPath = createdNode.Path ?? threadPath;
-            ctx.OnThreadCreated?.Invoke(createdNode);
-
-            var threadAddr = new Address(createdPath);
-
-            // Create the user cell on the new thread.
-            var cellDelivery = ctx.Hub.Post(
-                new CreateNodeRequest(userCell),
-                o => o.WithTarget(threadAddr));
-
-            if (cellDelivery is not null)
-            {
-                ctx.Hub.RegisterCallback((IMessageDelivery)cellDelivery, cellResp =>
-                {
-                    if (cellResp is IMessageDelivery<CreateNodeResponse> { Message.Success: false } cellFail)
-                        ctx.OnError?.Invoke($"User cell creation failed: {cellFail.Message.Error ?? "unknown"}");
-                    return cellResp;
-                });
-            }
-
-            // Tell the thread hub to register the id + queue it.
-            var appendDelivery = ctx.Hub.Post(
-                new AppendUserMessageRequest
-                {
-                    ThreadPath = createdPath,
-                    UserMessageId = userMsgId,
-                    UserText = ctx.UserText,
-                    AgentName = ctx.AgentName,
-                    ModelName = ctx.ModelName,
-                    ContextPath = ctx.ContextPath,
-                    Attachments = ctx.Attachments
-                },
-                o => o.WithTarget(threadAddr));
-
-            if (appendDelivery is not null)
-            {
-                ctx.Hub.RegisterCallback((IMessageDelivery)appendDelivery, appendResp =>
-                {
-                    if (appendResp is IMessageDelivery<AppendUserMessageResponse> { Message.Success: false } fail)
-                        ctx.OnError?.Invoke($"Append failed: {fail.Message.Error ?? "unknown"}");
-                    return appendResp;
-                });
-            }
-
-            return response;
-        });
-    }
-
-    public static void Resubmit(ResubmitContext ctx)
-    {
-        if (string.IsNullOrEmpty(ctx.ThreadPath) || string.IsNullOrEmpty(ctx.UserMessageIdToReplay))
-        {
-            ctx.OnError?.Invoke("Resubmit requires ThreadPath and UserMessageIdToReplay.");
-            return;
-        }
-
-        var delivery = ctx.Hub.Post(
-            new ResubmitUserMessageRequest
-            {
-                ThreadPath = ctx.ThreadPath,
-                UserMessageId = ctx.UserMessageIdToReplay,
-                NewUserText = ctx.NewUserText,
-                AgentName = ctx.AgentName,
-                ModelName = ctx.ModelName
-            },
-            o => o.WithTarget(new Address(ctx.ThreadPath)));
-
-        if (delivery == null)
-        {
-            ctx.OnError?.Invoke("Hub.Post returned null");
-            return;
-        }
-
-        ctx.Hub.RegisterCallback((IMessageDelivery)delivery, response =>
-        {
-            if (response is IMessageDelivery<AppendUserMessageResponse> { Message.Success: false } fail)
-                ctx.OnError?.Invoke($"Resubmit failed: {fail.Message.Error ?? "unknown"}");
-            return response;
-        });
-    }
-
-    /// <summary>
-    /// Fire-and-forget post of a <see cref="RecordSubmissionFailureRequest"/> so the thread
-    /// shows the failure as an error response cell. If this post also fails, we've exhausted
-    /// recovery — swallow silently (the OnError callback is still invoked separately).
-    /// </summary>
-    private static void PostFailureRecord(
-        IMessageHub hub, string threadPath, string userMsgId, string userText, string error)
-    {
-        try
-        {
-            hub.Post(
-                new RecordSubmissionFailureRequest
-                {
-                    ThreadPath = threadPath,
-                    UserMessageId = userMsgId,
-                    UserText = userText,
-                    ErrorMessage = error
-                },
-                o => o.WithTarget(new Address(threadPath)));
-        }
-        catch { /* swallow — caller's OnError will still fire */ }
-    }
-
-    private static MeshNode BuildUserCell(string userMsgId, string threadPath, SubmitContext ctx)
-        => new(userMsgId, threadPath)
-        {
-            NodeType = ThreadMessageNodeType.NodeType,
-            MainNode = ctx.ContextPath ?? threadPath,
-            Content = new ThreadMessage
-            {
-                Role = "user",
-                AuthorName = ctx.AuthorName,
-                Text = ctx.UserText,
-                Timestamp = DateTime.UtcNow,
-                Type = ThreadMessageType.ExecutedInput,
-                CreatedBy = ctx.CreatedBy,
-                AgentName = ctx.AgentName,
-                ModelName = ctx.ModelName,
-                ContextPath = ctx.ContextPath,
-                Attachments = ctx.Attachments
-            }
-        };
-}
-
 /// <summary>
 /// Server-side watcher: observes thread state changes and dispatches execution rounds.
 /// Installed once on thread hub initialization. Non-blocking; uses only Post + RegisterCallback
@@ -583,34 +475,49 @@ public static IDisposable InstallServerWatcher(IMessageHub threadHub)
         var threadPath = threadHub.Address.Path;
 
         // Reentrancy guard: 0=idle, 1=dispatching.
-        // Combined with the thread's IsExecuting flag, prevents double-dispatch
-        // between "start dispatching" and "IsExecuting=true visible on stream".
+        // Held until IsExecuting=true is observed back through the same stream, so a
+        // re-emission triggered by our own response-cell write or PendingUserMessages
+        // patch can't double-dispatch.
         var dispatching = 0;
 
-        var sub = workspace.GetStream<MeshNode>()
-            ?.Subscribe(nodes =>
+        // Subscribe to this thread's own MeshNode (via MeshNodeReference) instead of the
+        // collection-wide stream — fewer wakeups, and the patches we observe are exactly
+        // the writes against this thread.
+        //
+        // Throttle by a small window so a burst of rapid AppendUserMessageRequest patches
+        // (user submits 3 messages in quick succession, or the GUI batches submits) coalesce
+        // into a SINGLE dispatch with all the queued user ids in one round / one response
+        // cell. Without throttling each patch individually wins the reentrancy guard and
+        // produces one round per submit.
+        var sub = workspace.GetStream(new MeshNodeReference())
+            ?.Throttle(TimeSpan.FromMilliseconds(50))
+            ?.Subscribe(change =>
             {
-                if (nodes == null) return;
+                var threadNode = change.Value;
+                if (threadNode?.Content is not MeshThread thread) return;
+
+                // IsExecuting=true is visible — we held the guard waiting for this commit.
+                if (thread.IsExecuting && dispatching == 1)
+                {
+                    Interlocked.Exchange(ref dispatching, 0);
+                    return;
+                }
+                if (thread.IsExecuting) return;
+
                 if (Interlocked.CompareExchange(ref dispatching, 1, 0) != 0)
                     return;
 
+                var releaseGuard = true;
                 try
                 {
-                    var threadNode = nodes.FirstOrDefault(n => n.Path == threadPath);
-                    if (threadNode?.Content is not MeshThread thread) return;
-
-                    // Queue-don't-cancel: if the thread is executing, do nothing. The queued
-                    // user messages stay in UserMessageIds; as soon as IsExecuting flips to
-                    // false (current round completed naturally), we dispatch the next round.
-                    // This matches Claude Code / Anthropic's recommended pattern — the Messages
-                    // API doesn't support mid-stream injection and cancelling during a tool_use
-                    // produces orphaned blocks that need synthetic tool_result recovery.
-                    if (thread.IsExecuting) return;
-
                     var dispatch = ThreadSubmission.PlanNextRound(thread);
                     if (dispatch is null) return;
 
-                    DispatchRound(threadHub, threadNode, dispatch, logger);
+                    // Hold the guard. It will be released when we observe IsExecuting=true
+                    // back on this same stream above (or on hard failure inside DispatchRound).
+                    releaseGuard = false;
+                    DispatchRound(threadHub, threadNode, dispatch, logger,
+                        onFailure: () => Interlocked.Exchange(ref dispatching, 0));
                 }
                 catch (Exception ex)
                 {
@@ -618,7 +525,7 @@ public static IDisposable InstallServerWatcher(IMessageHub threadHub)
                 }
                 finally
                 {
-                    Interlocked.Exchange(ref dispatching, 0);
+                    if (releaseGuard) Interlocked.Exchange(ref dispatching, 0);
                 }
             });
 
@@ -629,12 +536,17 @@ public static IDisposable InstallServerWatcher(IMessageHub threadHub)
     /// Creates the output cell, writes the committed round to the thread node, and
     /// fires off agent execution on the _Exec hosted hub. Non-blocking — all
     /// Hub.Post + RegisterCallback; the workspace write is a synchronous fire-and-forget.
+    ///
+    /// Step 0 (new): for each unprocessed user id present in <see cref="MeshThread.PendingUserMessages"/>,
+    /// create the satellite ThreadMessage cell. The client only writes the thread node;
+    /// the server materializes the per-message satellite nodes here.
     /// </summary>
     private static void DispatchRound(
         IMessageHub hub,
         MeshNode threadNode,
         RoundDispatch dispatch,
-        ILogger<AgentChatClient>? logger)
+        ILogger<AgentChatClient>? logger,
+        Action? onFailure = null)
     {
         var threadPath = hub.Address.Path;
         var responseMsgId = dispatch.ResponseMessageId;
@@ -642,10 +554,6 @@ private static void DispatchRound(
         var thread = threadNode.Content as MeshThread ?? new MeshThread();
         var mainEntity = threadNode.MainNode ?? dispatch.ContextPath ?? threadPath;
 
-        // PendingUserMessage contains the concatenated text of all user messages queued by
-        // AppendUserMessageRequest handlers since the last dispatch.
-        var combinedUserText = thread.PendingUserMessage ?? "";
-
         var accessService = hub.ServiceProvider.GetService<AccessService>();
         var userCtx = accessService?.Context ?? accessService?.CircuitContext;
         if (userCtx is null && !string.IsNullOrEmpty(thread.CreatedBy))
@@ -653,100 +561,180 @@ private static void DispatchRound(
             userCtx = new AccessContext { ObjectId = thread.CreatedBy, Name = thread.CreatedBy };
         }
 
-        // Step 1: create the assistant output cell (CreateNodeRequest → RegisterCallback).
-        var responseCell = new MeshNode(responseMsgId, threadPath)
-        {
-            NodeType = ThreadMessageNodeType.NodeType,
-            MainNode = mainEntity,
-            Content = new ThreadMessage
-            {
-                Role = "assistant",
-                Text = "",
-                Timestamp = DateTime.UtcNow,
-                Type = ThreadMessageType.AgentResponse,
-                AgentName = dispatch.AgentName,
-                ModelName = dispatch.ModelName
-            }
-        };
+        var meshService = hub.ServiceProvider.GetRequiredService<IMeshService>();
 
-        var createDelivery = hub.Post(
-            new CreateNodeRequest(responseCell),
-            o => userCtx != null ? o.WithAccessContext(userCtx).WithTarget(hub.Address) : o.WithTarget(hub.Address));
+        // Step 0: materialize user satellite cells from PendingUserMessages.
+        // Only ids present in dispatch.UserMessageIds AND PendingUserMessages need creation
+        // here — legacy paths (PendingUserMessage string) create cells elsewhere.
+        var pendingForRound = dispatch.UserMessageIds
+            .Where(id => thread.PendingUserMessages.ContainsKey(id))
+            .Select(id => (Id: id, Msg: thread.PendingUserMessages[id]))
+            .ToImmutableList();
 
-        if (createDelivery == null)
-        {
-            logger?.LogWarning("[ThreadSubmission] Post of CreateNodeRequest returned null for response cell {ResponseMsgId} on {ThreadPath}",
-                responseMsgId, threadPath);
-            return;
-        }
+        var combinedUserText = pendingForRound.Count > 0
+            ? string.Join("\n\n---\n\n", pendingForRound.Select(p => p.Msg.Text))
+            : (thread.PendingUserMessage ?? "");
 
-        hub.RegisterCallback((IMessageDelivery)createDelivery, response =>
+        void AfterUserCellsReady()
         {
-            if (response is not IMessageDelivery<CreateNodeResponse> { Message.Success: true })
+            // Step 1: create the assistant output cell (CreateNodeRequest → RegisterCallback).
+            var responseCell = new MeshNode(responseMsgId, threadPath)
             {
-                var err = (response as IMessageDelivery<CreateNodeResponse>)?.Message.Error ?? "unknown";
-                logger?.LogWarning("[ThreadSubmission] Response cell creation failed for {ResponseMsgId} on {ThreadPath}: {Error}",
-                    responseMsgId, threadPath, err);
-                return response;
+                NodeType = ThreadMessageNodeType.NodeType,
+                MainNode = mainEntity,
+                Content = new ThreadMessage
+                {
+                    Role = "assistant",
+                    Text = "",
+                    Timestamp = DateTime.UtcNow,
+                    Type = ThreadMessageType.AgentResponse,
+                    AgentName = dispatch.AgentName,
+                    ModelName = dispatch.ModelName
+                }
+            };
+
+            var createDelivery = hub.Post(
+                new CreateNodeRequest(responseCell),
+                o => userCtx != null
+                    ? o.WithAccessContext(userCtx).WithTarget(hub.Address)
+                    : o.WithTarget(hub.Address));
+
+            if (createDelivery == null)
+            {
+                logger?.LogWarning("[ThreadSubmission] Post of CreateNodeRequest returned null for response cell {ResponseMsgId} on {ThreadPath}",
+                    responseMsgId, threadPath);
+                onFailure?.Invoke();
+                return;
             }
 
-            // Step 2: commit the round to the thread state (one atomic UpdateMeshNode).
-            hub.GetWorkspace().UpdateMeshNode(node =>
+            hub.RegisterCallback((IMessageDelivery)createDelivery, response =>
             {
-                var t = node.Content as MeshThread ?? new MeshThread();
-                var msgs = t.Messages.Contains(responseMsgId) ? t.Messages : t.Messages.Add(responseMsgId);
-                var ingested = t.IngestedMessageIds;
-                foreach (var uid in dispatch.UserMessageIds)
+                if (response is not IMessageDelivery<CreateNodeResponse> { Message.Success: true })
                 {
-                    if (!ingested.Contains(uid))
-                        ingested = ingested.Add(uid);
+                    var err = (response as IMessageDelivery<CreateNodeResponse>)?.Message.Error ?? "unknown";
+                    logger?.LogWarning("[ThreadSubmission] Response cell creation failed for {ResponseMsgId} on {ThreadPath}: {Error}",
+                        responseMsgId, threadPath, err);
+                    onFailure?.Invoke();
+                    return response;
                 }
-                return node with
+
+                // Step 2: commit the round to the thread state (one atomic UpdateMeshNode).
+                // Both the user satellite cells (created above in the materialization step)
+                // and the response satellite cell (just confirmed in the CreateNodeRequest
+                // callback above) exist on the hub now. Only NOW do we add their ids into
+                // Messages — the GUI iterates Messages to render LayoutAreaControls, so
+                // every id it sees has a backing satellite.
+                //
+                // The IsExecuting check is the idempotency guard — every other watcher
+                // emission in this round skips, so this body runs exactly once per round.
+                hub.GetWorkspace().UpdateMeshNode(node =>
                 {
-                    Content = t with
+                    var t = node.Content as MeshThread ?? new MeshThread();
+                    if (t.IsExecuting) return node;
+
+                    // User ids in dispatch order, then the response id last.
+                    // Contains check covers the resubmit case where u1 was already in
+                    // Messages from a prior round — ApplyResubmit removed u1 from
+                    // IngestedMessageIds (so the watcher re-dispatches it) but kept it
+                    // in Messages, so a blind AddRange would duplicate it.
+                    var msgs = t.Messages;
+                    foreach (var uid in dispatch.UserMessageIds)
+                        if (!msgs.Contains(uid)) msgs = msgs.Add(uid);
+                    msgs = msgs.Add(responseMsgId);
+
+                    var ingested = t.IngestedMessageIds.AddRange(
+                        dispatch.UserMessageIds.Where(uid => !t.IngestedMessageIds.Contains(uid)));
+
+                    // Drop consumed PendingUserMessages entries — their satellites now exist
+                    // and their ids are now in Messages.
+                    var pending = t.PendingUserMessages;
+                    foreach (var (uid, _) in pendingForRound)
+                        pending = pending.Remove(uid);
+
+                    return node with
                     {
-                        Messages = msgs,
-                        IngestedMessageIds = ingested,
-                        IsExecuting = true,
-                        ActiveMessageId = responseMsgId,
-                        ExecutionStartedAt = DateTime.UtcNow,
-                        TokensUsed = 0,
-                        ExecutionStatus = null,
-                        // Clear PendingUserMessage — the round's text is already captured in combinedUserText.
-                        // Next AppendUserMessageRequest starts accumulating fresh for the next round.
-                        PendingUserMessage = null,
-                        PendingContextPath = dispatch.ContextPath,
-                        PendingAttachments = dispatch.Attachments?.ToImmutableList()
-                    }
-                };
-            });
+                        Content = t with
+                        {
+                            Messages = msgs,
+                            IngestedMessageIds = ingested,
+                            IsExecuting = true,
+                            ActiveMessageId = responseMsgId,
+                            ExecutionStartedAt = DateTime.UtcNow,
+                            TokensUsed = 0,
+                            ExecutionStatus = null,
+                            PendingUserMessage = null,
+                            PendingUserMessages = pending,
+                            PendingContextPath = dispatch.ContextPath,
+                            PendingAttachments = dispatch.Attachments?.ToImmutableList()
+                        }
+                    };
+                });
 
-            hub.Post(
-                new UpdateThreadMessageContent { Text = "Allocating agent..." },
-                o => o.WithTarget(new Address(responsePath)));
+                hub.Post(
+                    new UpdateThreadMessageContent { Text = "Allocating agent..." },
+                    o => o.WithTarget(new Address(responsePath)));
 
-            // Step 3: post to _Exec hosted hub — actual agent streaming runs there.
-            var executionHub = hub.GetHostedHub(
-                new Address($"{hub.Address}/_Exec"),
-                config => config.WithHandler<SubmitMessageRequest>(ThreadExecution.ExecuteMessageAsync),
-                HostedHubCreation.Always);
+                // Step 3: post to _Exec hosted hub — actual agent streaming runs there.
+                var executionHub = hub.GetHostedHub(
+                    new Address($"{hub.Address}/_Exec"),
+                    config => config.WithHandler<SubmitMessageRequest>(ThreadExecution.ExecuteMessageAsync),
+                    HostedHubCreation.Always);
 
-            executionHub!.Post(
-                new SubmitMessageRequest
+                executionHub!.Post(
+                    new SubmitMessageRequest
+                    {
+                        ThreadPath = threadPath,
+                        UserMessageText = combinedUserText,
+                        UserMessageId = dispatch.UserMessageIds.LastOrDefault(),
+                        ResponseMessageId = responseMsgId,
+                        ResponsePath = responsePath,
+                        AgentName = dispatch.AgentName,
+                        ModelName = dispatch.ModelName,
+                        ContextPath = dispatch.ContextPath,
+                        Attachments = dispatch.Attachments
+                    },
+                    o => userCtx != null ? o.WithAccessContext(userCtx) : o);
+
+                return response;
+            });
+        }
+
+        if (pendingForRound.Count == 0)
+        {
+            AfterUserCellsReady();
+            return;
+        }
+
+        // Materialize satellite cells in parallel, then proceed. We swallow per-cell errors
+        // (cell may already exist from a prior crashed attempt — that's recoverable) and only
+        // wait for one notification per cell before continuing.
+        var creationStreams = pendingForRound.Select(p =>
+        {
+            var cell = new MeshNode(p.Id, threadPath)
+            {
+                NodeType = ThreadMessageNodeType.NodeType,
+                MainNode = mainEntity,
+                Content = p.Msg
+            };
+            return meshService.CreateNode(cell)
+                .Take(1)
+                .Select(_ => true)
+                .Catch<bool, Exception>(ex =>
                 {
-                    ThreadPath = threadPath,
-                    UserMessageText = combinedUserText,
-                    UserMessageId = dispatch.UserMessageIds.LastOrDefault(),
-                    ResponseMessageId = responseMsgId,
-                    ResponsePath = responsePath,
-                    AgentName = dispatch.AgentName,
-                    ModelName = dispatch.ModelName,
-                    ContextPath = dispatch.ContextPath,
-                    Attachments = dispatch.Attachments
-                },
-                o => userCtx != null ? o.WithAccessContext(userCtx) : o);
+                    logger?.LogDebug(ex, "[ThreadSubmission] User cell create returned error (may already exist) for {Path}",
+                        $"{threadPath}/{p.Id}");
+                    return Observable.Return(true);
+                });
+        }).ToList();
 
-            return response;
-        });
+        Observable.CombineLatest(creationStreams)
+            .Take(1)
+            .Subscribe(
+                _ => AfterUserCellsReady(),
+                ex =>
+                {
+                    logger?.LogWarning(ex, "[ThreadSubmission] User cell materialization failed for {ThreadPath}", threadPath);
+                    onFailure?.Invoke();
+                });
     }
 }
diff --git a/src/MeshWeaver.AI/UpdateThreadMessageContent.cs b/src/MeshWeaver.AI/UpdateThreadMessageContent.cs
index ead099905..f038f9536 100644
--- a/src/MeshWeaver.AI/UpdateThreadMessageContent.cs
+++ b/src/MeshWeaver.AI/UpdateThreadMessageContent.cs
@@ -9,9 +9,28 @@ namespace MeshWeaver.AI;
 /// </summary>
 public record UpdateThreadMessageContent
 {
+    /// <summary>
+    /// Incremental text chunk to APPEND to the current message Text. The preferred shape
+    /// for streaming — each chunk just carries the new bytes since the previous update.
+    /// </summary>
+    public string? TextDelta { get; init; }
+
+    /// <summary>
+    /// Full text replacement. Only set for final-state writes (completion text, error text,
+    /// cancel markers). Streaming should use <see cref="TextDelta"/> instead.
+    /// </summary>
     public string? Text { get; init; }
+
     public ImmutableList<ToolCallEntry>? ToolCalls { get; init; }
     public ImmutableList<NodeChangeEntry>? UpdatedNodes { get; init; }
     public string? AgentName { get; init; }
     public string? ModelName { get; init; }
+
+    /// <summary>Token usage from the model provider. Set on the final update of a round.</summary>
+    public int? InputTokens { get; init; }
+    public int? OutputTokens { get; init; }
+    public int? TotalTokens { get; init; }
+
+    /// <summary>Wall-clock completion timestamp. Set on the final update of a round.</summary>
+    public DateTime? CompletedAt { get; init; }
 }
diff --git a/src/MeshWeaver.Blazor.AI/McpMeshPlugin.cs b/src/MeshWeaver.Blazor.AI/McpMeshPlugin.cs
index 61a15c10c..5fcd3d332 100644
--- a/src/MeshWeaver.Blazor.AI/McpMeshPlugin.cs
+++ b/src/MeshWeaver.Blazor.AI/McpMeshPlugin.cs
@@ -69,6 +69,18 @@ public string NavigateTo(
         var resolvedPath = MeshOperations.ResolvePath(path);
         return $"{baseUrl}/node/{Uri.EscapeDataString(resolvedPath)}";
     }
+
+    [McpServerTool]
+    [Description("Returns compilation diagnostics for a NodeType (or any instance of one). Status is 'Ok' when the type compiled cleanly, 'Error' with details when it failed, 'Compiling' while a compile is in progress (with elapsedMs), or 'Unknown' when no compile has happened yet. Use after creating/updating a NodeType to verify it actually compiles — a NodeType that doesn't compile is not 'done'.")]
+    public Task<string> GetDiagnostics(
+        [Description("Path to a NodeType (e.g., @Systemorph/SocialMedia/Profile) or to any instance of one")] string path)
+        => ops.GetDiagnostics(path);
+
+    [McpServerTool]
+    [Description("Recycles the hub at the given path by posting DisposeRequest. Forces a fresh hub initialization on the next access — use after fixing a broken NodeType, after editing the `sources` list, or whenever a grain is stuck in a cached bad state. Returns {status:'Recycled', path}. Wait ~100ms before the next access so the grain teardown completes.")]
+    public Task<string> Recycle(
+        [Description("Path to the node (e.g., @Systemorph/SocialMedia/Profile). Use the NodeType path to recycle the whole type; use an instance path to recycle just that instance's hub.")] string path)
+        => ops.Recycle(path);
 }
 
 /// <summary>
diff --git a/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor b/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor
index 5f75538b5..20b63200b 100644
--- a/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor
+++ b/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor
@@ -32,6 +32,13 @@ else
     @if (!ViewModel.HideEmptyState)
     {
         <div class="thread-chat-messages" @ref="messagesContainer">
+            @{
+                var header = GetHeaderCell();
+            }
+            @if (header != null)
+            {
+                <LayoutAreaView @key="@($"hdr-{threadPath}")" ViewModel="@header" Stream="@Stream" Area="@($"hdr-{threadPath}")" />
+            }
             @if (ThreadMessages.Count > 0)
             {
                 @foreach (var msgId in ThreadMessages)
@@ -94,6 +101,21 @@ else
     <!-- Footer: input — pinned at bottom, never scrolls -->
     <div class="thread-chat-footer">
         <div class="thread-chat-input-area">
+        @if (showSubmissionProgress)
+        {
+            <!-- During thread creation (compact/embedded flow on User Activity etc.) we hide
+                 the editor entirely and show a prominent "Allocating agent..." panel with a
+                 spinner. When OnThreadCreated fires the page navigates to the new thread. -->
+            <div class="thread-allocating-panel">
+                <FluentProgressRing Style="width: 28px; height: 28px;" />
+                <div class="thread-allocating-text">
+                    <div class="thread-allocating-title">Allocating agent…</div>
+                    <div class="thread-allocating-subtitle">Creating conversation and redirecting</div>
+                </div>
+            </div>
+        }
+        else
+        {
         <!-- Attachment chip collection -->
         <ReferenceChipCollection
             Attachments="@attachments"
@@ -170,33 +192,27 @@ else
                 </FluentButton>
             }
         </div>
+        }
     </div>
     </div>
 }
 
-@if (showSubmissionProgress)
-{
-    <div class="thread-submission-overlay">
-        <div class="thread-submission-dialog">
-            <span class="thread-exec-star" style="font-size: 1.5rem;">&#10041;</span>
-            <span>Creating conversation...</span>
-        </div>
-    </div>
-}
 </div>
 
 <style>
-    .thread-submission-overlay {
-        position: absolute; inset: 0; z-index: 100;
-        display: flex; align-items: center; justify-content: center;
-        background: rgba(0,0,0,0.15); backdrop-filter: blur(2px);
-        border-radius: inherit;
+    .thread-allocating-panel {
+        display: flex; align-items: center; gap: 14px;
+        padding: 18px 22px; border-radius: 12px;
+        background: var(--neutral-layer-2);
+        border: 1px solid var(--neutral-stroke-rest);
+    }
+    .thread-allocating-text { display: flex; flex-direction: column; gap: 2px; }
+    .thread-allocating-title {
+        font-weight: 600; font-size: 0.95rem;
+        color: var(--accent-fill-rest);
     }
-    .thread-submission-dialog {
-        display: flex; align-items: center; gap: 12px;
-        padding: 16px 28px; border-radius: 12px;
-        background: var(--neutral-layer-1); box-shadow: 0 8px 32px rgba(0,0,0,0.2);
-        font-size: 0.95rem; font-weight: 500;
+    .thread-allocating-subtitle {
+        font-size: 0.8rem; color: var(--neutral-foreground-hint);
     }
     @@keyframes thread-pending-pulse {
         0%, 100% { opacity: 0.6; }
diff --git a/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor.cs b/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor.cs
index 3359e94e1..250595e3c 100644
--- a/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor.cs
+++ b/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor.cs
@@ -960,6 +960,22 @@ private static CompletionItem AutocompleteToCompletion(
             .WithSpinnerType(SpinnerType.Skeleton);
     }
 
+    /// <summary>
+    /// Creates a LayoutAreaControl pointing to the thread's Header layout area
+    /// (parent-thread back-link + aggregated UpdatedNodes summary). Null when the
+    /// thread doesn't exist yet. Uses <see cref="SpinnerType.None"/> — the header
+    /// is ancillary; showing a skeleton for it looks like a phantom message cell.
+    /// </summary>
+    private LayoutAreaControl? GetHeaderCell()
+    {
+        if (string.IsNullOrEmpty(threadPath))
+            return null;
+        return new LayoutAreaControl(
+            threadPath,
+            new LayoutAreaReference(ThreadNodeType.HeaderArea))
+            .WithSpinnerType(SpinnerType.None);
+    }
+
     private static string TruncateText(string text, int maxLength)
     {
         if (string.IsNullOrEmpty(text) || text.Length <= maxLength)
diff --git a/src/MeshWeaver.Blazor.Portal/Pages/CreateNode.razor b/src/MeshWeaver.Blazor.Portal/Pages/CreateNode.razor
index 353b95eff..4db47ce16 100644
--- a/src/MeshWeaver.Blazor.Portal/Pages/CreateNode.razor
+++ b/src/MeshWeaver.Blazor.Portal/Pages/CreateNode.razor
@@ -338,11 +338,11 @@
         if (string.IsNullOrWhiteSpace(name))
             return "";
 
-        var words = Regex.Split(name.Trim(), @"[\s_]+")
+        var words = Regex.Split(name.Trim(), @"[\s\-_]+")
             .Where(w => !string.IsNullOrEmpty(w))
-            .Select(w => Regex.Replace(w, @"[^a-zA-Z0-9\-]", "").ToLowerInvariant())
-            .Where(w => !string.IsNullOrEmpty(w));
+            .Select(w => char.ToUpperInvariant(w[0]) + w.Substring(1));
 
-        return string.Join("-", words);
+        var pascalCase = string.Join("", words);
+        return Regex.Replace(pascalCase, @"[^a-zA-Z0-9]", "");
     }
 }
diff --git a/src/MeshWeaver.Blazor/BlazorView.razor.cs b/src/MeshWeaver.Blazor/BlazorView.razor.cs
index d41f53d44..fa113ac92 100644
--- a/src/MeshWeaver.Blazor/BlazorView.razor.cs
+++ b/src/MeshWeaver.Blazor/BlazorView.razor.cs
@@ -61,8 +61,18 @@ protected virtual void BindDataAfterParameterReset()
 
     protected List<IDisposable> Disposables { get; } = new();
 
+    private bool _viewDisposed;
+
+    /// <summary>True after <see cref="DisposeAsync"/> has been entered. Subscription callbacks
+    /// can check this to avoid invoking <see cref="StateHasChanged"/> on a dead renderer.</summary>
+    protected bool IsViewDisposed => _viewDisposed;
+
     public virtual ValueTask DisposeAsync()
     {
+        // Set the flag BEFORE disposing subscriptions so any in-flight callbacks
+        // queued by Subscribe(...) onto the synchronization context can short-circuit
+        // on IsViewDisposed instead of touching a torn-down renderer.
+        _viewDisposed = true;
         Logger.LogDebug("Disposing area {Area}", Area);
         DisposeBindings();
         foreach (var d in Disposables)
@@ -108,18 +118,32 @@ protected void DataBind<T>(
                         bindings.Add(Stream.DataBind(reference, DataContext, conversion, defaultValue)
                             .Subscribe(v =>
                                 {
+                                    if (_viewDisposed) return;
                                     try
                                     {
                                         Logger.LogTrace("Binding property in Area {area}", Area);
                                         InvokeAsync(() =>
                                         {
-                                            setter(v);
-                                            RequestStateChange();
+                                            // Re-check after dispatch — the renderer may have
+                                            // been torn down between Subscribe.OnNext and the
+                                            // synchronization-context callback firing.
+                                            if (_viewDisposed) return;
+                                            try
+                                            {
+                                                setter(v);
+                                                RequestStateChange();
+                                            }
+                                            catch (ObjectDisposedException) { /* renderer gone */ }
+                                            catch (Exception ex)
+                                            {
+                                                Logger.LogError(ex, "Error setting bound property value in Area {area}", Area);
+                                            }
                                         });
                                     }
+                                    catch (ObjectDisposedException) { /* renderer gone */ }
                                     catch (Exception ex)
                                     {
-                                        Logger.LogError(ex, "Error setting bound property value in Area {area}", Area);
+                                        Logger.LogError(ex, "Error scheduling bound property update in Area {area}", Area);
                                     }
                                 }
                             )
diff --git a/src/MeshWeaver.Blazor/Components/ChatSubmissionHandler.cs b/src/MeshWeaver.Blazor/Components/ChatSubmissionHandler.cs
index 82c6c1608..80a0b653d 100644
--- a/src/MeshWeaver.Blazor/Components/ChatSubmissionHandler.cs
+++ b/src/MeshWeaver.Blazor/Components/ChatSubmissionHandler.cs
@@ -16,9 +16,12 @@ public enum SubmissionState
     }
 
     private readonly TimeSpan _timeout;
+    private readonly TimeSpan _dedupWindow;
+    private readonly Func<DateTime> _now;
     private readonly Func<TimeSpan, Action, IDisposable> _scheduleTimeout;
     private IDisposable? _timeoutDisposable;
     private bool _disposed;
+    private DateTime? _lastAcceptedAt;
 
     /// <summary>
     /// Current state of the submission handler.
@@ -47,10 +50,14 @@ public enum SubmissionState
     /// <param name="scheduleTimeout">Optional scheduler for testing. If null, uses Task.Delay.</param>
     public ChatSubmissionHandler(
         TimeSpan? timeout = null,
-        Func<TimeSpan, Action, IDisposable>? scheduleTimeout = null)
+        Func<TimeSpan, Action, IDisposable>? scheduleTimeout = null,
+        TimeSpan? dedupWindow = null,
+        Func<DateTime>? now = null)
     {
         _timeout = timeout ?? TimeSpan.FromSeconds(30);
         _scheduleTimeout = scheduleTimeout ?? DefaultScheduleTimeout;
+        _dedupWindow = dedupWindow ?? TimeSpan.FromMilliseconds(500);
+        _now = now ?? (() => DateTime.UtcNow);
     }
 
     /// <summary>
@@ -70,8 +77,22 @@ public bool TryBeginSubmit(string? text)
         if (State != SubmissionState.Idle)
             return false;
 
+        // UX-only debounce: ThreadChatView force-releases immediately after Submit so the
+        // input stays enabled for queueing while the previous round is processed by the
+        // server. Without this guard, a double-click / Enter+Send race appends the same
+        // message twice (the server watcher batches them into one round, but the user
+        // sees two duplicate cells). The duplicate-EXECUTION race that this guard used
+        // to mask is now fixed in ThreadSubmissionServer (atomic single-write append +
+        // hardened reentrancy guard); this remains only as a UX safeguard against
+        // accidental double-clicks of the same exact text.
+        if (LastSubmittedText == text
+            && _lastAcceptedAt.HasValue
+            && (_now() - _lastAcceptedAt.Value) < _dedupWindow)
+            return false;
+
         State = SubmissionState.Submitting;
         LastSubmittedText = text;
+        _lastAcceptedAt = _now();
         SubmissionCount++;
 
         return true;
diff --git a/src/MeshWeaver.Blazor/Components/CollaborativeMarkdownView.razor.cs b/src/MeshWeaver.Blazor/Components/CollaborativeMarkdownView.razor.cs
index a438e50a4..831dfb96c 100644
--- a/src/MeshWeaver.Blazor/Components/CollaborativeMarkdownView.razor.cs
+++ b/src/MeshWeaver.Blazor/Components/CollaborativeMarkdownView.razor.cs
@@ -356,40 +356,27 @@ private void UpdateContentLocally(string newContent)
         StateHasChanged();
     }
 
-    // Post content update to hub and return success/failure
-    private async Task<bool> PostContentUpdateAsync(string newContent)
+    // Post content update by syncing the full MeshNode via the remote stream and
+    // editing its Content field directly — this preserves Name/Icon/Description/etc.
+    // Using a partial MeshNode + DataChangeRequest fails key-mapping validation on the
+    // hosting hub ("No key mapping is defined for type MeshNode").
+    private Task<bool> PostContentUpdateAsync(string newContent)
     {
-        if (string.IsNullOrEmpty(BoundHubAddress))
-            return false;
-
-        // Split path into Id + Namespace so the workspace matches the existing node by key (Id).
-        var path = BoundNodePath ?? "";
-        var lastSlash = path.LastIndexOf('/');
-        var (id, ns) = lastSlash > 0
-            ? (path[(lastSlash + 1)..], path[..lastSlash])
-            : (path, (string?)null);
-
-        var nodeUpdate = new MeshNode(id, ns)
-        {
-            NodeType = "Markdown",
-            Content = new MarkdownContent { Content = newContent }
-        };
+        if (string.IsNullOrEmpty(BoundHubAddress) || string.IsNullOrEmpty(BoundNodePath))
+            return Task.FromResult(false);
 
         try
         {
-            var response = await Hub.AwaitResponse(
-                new DataChangeRequest { ChangedBy = Stream?.ClientId }.WithUpdates(nodeUpdate),
-                o => o.WithTarget(new Address(BoundHubAddress)),
-                default);
-
-            if (response.Message is DataChangeResponse dcr && dcr.Status != DataChangeStatus.Committed)
-                return false;
-
-            return true;
+            var workspace = Hub.ServiceProvider.GetRequiredService<IWorkspace>();
+            workspace.UpdateMeshNode(
+                node => node with { Content = new MarkdownContent { Content = newContent } },
+                new Address(BoundHubAddress),
+                BoundNodePath);
+            return Task.FromResult(true);
         }
         catch
         {
-            return false;
+            return Task.FromResult(false);
         }
     }
 
diff --git a/src/MeshWeaver.Blazor/Components/MarkdownEditorView.razor b/src/MeshWeaver.Blazor/Components/MarkdownEditorView.razor
index d0f25fbb6..ad9d5ed27 100644
--- a/src/MeshWeaver.Blazor/Components/MarkdownEditorView.razor
+++ b/src/MeshWeaver.Blazor/Components/MarkdownEditorView.razor
@@ -407,7 +407,7 @@
         _ = AutoSaveContentAsync(content);
     }
 
-    private async Task<bool> AutoSaveContentAsync(string content)
+    private Task<bool> AutoSaveContentAsync(string content)
     {
         if (ValuePointer != null)
         {
@@ -415,35 +415,25 @@
         }
 
         if (string.IsNullOrEmpty(BoundAutoSaveAddress) || string.IsNullOrEmpty(BoundNodePath))
-            return true;
+            return Task.FromResult(true);
 
         try
         {
-            var nodeUpdate = new MeshWeaver.Mesh.MeshNode(BoundNodePath)
-            {
-                NodeType = "Markdown",
-                Content = new MarkdownContent { Content = content }
-            };
-
-            var response = await Hub.AwaitResponse(
-                new DataChangeRequest { ChangedBy = Stream?.ClientId }.WithUpdates(nodeUpdate),
-                o => o.WithTarget(new Address(BoundAutoSaveAddress)),
-                default);
-
-            if (response.Message is DataChangeResponse dcr && dcr.Status != DataChangeStatus.Committed)
-            {
-                Logger.LogWarning("Auto-save rejected for node {Path}: {Message}",
-                    BoundNodePath, dcr.Log.Messages.LastOrDefault()?.Message);
-                return false;
-            }
-
+            // Sync the full MeshNode via the remote stream and patch Content only —
+            // preserves Name/Icon/Description and avoids the key-mapping failure that
+            // DataChangeRequest + partial MeshNode triggers on the hosting hub.
+            var workspace = Hub.ServiceProvider.GetRequiredService<IWorkspace>();
+            workspace.UpdateMeshNode(
+                node => node with { Content = new MarkdownContent { Content = content } },
+                new Address(BoundAutoSaveAddress),
+                BoundNodePath);
             Logger.LogDebug("Auto-saved content to {Address} for node {Path}", BoundAutoSaveAddress, BoundNodePath);
-            return true;
+            return Task.FromResult(true);
         }
         catch (Exception ex)
         {
             Logger.LogWarning(ex, "Failed to auto-save content to {Address}", BoundAutoSaveAddress);
-            return false;
+            return Task.FromResult(false);
         }
     }
 
diff --git a/src/MeshWeaver.Blazor/Components/NamedAreaView.razor.cs b/src/MeshWeaver.Blazor/Components/NamedAreaView.razor.cs
index 9a589f951..c99ff794c 100644
--- a/src/MeshWeaver.Blazor/Components/NamedAreaView.razor.cs
+++ b/src/MeshWeaver.Blazor/Components/NamedAreaView.razor.cs
@@ -44,30 +44,57 @@ protected override void BindData()
             .Subscribe(
                 x =>
                 {
-                    InvokeAsync(() =>
+                    if (IsViewDisposed) return;
+                    try
                     {
-                        var control = x as UiControl;
-                        if (RootControl is null && control is null || RootControl != null && RootControl.Equals(control))
-                            return;
-                        RootControl = control;
-                        if (RootControl is not null)
+                        InvokeAsync(() =>
                         {
-                            DataBind(RootControl.PageTitle, y => y.PageTitle);
-                            DataBind(RootControl.Meta, y => y.MetaAttributes);
-                        }
-                        Logger.LogDebug("Setting area {Area} to rendering area {AreaToBeRendered} to type {Type}", Area,
-                            AreaToBeRendered, control?.GetType().Name ?? "null");
-                        RequestStateChange();
-                    });
+                            if (IsViewDisposed) return;
+                            try
+                            {
+                                var control = x as UiControl;
+                                if (RootControl is null && control is null || RootControl != null && RootControl.Equals(control))
+                                    return;
+                                RootControl = control;
+                                if (RootControl is not null)
+                                {
+                                    DataBind(RootControl.PageTitle, y => y.PageTitle);
+                                    DataBind(RootControl.Meta, y => y.MetaAttributes);
+                                }
+                                Logger.LogDebug("Setting area {Area} to rendering area {AreaToBeRendered} to type {Type}", Area,
+                                    AreaToBeRendered, control?.GetType().Name ?? "null");
+                                RequestStateChange();
+                            }
+                            catch (ObjectDisposedException) { /* renderer gone */ }
+                        });
+                    }
+                    catch (ObjectDisposedException) { /* renderer gone */ }
                 },
                 error =>
                 {
+                    // ObjectDisposedException is a benign teardown artifact — the area stream's
+                    // upstream hub or workspace was disposed during navigation/component swap.
+                    // Don't surface it as a user-visible "Error loading area" markdown.
+                    if (IsViewDisposed || error is ObjectDisposedException)
+                    {
+                        Logger.LogDebug(error, "Suppressed teardown error in control stream for area {Area}", AreaToBeRendered);
+                        return;
+                    }
                     Logger.LogError(error, "Error in control stream for area {Area}", AreaToBeRendered);
-                    InvokeAsync(() =>
+                    try
                     {
-                        RootControl = new MarkdownControl($"**Error loading area:** {error.Message}");
-                        RequestStateChange();
-                    });
+                        InvokeAsync(() =>
+                        {
+                            if (IsViewDisposed) return;
+                            try
+                            {
+                                RootControl = new MarkdownControl($"**Error loading area:** {error.Message}");
+                                RequestStateChange();
+                            }
+                            catch (ObjectDisposedException) { /* renderer gone */ }
+                        });
+                    }
+                    catch (ObjectDisposedException) { /* renderer gone */ }
                 },
                 () =>
                 {
diff --git a/src/MeshWeaver.Blazor/Components/ThreadMessageBubbleView.razor b/src/MeshWeaver.Blazor/Components/ThreadMessageBubbleView.razor
index 756e59ca6..39f4cdefd 100644
--- a/src/MeshWeaver.Blazor/Components/ThreadMessageBubbleView.razor
+++ b/src/MeshWeaver.Blazor/Components/ThreadMessageBubbleView.razor
@@ -61,6 +61,8 @@
                 }
                 else
                 {
+                    var display = FormatToolCallDisplay(call);
+                    var change = display.IsNodeModifying ? FindChange(display.Path) : null;
                     @* Completed delegation or regular tool call: expandable details *@
                     <details class="thread-msg-tool-entry @(isDelegation ? "thread-msg-delegation-entry" : "")">
                         <summary class="thread-msg-tool-entry-name">
@@ -71,7 +73,27 @@
                             }
                             else
                             {
-                                <span>@summary</span>
+                                <span>@display.Verb</span>
+                                @if (!string.IsNullOrEmpty(display.Path))
+                                {
+                                    <text>&nbsp;</text>
+                                    <a href="/@display.Path" class="thread-msg-tool-path" @onclick:stopPropagation>@display.Path</a>
+                                }
+                                @if (change is not null)
+                                {
+                                    @if (change.VersionBefore.HasValue && change.VersionAfter.HasValue)
+                                    {
+                                        <a class="thread-msg-tool-action" title="Compare v@(change.VersionBefore) with v@(change.VersionAfter)"
+                                           href="/@display.Path/VersionDiff?from=@(change.VersionBefore)&to=@(change.VersionAfter)"
+                                           @onclick:stopPropagation>Diff</a>
+                                    }
+                                    @if (change.VersionBefore.HasValue)
+                                    {
+                                        <a class="thread-msg-tool-action thread-msg-tool-action-muted" title="Revert to v@(change.VersionBefore)"
+                                           href="/@display.Path/VersionDiff?version=@(change.VersionBefore)"
+                                           @onclick:stopPropagation>Revert v@(change.VersionBefore)</a>
+                                    }
+                                }
                             }
                         </summary>
                         @if (!string.IsNullOrEmpty(call.Arguments))
@@ -237,6 +259,36 @@
     .thread-msg-tool-entry-name:hover {
         color: var(--neutral-foreground-rest);
     }
+    .thread-msg-tool-path {
+        color: var(--accent-fill-rest);
+        text-decoration: none;
+        font-family: var(--monospace-font, monospace);
+        font-size: 0.72rem;
+        padding: 1px 4px;
+        border-radius: 3px;
+    }
+    .thread-msg-tool-path:hover {
+        background: var(--neutral-layer-3);
+        text-decoration: underline;
+    }
+    .thread-msg-tool-action {
+        display: inline-flex;
+        align-items: center;
+        margin-left: 6px;
+        padding: 1px 6px;
+        font-size: 0.7rem;
+        border-radius: 3px;
+        color: var(--accent-fill-rest);
+        text-decoration: none;
+        border: 1px solid transparent;
+    }
+    .thread-msg-tool-action:hover {
+        background: var(--neutral-layer-3);
+        border-color: var(--neutral-stroke-rest);
+    }
+    .thread-msg-tool-action-muted {
+        color: var(--neutral-foreground-hint);
+    }
     .thread-msg-tool-pending {
         color: var(--accent-fill-rest);
         animation: thread-dots-blink 1.4s infinite both;
diff --git a/src/MeshWeaver.Blazor/Components/ThreadMessageBubbleView.razor.cs b/src/MeshWeaver.Blazor/Components/ThreadMessageBubbleView.razor.cs
index d8beff703..0d039488c 100644
--- a/src/MeshWeaver.Blazor/Components/ThreadMessageBubbleView.razor.cs
+++ b/src/MeshWeaver.Blazor/Components/ThreadMessageBubbleView.razor.cs
@@ -13,10 +13,18 @@ public partial class ThreadMessageBubbleView : BlazorView<ThreadMessageBubbleCon
 
     private string? messageText;
     private IReadOnlyList<ToolCallEntry>? toolCalls;
+    private IReadOnlyList<NodeChangeEntry>? updatedNodes;
     private bool isEditing;
 
     private bool HasToolCalls => toolCalls is { Count: > 0 };
 
+    /// <summary>
+    /// Shape returned by <see cref="FormatToolCallDisplay"/>: tells the view how
+    /// to render the chip — verb text, target path (when the tool modifies a node),
+    /// and whether the path should be decorated with Diff + Restore links.
+    /// </summary>
+    public readonly record struct ToolCallDisplay(string Verb, string? Path, bool IsNodeModifying);
+
     private MarkdownControl MarkdownVm => new MarkdownControl(messageText ?? "")
         .WithStyle("background: transparent;");
 
@@ -46,32 +54,99 @@ protected override void BindData()
             if (result != null && prev != null && result.SequenceEqual(prev)) return prev;
             return result;
         });
+        DataBind(ViewModel.UpdatedNodes, x => x.updatedNodes, (val, prev) =>
+        {
+            IReadOnlyList<NodeChangeEntry>? result = val switch
+            {
+                null => null,
+                IReadOnlyList<NodeChangeEntry> list => list,
+                JsonElement je => je.Deserialize<List<NodeChangeEntry>>(Hub.JsonSerializerOptions),
+                _ => null
+            };
+            if (result == null && prev == null) return prev;
+            if (result != null && prev != null && result.SequenceEqual(prev)) return prev;
+            return result;
+        });
+    }
+
+    /// <summary>
+    /// Matches a tool-call target path against the message's aggregated
+    /// <c>UpdatedNodes</c> so the chip can render Diff / Restore links with the
+    /// correct before/after versions.
+    /// </summary>
+    private NodeChangeEntry? FindChange(string? path)
+    {
+        if (string.IsNullOrEmpty(path) || updatedNodes is null)
+            return null;
+        return updatedNodes.FirstOrDefault(n =>
+            string.Equals(n.Path, path, StringComparison.Ordinal));
     }
 
     private static string FormatToolCallSummary(ToolCallEntry call)
+    {
+        var d = FormatToolCallDisplay(call);
+        return d.Path is null ? d.Verb : $"{d.Verb} {d.Path}";
+    }
+
+    /// <summary>
+    /// Splits the tool call into a verb + target-path + flag. Node-modifying verbs
+    /// (Create / Update / Patch / Delete) flow through with <c>IsNodeModifying=true</c>
+    /// so the view can render inline Diff + Restore links next to the path.
+    /// </summary>
+    private static ToolCallDisplay FormatToolCallDisplay(ToolCallEntry call)
     {
         if (!string.IsNullOrEmpty(call.DelegationPath))
         {
-            // Delegation: extract agent name from DisplayName (e.g., "Delegating to Coder..." → "Coder")
             var name = call.DisplayName ?? call.Name;
             if (name.Contains("Delegating to "))
                 name = name.Replace("Delegating to ", "").TrimEnd('.', ' ');
-            return name;
+            return new ToolCallDisplay(name, null, false);
         }
 
-        // Regular tool calls: friendly verb
-        var target = call.Arguments?.Split('\n').FirstOrDefault()?.Trim() ?? "";
+        // Args come serialized as "path: Org/X\ncontent: ...". Strip the "path: " prefix.
+        var rawArgs = call.Arguments ?? "";
+        string? path = null;
+        foreach (var line in rawArgs.Split('\n'))
+        {
+            var trimmed = line.Trim();
+            if (trimmed.StartsWith("path:", StringComparison.OrdinalIgnoreCase))
+            {
+                path = trimmed["path:".Length..].Trim();
+                break;
+            }
+            if (trimmed.StartsWith("url:", StringComparison.OrdinalIgnoreCase))
+            {
+                path = trimmed["url:".Length..].Trim();
+                break;
+            }
+            if (trimmed.StartsWith("query:", StringComparison.OrdinalIgnoreCase))
+            {
+                path = trimmed["query:".Length..].Trim();
+                break;
+            }
+        }
+        // Fallback to the first arg line if we couldn't identify the key.
+        if (string.IsNullOrEmpty(path))
+            path = rawArgs.Split('\n').FirstOrDefault()?.Trim();
+
+        // Agents write references as "@/Foo/Bar" — strip the "@" so href="/{path}"
+        // renders as "/Foo/Bar" and not "/@/Foo/Bar".
+        if (!string.IsNullOrEmpty(path) && path.StartsWith('@'))
+            path = path[1..].TrimStart('/');
+
         return call.Name switch
         {
-            "Get" or "get_node" => $"Getting {target}",
-            "Search" or "search_nodes" => $"Searching {target}",
-            "Create" or "create_node" => $"Creating {target}",
-            "Update" or "update_node" => $"Updating {target}",
-            "Patch" or "patch_node" => $"Patching {target}",
-            "Delete" or "delete_node" => $"Deleting {target}",
-            "NavigateTo" or "navigate_to" => $"Navigating to {target}",
-            "store_plan" => "Storing plan",
-            _ => call.DisplayName ?? call.Name
+            "Get" or "get_node" => new ToolCallDisplay("Reading", path, false),
+            "Search" or "search_nodes" => new ToolCallDisplay("Searching", path, false),
+            "Create" or "create_node" => new ToolCallDisplay("Created", path, true),
+            "Update" or "update_node" => new ToolCallDisplay("Updated", path, true),
+            "Patch" or "patch_node" => new ToolCallDisplay("Patched", path, true),
+            "Delete" or "delete_node" => new ToolCallDisplay("Deleted", path, true),
+            "NavigateTo" or "navigate_to" => new ToolCallDisplay("Navigating to", path, false),
+            "SearchWeb" => new ToolCallDisplay("Searching web for", path, false),
+            "FetchWebPage" => new ToolCallDisplay("Fetching", path, false),
+            "store_plan" => new ToolCallDisplay("Stored plan", null, false),
+            _ => new ToolCallDisplay(call.DisplayName ?? call.Name, path, false)
         };
     }
 }
diff --git a/src/MeshWeaver.Blazor/Infrastructure/UserContextMiddleware.cs b/src/MeshWeaver.Blazor/Infrastructure/UserContextMiddleware.cs
index fd4d31cc7..1b29270c5 100644
--- a/src/MeshWeaver.Blazor/Infrastructure/UserContextMiddleware.cs
+++ b/src/MeshWeaver.Blazor/Infrastructure/UserContextMiddleware.cs
@@ -80,7 +80,10 @@ public async Task InvokeAsync(HttpContext context)
 
         return new AccessContext
         {
-            ObjectId = response.UserName ?? response.UserEmail!,
+            // ObjectId must be the mesh User.Id (e.g. "rbuergi"), not the display name.
+            // RLS compares context.Node.Path against `User/{ObjectId}` for self-scope access —
+            // using UserName ("Roland Buergi") here would mismatch the `User/rbuergi/...` path.
+            ObjectId = response.UserId ?? response.UserEmail!,
             Name = response.UserName ?? "",
             Email = response.UserEmail!,
             IsApiToken = true,
diff --git a/src/MeshWeaver.Blazor/Pages/ApplicationPage.razor b/src/MeshWeaver.Blazor/Pages/ApplicationPage.razor
index 51400e628..49e3fc997 100644
--- a/src/MeshWeaver.Blazor/Pages/ApplicationPage.razor
+++ b/src/MeshWeaver.Blazor/Pages/ApplicationPage.razor
@@ -16,10 +16,27 @@
     }
     else if (!IsInteractive || IsLoading)
     {
-        @* Pre-render (no cached HTML) or interactive still resolving *@
+        @* Pre-render (no cached HTML) or interactive still resolving.
+           While navigation is blocked, peek at NodeTypeService to show a richer
+           progress message: "Looking up" → "Compiling <path> (<N>s)" so the user
+           sees what the hub is actually busy with. *@
         <div class="resolving-container">
             <FluentProgressRing style="width: 40px; height: 40px;" />
-            <p>Looking up <strong>@Path</strong>...</p>
+            @if (CompilingPath is not null)
+            {
+                <p>
+                    Compiling <strong>@CompilingPath</strong>
+                    @if (CompilingSeconds > 0)
+                    {
+                        <text> (@CompilingSeconds s)</text>
+                    }
+                    ...
+                </p>
+            }
+            else
+            {
+                <p>Looking up <strong>@Path</strong>...</p>
+            }
         </div>
     }
     else if (NavigationService.Context is null)
diff --git a/src/MeshWeaver.Blazor/Pages/ApplicationPage.razor.cs b/src/MeshWeaver.Blazor/Pages/ApplicationPage.razor.cs
index 6b944d127..c27ebd3c3 100644
--- a/src/MeshWeaver.Blazor/Pages/ApplicationPage.razor.cs
+++ b/src/MeshWeaver.Blazor/Pages/ApplicationPage.razor.cs
@@ -5,6 +5,7 @@
 using MeshWeaver.Mesh.Services;
 using MeshWeaver.Messaging;
 using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.FluentUI.AspNetCore.Components;
 
 namespace MeshWeaver.Blazor.Pages;
@@ -26,6 +27,25 @@ public partial class ApplicationPage : ComponentBase, IDisposable
     [Inject]
     private IMeshService MeshService { get; set; } = null!;
 
+    // Resolved lazily from the service provider so the page still renders when
+    // INodeTypeService isn't registered. A hard [Inject] would throw during
+    // component construction and leave the user with a black screen.
+    [Inject]
+    private IServiceProvider Services { get; set; } = null!;
+    private INodeTypeService? NodeTypeService => Services.GetService<INodeTypeService>();
+
+    /// <summary>
+    /// Path of any NodeType currently compiling. Used by the razor template to flip
+    /// the "Looking up …" placeholder into "Compiling &lt;path&gt; (Ns)…" during the
+    /// navigation blocking phase, so the user sees activity instead of a blank spinner.
+    /// </summary>
+    private string? CompilingPath { get; set; }
+
+    /// <summary>Elapsed seconds since the current compile started.</summary>
+    private int CompilingSeconds { get; set; }
+
+    private System.Threading.Timer? _compileProgressTimer;
+
     /// <summary>
     /// Catch-all path parameter - the entire URL path is matched against registered namespace patterns.
     /// </summary>
@@ -71,6 +91,35 @@ protected override void OnInitialized()
     {
         base.OnInitialized();
         NavigationService.OnNavigationContextChanged += OnNavigationContextChanged;
+
+        // Poll NodeTypeService.GetCompilingPaths while the page is in "Looking up"
+        // state so the user sees "Compiling <path> (Ns)…" rather than a blank spinner.
+        // Stopped once IsLoading flips to false. Two-second granularity is enough —
+        // most compiles are sub-second; the tick is for reassurance on slow ones.
+        _compileProgressTimer = new System.Threading.Timer(_ =>
+        {
+            try
+            {
+                if (!IsLoading) return;
+                var paths = NodeTypeService?.GetCompilingPaths();
+                var first = paths?.FirstOrDefault();
+                if (first != CompilingPath)
+                {
+                    CompilingPath = first;
+                    CompilingSeconds = 0;
+                }
+                else if (first != null)
+                {
+                    CompilingSeconds++;
+                }
+                _ = InvokeAsync(StateHasChanged);
+            }
+            catch
+            {
+                // Timer tick should never take down the page. The worst-case is a stale
+                // "Compiling…" message; that's better than a crashed circuit.
+            }
+        }, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
     }
 
     protected override async Task OnParametersSetAsync()
@@ -178,5 +227,6 @@ private void UpdateFromContext()
     public void Dispose()
     {
         NavigationService.OnNavigationContextChanged -= OnNavigationContextChanged;
+        _compileProgressTimer?.Dispose();
     }
 }
diff --git a/src/MeshWeaver.ContentCollections/ContentCollectionsExtensions.cs b/src/MeshWeaver.ContentCollections/ContentCollectionsExtensions.cs
index 21c93f4f2..50275ba8d 100644
--- a/src/MeshWeaver.ContentCollections/ContentCollectionsExtensions.cs
+++ b/src/MeshWeaver.ContentCollections/ContentCollectionsExtensions.cs
@@ -55,6 +55,9 @@ public static string GetLocalizedCollectionName(string collectionName, string ad
         /// </summary>
         public MessageHubConfiguration AddContentCollectionsInfrastructure()
         {
+            if (config.Get<bool>(nameof(AddContentCollectionsInfrastructure)))
+                return config;
+            config = config.Set(true, nameof(AddContentCollectionsInfrastructure));
             return config
                 .WithTypes(typeof(ContentCollectionReference))
                 .WithServices(AddContentService)
diff --git a/src/MeshWeaver.Data/Serialization/JsonSynchronizationStream.cs b/src/MeshWeaver.Data/Serialization/JsonSynchronizationStream.cs
index 77f3ff1b0..245532d38 100644
--- a/src/MeshWeaver.Data/Serialization/JsonSynchronizationStream.cs
+++ b/src/MeshWeaver.Data/Serialization/JsonSynchronizationStream.cs
@@ -11,6 +11,18 @@
 
 namespace MeshWeaver.Data.Serialization;
 
+/// <summary>
+/// Thrown by <c>ApplyAdd</c>/<c>ApplyReplace</c>/<c>ApplyRemove</c> when a patch's array
+/// index doesn't match the locally cached snapshot (drift between the owner's cached
+/// JSON view and the authoritative entity store). The upstream <c>ToDataChanged</c>
+/// catches this and falls back to emitting a <see cref="ChangeType.Full"/> snapshot
+/// so subscribers can resync.
+/// </summary>
+public sealed class StaleStreamStateException : InvalidOperationException
+{
+    public StaleStreamStateException(string message) : base(message) { }
+}
+
 public static class JsonSynchronizationStream
 {
     private static ILogger GetLogger(IServiceProvider serviceProvider)
@@ -149,16 +161,30 @@ internal static ISynchronizationStream CreateExternalClient<TReduced, TReference
 
         // Keep the remote owner grain alive while this subscription exists.
         // HeartBeatEvent is a no-op in monolith mode (no GrainKeepAliveCallback).
+        // Stop sending after the first DeliveryFailure so we don't spam warnings when
+        // the owner hub has no HeartBeatEvent handler (e.g. non-grain event hubs).
         if (!owner.Equals(hub.Address))
         {
-            reduced.RegisterForDisposal(
-                Observable.Interval(TimeSpan.FromSeconds(45))
-                    .Subscribe(_ =>
+            var cts = new CancellationTokenSource();
+            IDisposable? sub = null;
+            sub = Observable.Interval(TimeSpan.FromSeconds(45))
+                .Subscribe(_ =>
+                {
+                    if (hub.RunLevel > MessageHubRunLevel.Started) return;
+                    var delivery = hub.Post(new HeartBeatEvent(), o => o.WithTarget(owner));
+                    if (delivery == null) return;
+                    hub.RegisterCallback(delivery, (d, _) =>
                     {
-                        if (hub.RunLevel <= MessageHubRunLevel.Started)
-                            hub.Post(new HeartBeatEvent(), o => o.WithTarget(owner));
-                    })
-            );
+                        if (d.Message is DeliveryFailure)
+                        {
+                            sub?.Dispose();
+                            cts.Cancel();
+                        }
+                        return Task.FromResult(d);
+                    }, cts.Token);
+                });
+            reduced.RegisterForDisposal(sub);
+            reduced.RegisterForDisposal(new AnonymousDisposable(() => cts.Cancel()));
         }
 
         return reduced;
@@ -281,9 +307,33 @@ fromWorkspace as ISynchronizationStream<TReduced>
                     }
                     var patch = x.Updates.ToJsonPatch(stream.Host.JsonSerializerOptions, stream.Reference as WorkspaceReference);
                     var patchJson = JsonSerializer.Serialize(patch, stream.Host.JsonSerializerOptions);
-                    // Apply patch with correct RFC 6901 unescaping
-                    // The json-everything library doesn't properly unescape ~1 -> / in property names
-                    (currentJson, _) = ApplyPatchWithCorrectUnescaping(patchJson, currentJson.Value, stream.Host.JsonSerializerOptions);
+                    try
+                    {
+                        // Apply patch with correct RFC 6901 unescaping
+                        // The json-everything library doesn't properly unescape ~1 -> / in property names
+                        (currentJson, _) = ApplyPatchWithCorrectUnescaping(patchJson, currentJson.Value, stream.Host.JsonSerializerOptions);
+                    }
+                    catch (StaleStreamStateException stale)
+                    {
+                        // The cached JSON drifted from the authoritative entity store
+                        // (concurrent updates whose Updates were computed against an older
+                        // snapshot). Regenerate from the current value and emit a Full
+                        // so every subscriber resyncs cleanly.
+                        logger.LogWarning(stale,
+                            "Stale JSON snapshot for stream {StreamId}; regenerating Full from current value.",
+                            stream.ClientId);
+                        currentJson = JsonSerializer.SerializeToElement(
+                            x.Value, x.Value?.GetType() ?? typeof(object),
+                            stream.Host.JsonSerializerOptions);
+                        stream.Set(currentJson);
+                        return (TChange?)Activator.CreateInstance(
+                            typeof(TChange),
+                            stream.ClientId,
+                            x.Version,
+                            new RawJson(currentJson.Value.ToString() ?? string.Empty),
+                            ChangeType.Full,
+                            x.ChangedBy ?? string.Empty);
+                    }
                     stream.Set(currentJson);
                     return (TChange?)Activator.CreateInstance
                     (
@@ -452,7 +502,13 @@ private static void ApplyAdd(JsonNode root, string[] segments, JsonNode? value)
         else if (parent is JsonArray arr)
         {
             if (key == "-") arr.Add(value);
-            else if (int.TryParse(key, out var index)) arr.Insert(index, value);
+            else if (int.TryParse(key, out var index))
+            {
+                if (index < 0 || index > arr.Count)
+                    throw new StaleStreamStateException(
+                        $"Stale patch: add at index {index} but array has {arr.Count} elements.");
+                arr.Insert(index, value);
+            }
         }
     }
 
@@ -467,7 +523,12 @@ private static void ApplyReplace(JsonNode root, string[] segments, JsonNode? val
         if (parent is JsonObject obj)
             obj[key] = value;
         else if (parent is JsonArray arr && int.TryParse(key, out var index))
+        {
+            if (index < 0 || index >= arr.Count)
+                throw new StaleStreamStateException(
+                    $"Stale patch: replace at index {index} but array has {arr.Count} elements.");
             arr[index] = value;
+        }
     }
 
     private static void ApplyRemove(JsonNode root, string[] segments)
@@ -479,7 +540,12 @@ private static void ApplyRemove(JsonNode root, string[] segments)
         if (parent is JsonObject obj)
             obj.Remove(segments[^1]);
         else if (parent is JsonArray arr && int.TryParse(segments[^1], out var index))
+        {
+            if (index < 0 || index >= arr.Count)
+                throw new StaleStreamStateException(
+                    $"Stale patch: remove at index {index} but array has {arr.Count} elements.");
             arr.RemoveAt(index);
+        }
     }
 
     /// <summary>
diff --git a/src/MeshWeaver.Data/Serialization/SynchronizationStream.cs b/src/MeshWeaver.Data/Serialization/SynchronizationStream.cs
index 2f4a962f3..ee8703c4b 100644
--- a/src/MeshWeaver.Data/Serialization/SynchronizationStream.cs
+++ b/src/MeshWeaver.Data/Serialization/SynchronizationStream.cs
@@ -370,9 +370,9 @@ private void UpdateStream<TChange>(IMessageDelivery<TChange> delivery, IMessageH
         else
         {
             logger.LogDebug("[SYNC_STREAM] Processing Patch change for {StreamId}", StreamId);
-            (currentJson, var patch) = delivery.Message.UpdateJsonElement(currentJson, hub.JsonSerializerOptions);
             try
             {
+                (currentJson, var patch) = delivery.Message.UpdateJsonElement(currentJson, hub.JsonSerializerOptions);
                 var changeItem = this.ToChangeItem(Current!.Value!,
                     currentJson.Value,
                     patch,
@@ -390,6 +390,20 @@ private void UpdateStream<TChange>(IMessageDelivery<TChange> delivery, IMessageH
 
                 SetCurrent(hub, changeItem);
             }
+            catch (StaleStreamStateException stale)
+            {
+                // Local JSON cache drifted from the owner's view. Drop our cached snapshot
+                // and request a fresh Full from the owner via a new SubscribeRequest.
+                logger.LogWarning(stale,
+                    "[SYNC_STREAM] Stale patch for {StreamId}; requesting fresh snapshot from {Owner}.",
+                    StreamId, StreamIdentity.Owner);
+                Set<JsonElement?>(null);
+                if (Reference is WorkspaceReference wsRef)
+                {
+                    Host.Post(new SubscribeRequest(StreamId, wsRef) { Subscriber = Configuration.Subscriber! },
+                        o => o.WithTarget(StreamIdentity.Owner));
+                }
+            }
             catch (Exception ex)
             {
                 logger.LogError(ex, "[SYNC_STREAM] Failed to process Patch change for {StreamId}", StreamId);
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia.md b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia.md
new file mode 100644
index 000000000..f105f7070
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia.md
@@ -0,0 +1,205 @@
+---
+Name: Example — SocialMedia Model Node Type
+Category: DataMesh
+Description: End-to-end worked example of a custom model node type — data records, reference data, layout areas, NodeType JSON, and instances
+Icon: Code
+---
+
+# SocialMedia — A Model Node Type, End to End
+
+This is the **canonical reference example** for a custom model node type. When you
+(or the Coder agent) are asked to build "X as code" — a typed model with its own data
+and views — this is the shape to mirror.
+
+> See also [Creating Node Types](@@Doc/DataMesh/CreatingNodeTypes) for the step-by-step
+> theory, and [Business Rules](@@Doc/Architecture/BusinessRules) for a
+> calculation-heavy example with charts.
+
+## The Layout
+
+```
+Doc/DataMesh/SocialMedia/
+  Post.json                              # NodeType definition (nodeType: "NodeType")
+  Post/
+    _Source/                             # C# compiled at startup
+      Platform.cs                        # Reference-data record
+      SocialMediaPost.cs                 # Content record
+      SocialMediaPostLayoutAreas.cs      # List + Detail layout areas
+    Post-001.json                        # Instance (nodeType: "Doc/DataMesh/SocialMedia/Post")
+  Profile.json                           # Second NodeType
+  Profile/
+    _Source/
+      SocialMediaProfile.cs
+      SocialMediaProfileLayoutAreas.cs
+    Roland-LinkedIn.json                 # Instance
+```
+
+Every part of this folder has a specific job. The next sections walk them one at a time.
+
+## 1. Reference Data — `Platform.cs`
+
+Reference data is a small closed set of lookups (platforms, statuses, categories).
+It's a plain record with a `[Key]`, static instances, and an `All[]` array.
+
+```csharp
+// <meshweaver>
+// Id: Platform
+// DisplayName: Social Media Platform
+// </meshweaver>
+
+public record Platform
+{
+    [Key] public string Id { get; init; } = string.Empty;
+    [Required] public string Name { get; init; } = string.Empty;
+    public string Emoji { get; init; } = string.Empty;
+    public string Color { get; init; } = "#0a66c2";
+
+    public static readonly Platform LinkedIn  = new() { Id = "LinkedIn",  Name = "LinkedIn",    Emoji = "💼", Color = "#0a66c2" };
+    public static readonly Platform Twitter   = new() { Id = "Twitter",   Name = "X / Twitter", Emoji = "🐦", Color = "#000000" };
+    public static readonly Platform Instagram = new() { Id = "Instagram", Name = "Instagram",   Emoji = "📷", Color = "#e1306c" };
+
+    public static readonly Platform[] All = [LinkedIn, Twitter, Instagram];
+    public static Platform GetById(string? id) => All.FirstOrDefault(p => p.Id == id) ?? LinkedIn;
+}
+```
+
+## 2. Content Record — `SocialMediaPost.cs`
+
+The content record is the shape of a single instance's `content` payload. It uses
+domain attributes to describe the fields to the editor and to wire reference data.
+
+```csharp
+// <meshweaver>
+// Id: SocialMediaPost
+// DisplayName: Social Media Post
+// </meshweaver>
+
+using MeshWeaver.Domain;
+
+public record SocialMediaPost
+{
+    [Required]
+    [MeshNodeProperty(nameof(MeshNode.Name))]   // syncs MeshNode.Name with Title
+    public string Title { get; init; } = string.Empty;
+
+    [Markdown(EditorHeight = "200px")]
+    public string? Body { get; init; }
+
+    [Dimension<Platform>]                        // renders as a Platform picker
+    public string Platform { get; init; } = "LinkedIn";
+
+    [DisplayName("Scheduled at")]
+    public DateTimeOffset? ScheduledAt { get; init; }
+
+    public int Impressions { get; init; }
+    public int Likes { get; init; }
+}
+```
+
+Key attributes to memorise:
+- `[Required]` — validation
+- `[MeshNodeProperty(nameof(MeshNode.Name))]` — mirrors the property into `MeshNode.Name`
+- `[Dimension<T>]` — typed lookup against reference data
+- `[Markdown(...)]` — rich-text editor
+- `[DisplayName(...)]` — UI label
+
+## 3. Layout Areas — `SocialMediaPostLayoutAreas.cs`
+
+Layout areas are the **views** for instances of the type. They return
+`IObservable<UiControl?>` — never `Task<…>`, never `async`. Compose with Rx:
+
+```csharp
+public static IObservable<UiControl?> List(LayoutAreaHost host, RenderingContext _)
+{
+    var meshService = host.Hub.ServiceProvider.GetRequiredService<IMeshService>();
+    return meshService
+        .ObserveQuery<MeshNode>(MeshQueryRequest.FromQuery("namespace:Doc/DataMesh/SocialMedia/Post"))
+        .Scan(ImmutableDictionary<string, MeshNode>.Empty, ApplyChanges)
+        .Select(dict => (UiControl?)BuildList(dict.Values.ToImmutableList()));
+}
+```
+
+The companion extension method is how the layout area gets wired into the NodeType:
+
+```csharp
+public static LayoutDefinition AddSocialMediaPostLayoutAreas(this LayoutDefinition layout) =>
+    layout.WithView("List", List).WithView("Detail", Detail);
+```
+
+## 4. The NodeType JSON — `Post.json`
+
+The JSON is the binding glue. It registers the type, points at its content record,
+seeds reference data, and wires custom layout areas.
+
+```json
+{
+  "id": "Post",
+  "namespace": "Doc/DataMesh/SocialMedia",
+  "name": "Social Media Post",
+  "nodeType": "NodeType",
+  "content": {
+    "$type": "NodeTypeDefinition",
+    "configuration": "config => config
+      .WithContentType<SocialMediaPost>()
+      .AddData(data => data.AddSource(source => source
+        .WithType<Platform>(t => t.WithInitialData(Platform.All))))
+      .AddDefaultLayoutAreas()
+      .AddLayout(layout => layout
+        .AddSocialMediaPostLayoutAreas()
+        .WithDefaultArea(\"List\"))"
+  }
+}
+```
+
+Configuration-lambda cheat sheet:
+| Call | Purpose |
+|---|---|
+| `WithContentType<T>()` | The record type for new instances |
+| `AddData(data => data.AddSource(…))` | Seed in-memory data sources (reference data) |
+| `AddDefaultLayoutAreas()` | Overview, Edit, Threads, Files |
+| `AddLayout(layout => layout.AddXxxLayoutAreas())` | Custom views |
+| `WithDefaultArea("List")` | Which view opens by default |
+
+## 5. Instances — `Post/Post-001.json`
+
+An instance sets `nodeType` to the **namespace-qualified path** of the NodeType
+(`Doc/DataMesh/SocialMedia/Post`), and its `content` matches the record (`$type` =
+class name). Instance IDs should be **meaningful** — e.g. `Roland-LinkedIn`, `Post-001` —
+not generic like `SamplePost`.
+
+```json
+{
+  "id": "Post-001",
+  "namespace": "Doc/DataMesh/SocialMedia/Post",
+  "name": "Why we bet on the actor model",
+  "nodeType": "Doc/DataMesh/SocialMedia/Post",
+  "content": {
+    "$type": "SocialMediaPost",
+    "title": "Why we bet on the actor model",
+    "body": "Reactive systems live or die on isolation …",
+    "profilePath": "Doc/DataMesh/SocialMedia/Profile/Roland-LinkedIn",
+    "platform": "LinkedIn",
+    "scheduledAt": "2026-04-05T09:00:00+02:00",
+    "impressions": 4321,
+    "likes": 187
+  }
+}
+```
+
+## Live Profile Instance
+
+The embedded view below is the `Roland-LinkedIn` profile instance, rendered by its `Detail` layout area:
+
+@@Doc/DataMesh/SocialMedia/Profile/Roland-LinkedIn
+
+## Copy-This Checklist
+
+When asked to build a new model node type "as code":
+
+1. ☐ Create a namespace folder under your target location.
+2. ☐ Add one `.cs` per content record in `_Source/`, each with the `<meshweaver>` frontmatter.
+3. ☐ Add reference-data `.cs` files with `[Key]`, static instances, and `All[]`.
+4. ☐ Add a `XxxLayoutAreas.cs` with `List`/`Detail` views returning `IObservable<UiControl?>`.
+5. ☐ Write the `Type.json` with `nodeType: "NodeType"` and a configuration lambda.
+6. ☐ Write **at least one** instance JSON with `nodeType` set to the namespace-qualified path.
+7. ☐ **Do not** substitute a Markdown node for a typed view. Markdown is for documents.
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post.json b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post.json
new file mode 100644
index 000000000..7e49550c3
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post.json
@@ -0,0 +1,18 @@
+{
+  "id": "Post",
+  "namespace": "Doc/DataMesh/SocialMedia",
+  "name": "Social Media Post",
+  "nodeType": "NodeType",
+  "category": "Types",
+  "description": "A social media post (scheduled, published, with engagement stats)",
+  "icon": "<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><defs><linearGradient id='g' x1='0' y1='0' x2='1' y2='1'><stop offset='0%' stop-color='#0a66c2'/><stop offset='100%' stop-color='#004f8a'/></linearGradient></defs><rect width='24' height='24' rx='5' fill='url(#g)'/><path d='M6 7h12M6 11h12M6 15h8' stroke='#fff' stroke-width='1.6' stroke-linecap='round'/></svg>",
+  "isPersistent": true,
+  "content": {
+    "$type": "NodeTypeDefinition",
+    "id": "Post",
+    "namespace": "Doc/DataMesh/SocialMedia",
+    "displayName": "Social Media Post",
+    "description": "A social media post (scheduled, published, with engagement stats)",
+    "configuration": "config => config.WithContentType<SocialMediaPost>().AddData(data => data.AddSource(source => source.WithType<Platform>(t => t.WithInitialData(Platform.All)))).AddDefaultLayoutAreas().AddLayout(layout => layout.AddSocialMediaPostLayoutAreas().WithDefaultArea(\"List\"))"
+  }
+}
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/Post-001.json b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/Post-001.json
new file mode 100644
index 000000000..982879fcd
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/Post-001.json
@@ -0,0 +1,20 @@
+{
+  "id": "Post-001",
+  "namespace": "Doc/DataMesh/SocialMedia/Post",
+  "path": "Doc/DataMesh/SocialMedia/Post/Post-001",
+  "name": "Why we bet on the actor model",
+  "nodeType": "Doc/DataMesh/SocialMedia/Post",
+  "icon": "/static/NodeTypeIcons/document.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaPost",
+    "title": "Why we bet on the actor model",
+    "body": "Reactive systems live or die on isolation. After years of fighting threadpools, we leaned into the actor model with Orleans \u2014 and never looked back.\n\nWhat surprised us most? **The debugging story is dramatically better.**",
+    "profilePath": "Doc/DataMesh/SocialMedia/Profile/Roland-LinkedIn",
+    "platform": "LinkedIn",
+    "scheduledAt": "2026-04-05T09:00:00+02:00",
+    "publishedAt": "2026-04-05T09:01:42+02:00",
+    "impressions": 4321,
+    "likes": 187
+  }
+}
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/_Source/Platform.cs b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/_Source/Platform.cs
new file mode 100644
index 000000000..ae7655974
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/_Source/Platform.cs
@@ -0,0 +1,39 @@
+// <meshweaver>
+// Id: Platform
+// DisplayName: Social Media Platform
+// </meshweaver>
+
+public record Platform
+{
+    [Key]
+    public string Id { get; init; } = string.Empty;
+
+    [Required]
+    public string Name { get; init; } = string.Empty;
+
+    public string Emoji { get; init; } = string.Empty;
+
+    public string Color { get; init; } = "#0a66c2";
+
+    public int Order { get; init; }
+
+    public static readonly Platform LinkedIn = new()
+    {
+        Id = "LinkedIn", Name = "LinkedIn", Emoji = "\ud83d\udcbc", Color = "#0a66c2", Order = 0
+    };
+
+    public static readonly Platform Twitter = new()
+    {
+        Id = "Twitter", Name = "X / Twitter", Emoji = "\ud83d\udc26", Color = "#000000", Order = 1
+    };
+
+    public static readonly Platform Instagram = new()
+    {
+        Id = "Instagram", Name = "Instagram", Emoji = "\ud83d\udcf7", Color = "#e1306c", Order = 2
+    };
+
+    public static readonly Platform[] All = [LinkedIn, Twitter, Instagram];
+
+    public static Platform GetById(string? id) =>
+        All.FirstOrDefault(p => p.Id == id) ?? LinkedIn;
+}
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/_Source/SocialMediaPost.cs b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/_Source/SocialMediaPost.cs
new file mode 100644
index 000000000..a76319859
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/_Source/SocialMediaPost.cs
@@ -0,0 +1,35 @@
+// <meshweaver>
+// Id: SocialMediaPost
+// DisplayName: Social Media Post
+// </meshweaver>
+
+using MeshWeaver.Domain;
+
+public record SocialMediaPost
+{
+    [Required]
+    [MeshNodeProperty(nameof(MeshNode.Name))]
+    [UiControl(Style = "width: 100%;")]
+    public string Title { get; init; } = string.Empty;
+
+    [Markdown(EditorHeight = "200px")]
+    public string? Body { get; init; }
+
+    [Required]
+    [DisplayName("Profile path")]
+    public string ProfilePath { get; init; } = string.Empty;
+
+    [Dimension<Platform>]
+    [UiControl(Style = "width: 200px;")]
+    public string Platform { get; init; } = "LinkedIn";
+
+    [DisplayName("Scheduled at")]
+    public DateTimeOffset? ScheduledAt { get; init; }
+
+    [DisplayName("Published at")]
+    public DateTimeOffset? PublishedAt { get; init; }
+
+    public int Impressions { get; init; }
+
+    public int Likes { get; init; }
+}
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/_Source/SocialMediaPostLayoutAreas.cs b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/_Source/SocialMediaPostLayoutAreas.cs
new file mode 100644
index 000000000..4314887f5
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Post/_Source/SocialMediaPostLayoutAreas.cs
@@ -0,0 +1,184 @@
+// <meshweaver>
+// Id: SocialMediaPostLayoutAreas
+// DisplayName: Social Media Post Views
+// </meshweaver>
+
+using System.Collections.Immutable;
+using System.Text.Json;
+using System.Web;
+using MeshWeaver.Layout.Composition;
+using MeshWeaver.Mesh.Services;
+
+public static class SocialMediaPostLayoutAreas
+{
+    public const string ListArea = "List";
+    public const string DetailArea = "Detail";
+
+    public static LayoutDefinition AddSocialMediaPostLayoutAreas(this LayoutDefinition layout) =>
+        layout
+            .WithView(ListArea, List)
+            .WithView(DetailArea, Detail);
+
+    private static ImmutableDictionary<string, MeshNode> ApplyChanges(
+        ImmutableDictionary<string, MeshNode> current, QueryResultChange<MeshNode> change)
+    {
+        var result = change.ChangeType == QueryChangeType.Initial || change.ChangeType == QueryChangeType.Reset
+            ? ImmutableDictionary<string, MeshNode>.Empty.WithComparers(StringComparer.OrdinalIgnoreCase)
+            : current;
+        foreach (var item in change.Items)
+            result = change.ChangeType == QueryChangeType.Removed
+                ? result.Remove(item.Path)
+                : result.SetItem(item.Path, item);
+        return result;
+    }
+
+    private static string? GetProp(MeshNode node, string prop)
+    {
+        if (node.Content is not JsonElement json) return null;
+        if (json.TryGetProperty(prop, out var p) && p.ValueKind == JsonValueKind.String) return p.GetString();
+        var pascal = char.ToUpperInvariant(prop[0]) + prop.Substring(1);
+        return json.TryGetProperty(pascal, out var pp) && pp.ValueKind == JsonValueKind.String ? pp.GetString() : null;
+    }
+
+    private static int GetInt(MeshNode node, string prop)
+    {
+        if (node.Content is not JsonElement json) return 0;
+        if (!json.TryGetProperty(prop, out var p))
+        {
+            var pascal = char.ToUpperInvariant(prop[0]) + prop.Substring(1);
+            if (!json.TryGetProperty(pascal, out p)) return 0;
+        }
+        return p.ValueKind == JsonValueKind.Number && p.TryGetInt32(out var v) ? v : 0;
+    }
+
+    private static DateTimeOffset? GetDate(MeshNode node, string prop)
+    {
+        if (node.Content is not JsonElement json) return null;
+        if (!json.TryGetProperty(prop, out var p))
+        {
+            var pascal = char.ToUpperInvariant(prop[0]) + prop.Substring(1);
+            if (!json.TryGetProperty(pascal, out p)) return null;
+        }
+        return p.ValueKind == JsonValueKind.String && DateTimeOffset.TryParse(p.GetString(), out var dt) ? dt : null;
+    }
+
+    public static IObservable<UiControl?> List(LayoutAreaHost host, RenderingContext _)
+    {
+        var meshService = host.Hub.ServiceProvider.GetRequiredService<IMeshService>();
+        var postsStream = meshService
+            .ObserveQuery<MeshNode>(MeshQueryRequest.FromQuery("namespace:Doc/DataMesh/SocialMedia/Post"))
+            .Scan(ImmutableDictionary<string, MeshNode>.Empty.WithComparers(StringComparer.OrdinalIgnoreCase), ApplyChanges);
+
+        return postsStream.Select(dict => (UiControl?)BuildList(dict.Values.ToImmutableList()));
+    }
+
+    private static UiControl BuildList(ImmutableList<MeshNode> posts)
+    {
+        var ordered = posts
+            .OrderByDescending(p => GetDate(p, "scheduledAt") ?? DateTimeOffset.MinValue)
+            .ToImmutableList();
+
+        if (ordered.Count == 0)
+            return Controls.Stack
+                .WithStyle("padding: 16px;")
+                .WithView(Controls.Markdown("*No posts yet.*"));
+
+        var rows = string.Join("", ordered.Select(p =>
+        {
+            var title = p.Name ?? GetProp(p, "title") ?? "(untitled)";
+            var platformId = GetProp(p, "platform") ?? "LinkedIn";
+            var platform = Platform.GetById(platformId);
+            var scheduled = GetDate(p, "scheduledAt")?.ToString("yyyy-MM-dd HH:mm") ?? "\u2014";
+            var published = GetDate(p, "publishedAt") is { } d ? d.ToString("yyyy-MM-dd HH:mm") : "\u2014";
+            var likes = GetInt(p, "likes");
+            var impressions = GetInt(p, "impressions");
+            return $"""
+                <tr>
+                  <td style="padding:8px 12px;"><a href="/{HttpUtility.HtmlAttributeEncode(p.Path)}">{HttpUtility.HtmlEncode(title)}</a></td>
+                  <td style="padding:8px 12px;"><span style="background:{platform.Color};color:white;padding:2px 8px;border-radius:10px;font-size:12px;">{platform.Emoji} {HttpUtility.HtmlEncode(platform.Name)}</span></td>
+                  <td style="padding:8px 12px;color:#666;">{scheduled}</td>
+                  <td style="padding:8px 12px;color:#666;">{published}</td>
+                  <td style="padding:8px 12px;text-align:right;">{likes:N0}</td>
+                  <td style="padding:8px 12px;text-align:right;">{impressions:N0}</td>
+                </tr>
+                """;
+        }));
+
+        var table = $"""
+            <table style="border-collapse:collapse;width:100%;font-family:var(--body-font);">
+              <thead>
+                <tr style="text-align:left;border-bottom:2px solid #e5e5e5;">
+                  <th style="padding:8px 12px;">Title</th>
+                  <th style="padding:8px 12px;">Platform</th>
+                  <th style="padding:8px 12px;">Scheduled</th>
+                  <th style="padding:8px 12px;">Published</th>
+                  <th style="padding:8px 12px;text-align:right;">Likes</th>
+                  <th style="padding:8px 12px;text-align:right;">Impressions</th>
+                </tr>
+              </thead>
+              <tbody>{rows}</tbody>
+            </table>
+            """;
+
+        return Controls.Stack
+            .WithStyle("padding: 16px; gap: 12px;")
+            .WithView(Controls.Html($"<h2 style=\"margin:0;\">Posts</h2>"))
+            .WithView(Controls.Html(table));
+    }
+
+    public static IObservable<UiControl?> Detail(LayoutAreaHost host, RenderingContext _)
+    {
+        var hubPath = host.Hub.Address.ToString();
+
+        return host.Workspace.GetStream<MeshNode>()!
+            .Select(nodes => nodes?.FirstOrDefault(n => n.Path == hubPath))
+            .Select(node =>
+            {
+                if (node is null)
+                    return (UiControl?)Controls.Markdown("*Post not found.*");
+
+                var title = node.Name ?? GetProp(node, "title") ?? "(untitled)";
+                var body = GetProp(node, "body");
+                var platformId = GetProp(node, "platform") ?? "LinkedIn";
+                var platform = Platform.GetById(platformId);
+                var scheduled = GetDate(node, "scheduledAt");
+                var published = GetDate(node, "publishedAt");
+                var status = published.HasValue ? "Published"
+                    : (scheduled.HasValue && scheduled.Value > DateTimeOffset.Now ? "Scheduled" : "Draft");
+                var statusColor = published.HasValue ? "#2e7d32" : "#ed6c02";
+                var impressions = GetInt(node, "impressions");
+                var likes = GetInt(node, "likes");
+
+                var header = $$"""
+                    <div style="display:flex;align-items:center;gap:12px;flex-wrap:wrap;padding:8px 0;">
+                      <span style="background:{{platform.Color}};color:white;padding:4px 10px;border-radius:12px;font-size:12px;font-weight:600;">{{platform.Emoji}} {{HttpUtility.HtmlEncode(platform.Name)}}</span>
+                      <span style="background:{{statusColor}};color:white;padding:4px 10px;border-radius:12px;font-size:12px;font-weight:600;">{{status}}</span>
+                    </div>
+                    """;
+
+                var dates = $$"""
+                    <table style="border-collapse:collapse;margin:4px 0;font-size:14px;">
+                      <tr><td style="color:#666;padding:2px 12px 2px 0;">Scheduled</td><td>{{HttpUtility.HtmlEncode(scheduled?.ToString("yyyy-MM-dd HH:mm") ?? "\u2014")}}</td></tr>
+                      <tr><td style="color:#666;padding:2px 12px 2px 0;">Published</td><td>{{HttpUtility.HtmlEncode(published?.ToString("yyyy-MM-dd HH:mm") ?? "\u2014")}}</td></tr>
+                    </table>
+                    """;
+
+                var stats = $$"""
+                    <div style="display:flex;gap:24px;padding:12px;background:#f5f7fa;border-radius:6px;">
+                      <div><div style="font-size:11px;color:#666;text-transform:uppercase;">Likes</div><div style="font-size:20px;font-weight:600;">{{likes:N0}}</div></div>
+                      <div><div style="font-size:11px;color:#666;text-transform:uppercase;">Impressions</div><div style="font-size:20px;font-weight:600;">{{impressions:N0}}</div></div>
+                    </div>
+                    """;
+
+                var stack = Controls.Stack
+                    .WithStyle("padding: 16px; gap: 8px;")
+                    .WithView(Controls.Html($"<h1 style=\"margin:0;\">{HttpUtility.HtmlEncode(title)}</h1>"))
+                    .WithView(Controls.Html(header))
+                    .WithView(Controls.Html(dates))
+                    .WithView(Controls.Html(stats));
+                if (!string.IsNullOrWhiteSpace(body))
+                    stack = stack.WithView(Controls.Markdown(body));
+                return (UiControl?)stack;
+            });
+    }
+}
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile.json b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile.json
new file mode 100644
index 000000000..f2dc1861e
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile.json
@@ -0,0 +1,18 @@
+{
+  "id": "Profile",
+  "namespace": "Doc/DataMesh/SocialMedia",
+  "name": "Social Media Profile",
+  "nodeType": "NodeType",
+  "category": "Types",
+  "description": "A social media profile owned by a user (LinkedIn, X, Instagram, ...)",
+  "icon": "<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><defs><linearGradient id='g2' x1='0' y1='0' x2='1' y2='1'><stop offset='0%' stop-color='#e1306c'/><stop offset='100%' stop-color='#8a2a7c'/></linearGradient></defs><rect width='24' height='24' rx='5' fill='url(#g2)'/><circle cx='12' cy='9' r='3' fill='#fff'/><path d='M6 19c1.5-3.5 4-5 6-5s4.5 1.5 6 5' stroke='#fff' stroke-width='1.6' fill='none' stroke-linecap='round'/></svg>",
+  "isPersistent": true,
+  "content": {
+    "$type": "NodeTypeDefinition",
+    "id": "Profile",
+    "namespace": "Doc/DataMesh/SocialMedia",
+    "displayName": "Social Media Profile",
+    "description": "A social media profile owned by a user",
+    "configuration": "config => config.WithContentType<SocialMediaProfile>().AddData(data => data.AddSource(source => source.WithType<Platform>(t => t.WithInitialData(Platform.All)))).AddDefaultLayoutAreas().AddLayout(layout => layout.AddSocialMediaProfileLayoutAreas().WithDefaultArea(\"Detail\"))"
+  }
+}
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile/Roland-LinkedIn.json b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile/Roland-LinkedIn.json
new file mode 100644
index 000000000..77954dbce
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile/Roland-LinkedIn.json
@@ -0,0 +1,17 @@
+{
+  "id": "Roland-LinkedIn",
+  "namespace": "Doc/DataMesh/SocialMedia/Profile",
+  "path": "Doc/DataMesh/SocialMedia/Profile/Roland-LinkedIn",
+  "name": "Roland on LinkedIn",
+  "nodeType": "Doc/DataMesh/SocialMedia/Profile",
+  "icon": "/static/NodeTypeIcons/person.svg",
+  "isPersistent": true,
+  "content": {
+    "$type": "SocialMediaProfile",
+    "name": "Roland on LinkedIn",
+    "platform": "LinkedIn",
+    "owner": "rbuergi@systemorph.com",
+    "profileUrl": "https://www.linkedin.com/in/rolandbuergi/",
+    "bio": "Building MeshWeaver \u2014 collaborative actor-based runtime for data, AI and reactive UIs."
+  }
+}
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile/_Source/SocialMediaProfile.cs b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile/_Source/SocialMediaProfile.cs
new file mode 100644
index 000000000..e1307b51a
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile/_Source/SocialMediaProfile.cs
@@ -0,0 +1,28 @@
+// <meshweaver>
+// Id: SocialMediaProfile
+// DisplayName: Social Media Profile
+// </meshweaver>
+
+using MeshWeaver.Domain;
+
+public record SocialMediaProfile
+{
+    [Required]
+    [MeshNodeProperty(nameof(MeshNode.Name))]
+    public string Name { get; init; } = string.Empty;
+
+    [Required]
+    [Dimension<Platform>]
+    [UiControl(Style = "width: 200px;")]
+    public string Platform { get; init; } = "LinkedIn";
+
+    [Required]
+    [DisplayName("Owner email")]
+    public string Owner { get; init; } = string.Empty;
+
+    [DisplayName("Profile URL")]
+    public string? ProfileUrl { get; init; }
+
+    [Markdown(EditorHeight = "120px")]
+    public string? Bio { get; init; }
+}
diff --git a/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile/_Source/SocialMediaProfileLayoutAreas.cs b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile/_Source/SocialMediaProfileLayoutAreas.cs
new file mode 100644
index 000000000..e07a8e121
--- /dev/null
+++ b/src/MeshWeaver.Documentation/Data/DataMesh/SocialMedia/Profile/_Source/SocialMediaProfileLayoutAreas.cs
@@ -0,0 +1,67 @@
+// <meshweaver>
+// Id: SocialMediaProfileLayoutAreas
+// DisplayName: Social Media Profile Views
+// </meshweaver>
+
+using System.Text.Json;
+using System.Web;
+using MeshWeaver.Layout.Composition;
+
+public static class SocialMediaProfileLayoutAreas
+{
+    public const string DetailArea = "Detail";
+
+    public static LayoutDefinition AddSocialMediaProfileLayoutAreas(this LayoutDefinition layout) =>
+        layout.WithView(DetailArea, Detail);
+
+    private static string? GetProp(MeshNode node, string prop)
+    {
+        if (node.Content is not JsonElement json) return null;
+        if (json.TryGetProperty(prop, out var p) && p.ValueKind == JsonValueKind.String) return p.GetString();
+        var pascal = char.ToUpperInvariant(prop[0]) + prop.Substring(1);
+        return json.TryGetProperty(pascal, out var pp) && pp.ValueKind == JsonValueKind.String ? pp.GetString() : null;
+    }
+
+    public static IObservable<UiControl?> Detail(LayoutAreaHost host, RenderingContext _)
+    {
+        var hubPath = host.Hub.Address.ToString();
+
+        return host.Workspace.GetStream<MeshNode>()!
+            .Select(nodes => nodes?.FirstOrDefault(n => n.Path == hubPath))
+            .Select(node =>
+            {
+                if (node is null)
+                    return (UiControl?)Controls.Markdown("*Profile not found.*");
+
+                var name = node.Name ?? GetProp(node, "name") ?? "Profile";
+                var platformId = GetProp(node, "platform") ?? "LinkedIn";
+                var platform = Platform.GetById(platformId);
+                var owner = GetProp(node, "owner") ?? "";
+                var profileUrl = GetProp(node, "profileUrl");
+                var bio = GetProp(node, "bio");
+
+                var link = !string.IsNullOrEmpty(profileUrl)
+                    ? $"<a href=\"{HttpUtility.HtmlAttributeEncode(profileUrl)}\" target=\"_blank\" rel=\"noopener\">Open profile \u2197</a>"
+                    : "<span style=\"color:#888;\">No profile URL</span>";
+
+                var html = $$"""
+                    <div style="display:flex;gap:24px;align-items:center;padding:16px;">
+                      <div style="width:96px;height:96px;border-radius:50%;background:{{platform.Color}};color:white;display:flex;align-items:center;justify-content:center;font-size:36px;">{{platform.Emoji}}</div>
+                      <div>
+                        <h2 style="margin:0 0 4px 0;">{{HttpUtility.HtmlEncode(name)}}</h2>
+                        <div style="color:{{platform.Color}};font-weight:600;margin-bottom:4px;">{{platform.Emoji}} {{HttpUtility.HtmlEncode(platform.Name)}}</div>
+                        <div style="color:#666;margin-bottom:8px;">Owner: {{HttpUtility.HtmlEncode(owner)}}</div>
+                        <div>{{link}}</div>
+                      </div>
+                    </div>
+                    """;
+
+                var stack = Controls.Stack
+                    .WithStyle("padding: 16px;")
+                    .WithView(Controls.Html(html));
+                if (!string.IsNullOrWhiteSpace(bio))
+                    stack = stack.WithView(Controls.Markdown(bio));
+                return (UiControl?)stack;
+            });
+    }
+}
diff --git a/src/MeshWeaver.Graph/AccessControlLayoutArea.cs b/src/MeshWeaver.Graph/AccessControlLayoutArea.cs
index 4eb90ff18..c5112a4a2 100644
--- a/src/MeshWeaver.Graph/AccessControlLayoutArea.cs
+++ b/src/MeshWeaver.Graph/AccessControlLayoutArea.cs
@@ -1,3 +1,4 @@
+using System.Net;
 using System.Reactive.Linq;
 using MeshWeaver.Application.Styles;
 using MeshWeaver.Data;
@@ -11,6 +12,7 @@
 using MeshWeaver.Messaging;
 using MeshWeaver.ShortGuid;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace MeshWeaver.Graph;
 
@@ -40,76 +42,53 @@ public static class AccessControlLayoutArea
             );
         }
 
-        var meshQuery = host.Hub.ServiceProvider.GetService<IMeshService>();
-        var nodeStream = host.Workspace.GetStream<MeshNode>()?.Select(nodes => nodes ?? [])
-            ?? Observable.Return<MeshNode[]>([]);
-
-        return nodeStream
-            .SelectMany(async nodes =>
-            {
-                var node = nodes.FirstOrDefault(n => n.Namespace == hubPath || n.Path == hubPath);
-                var isAdmin = await CheckAdminPermission(host.Hub, hubPath);
-
-                // Restrict to the current partition — the first path segment — so the query
-                // never fans out across partitions. Ancestors above the partition root
-                // (i.e. global/admin assignments) are excluded here by design.
-                var partitionRoot = hubPath.Split('/', 2)[0];
-
-                // Load ancestor assignments within the current partition only.
-                var inherited = new List<(AccessAssignment Assignment, string SourcePath, MeshNode Node)>();
-                if (meshQuery != null && !string.IsNullOrEmpty(partitionRoot))
-                {
-                    try
-                    {
-                        var ancestorAssignments = await meshQuery
-                            .QueryAsync<MeshNode>(
-                                $"namespace:{partitionRoot} path:{hubPath} nodeType:AccessAssignment scope:ancestors")
-                            .ToListAsync();
-
-                        foreach (var assignmentNode in ancestorAssignments)
-                        {
-                            var assignment = DeserializeAssignment(assignmentNode);
-                            if (assignment != null)
-                                inherited.Add((assignment, assignmentNode.Namespace ?? "", assignmentNode));
-                        }
-                    }
-                    catch
-                    {
-                        // Query may fail if index not ready
-                    }
-                }
-
-                // Pre-fetch user nodes for icons. Each user path is targeted (exact path) —
-                // no scope or fan-out. The query router uses the first segment to pick a
-                // partition (User, Group, etc.) so this stays O(1) per subject.
-                var userNodeLookup = new Dictionary<string, MeshNode>();
-                if (meshQuery != null)
-                {
-                    var userPaths = inherited.Select(x => x.Assignment.AccessObject).Distinct();
-                    foreach (var userPath in userPaths)
-                    {
-                        if (string.IsNullOrEmpty(userPath)) continue;
-                        try
-                        {
-                            var userNode = await meshQuery.QueryAsync<MeshNode>(
-                                $"path:{userPath}").FirstOrDefaultAsync();
-                            if (userNode != null)
-                                userNodeLookup[userPath] = userNode;
-                        }
-                        catch { }
-                    }
-                }
+        // Admin check — synchronous read from the current access context. No awaits,
+        // no Query, no FromAsync. Roles are set at circuit/request time.
+        var accessService = host.Hub.ServiceProvider.GetService<AccessService>();
+        var roles = accessService?.Context?.Roles
+            ?? accessService?.CircuitContext?.Roles
+            ?? [];
+        var isAdmin = roles.Any(r =>
+            string.Equals(r, "Admin", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(r, "PlatformAdmin", StringComparison.OrdinalIgnoreCase));
+
+        // Try to get the hub's own MeshNode stream. If the reducer isn't registered
+        // (test or minimal hub configurations), fall through to a stream-less render
+        // so the page is never blocked on stream initialization.
+        IObservable<ChangeItem<MeshNode>>? nodeStream = null;
+        try
+        {
+            nodeStream = host.Workspace.GetStream(new MeshNodeReference());
+        }
+        catch (Exception)
+        {
+            // MeshNodeReference reducer not available on this hub — render without node.
+        }
 
-                // Load partition access policy for this namespace
-                PartitionAccessPolicy? activePolicy = null;
-                if (securityService != null)
-                {
-                    try { activePolicy = await securityService.GetPolicyAsync(hubPath); }
-                    catch { }
-                }
+        if (nodeStream is null)
+        {
+            return Observable.Return<UiControl?>(BuildAccessControlPage(
+                host, node: null, hubPath, isAdmin,
+                inherited: [],
+                userNodeLookup: new Dictionary<string, MeshNode>(),
+                securityService,
+                activePolicy: null));
+        }
 
-                return BuildAccessControlPage(host, node, hubPath, isAdmin, inherited, userNodeLookup, securityService, activePolicy);
-            });
+        return nodeStream
+            .Select(change => (UiControl?)BuildAccessControlPage(
+                host, change?.Value, hubPath, isAdmin,
+                inherited: [],
+                userNodeLookup: new Dictionary<string, MeshNode>(),
+                securityService,
+                activePolicy: null))
+            .Catch<UiControl?, Exception>(_ => Observable.Return<UiControl?>(
+                BuildAccessControlPage(
+                    host, node: null, hubPath, isAdmin,
+                    inherited: [],
+                    userNodeLookup: new Dictionary<string, MeshNode>(),
+                    securityService,
+                    activePolicy: null)));
     }
 
     internal static AccessAssignment? DeserializeAssignment(MeshNode node)
diff --git a/src/MeshWeaver.Graph/Configuration/MeshNodeCompilationService.cs b/src/MeshWeaver.Graph/Configuration/MeshNodeCompilationService.cs
index 01b7cc3ce..863f5ed5c 100644
--- a/src/MeshWeaver.Graph/Configuration/MeshNodeCompilationService.cs
+++ b/src/MeshWeaver.Graph/Configuration/MeshNodeCompilationService.cs
@@ -28,6 +28,71 @@ internal class MeshNodeCompilationService(
     private readonly CompilationCacheOptions _cacheOptions = cacheOptions.Value ?? new CompilationCacheOptions();
     private JsonSerializerOptions JsonOptions => hub.JsonSerializerOptions;
     private readonly DynamicMeshNodeAttributeGenerator _attributeGenerator = new();
+
+    /// <summary>
+    /// Resolve one Sources entry into one-or-more concrete queries, ready to hand
+    /// to <see cref="IMeshService.QueryAsync{T}"/>. Rules:
+    /// <list type="bullet">
+    ///   <item><c>$self</c> expands to <paramref name="selfPath"/>.</item>
+    ///   <item>A leading <c>@@</c> or <c>@</c> marks a shorthand that yields both a
+    ///     <c>path:X</c> exact match and a <c>namespace:X scope:subtree</c> folder
+    ///     match (de-duplicated downstream by the caller).</item>
+    ///   <item>A <c>namespace:X</c> value that is a single relative segment (no
+    ///     <c>/</c>, no absolute root) is rebased onto <paramref name="selfPath"/>,
+    ///     so the default <c>namespace:_Source</c> reads as "my own _Source folder".</item>
+    ///   <item>Every emitted query is ANDed with <c>nodeType:Code</c> so non-code
+    ///     children can never leak into the compilation.</item>
+    /// </list>
+    /// </summary>
+    private static IEnumerable<string> ExpandSourceQuery(string rawQuery, string selfPath)
+    {
+        var expanded = rawQuery.Replace("$self", selfPath).Trim();
+
+        var isAt = expanded.StartsWith("@@") || expanded.StartsWith("@");
+        if (isAt)
+        {
+            var stripped = expanded.TrimStart('@').TrimStart();
+            if (stripped.Length == 0) yield break;
+            if (stripped.Contains(':'))
+            {
+                // "@namespace:X scope:subtree" — already qualified, pass through.
+                yield return WithCodeTypeFilter(stripped);
+                yield break;
+            }
+            yield return WithCodeTypeFilter($"path:{stripped}");
+            yield return WithCodeTypeFilter($"namespace:{stripped} scope:subtree");
+            yield break;
+        }
+
+        // Rebase relative "namespace:X" values onto selfPath. A value without '/' is
+        // assumed to be a subfolder of the NodeType (the default "_Source" case).
+        var rebased = RebaseRelativeNamespace(expanded, selfPath);
+        yield return WithCodeTypeFilter(rebased);
+    }
+
+    private static string RebaseRelativeNamespace(string query, string selfPath)
+    {
+        const string nsKey = "namespace:";
+        var idx = query.IndexOf(nsKey, StringComparison.OrdinalIgnoreCase);
+        if (idx < 0) return query;
+
+        var valueStart = idx + nsKey.Length;
+        var valueEnd = valueStart;
+        while (valueEnd < query.Length && !char.IsWhiteSpace(query[valueEnd]))
+            valueEnd++;
+        var value = query.Substring(valueStart, valueEnd - valueStart);
+
+        // Relative iff it contains no path separator (e.g. "_Source").
+        if (value.Length == 0 || value.Contains('/')) return query;
+
+        var rebased = $"{selfPath}/{value}";
+        return query.Substring(0, valueStart) + rebased + query.Substring(valueEnd);
+    }
+
+    private static string WithCodeTypeFilter(string query) =>
+        query.Contains("nodeType:", StringComparison.OrdinalIgnoreCase)
+            ? query
+            : $"{query} nodeType:{CodeNodeType.NodeType}";
     private readonly List<MetadataReference> _references = GetDefaultReferences();
 
     private static List<MetadataReference> GetDefaultReferences()
@@ -220,23 +285,67 @@ private async Task<string> ResolveCodeIncludesAsync(
             return dllPath;
         }
 
-        // Get CodeConfiguration from child MeshNodes under the _Source path
-        // For NodeType nodes (where Content is NodeTypeDefinition), use the node's own path
-        // For instance nodes, use the NodeType's path (e.g., "Person/_Source" for Alice with NodeType="Person")
-        // Collect ALL CodeConfiguration files and combine them
+        // Resolve the owning NodeTypeDefinition once — used both for source discovery
+        // (Sources / _Source convention) and for Configuration / ContentCollections.
+        // - If this node IS a NodeType, "self" is its own path and we read its Content.
+        // - If this node is an instance, "self" is the NodeType's path and we fetch it.
         var meshQuery = hub.ServiceProvider.GetService<IMeshService>();
+        NodeTypeDefinition? ntDef = null;
+        string selfPath;
+        if (node.Content is NodeTypeDefinition selfDef)
+        {
+            ntDef = selfDef;
+            selfPath = node.Path;
+        }
+        else
+        {
+            selfPath = node.NodeType;
+            if (meshQuery != null)
+            {
+                await foreach (var nodeTypeNode in meshQuery.QueryAsync<MeshNode>($"path:{node.NodeType}", ct: ct).WithCancellation(ct))
+                {
+                    if (nodeTypeNode?.Content is NodeTypeDefinition fetched)
+                        ntDef = fetched;
+                    break;
+                }
+            }
+        }
+
+        // Collect Code nodes from each configured source query.
+        // Default: "_Source" subtree directly under the NodeType (implicitly self-relative).
+        var sourceQueries = ntDef?.Sources is { Count: > 0 } configured
+            ? configured
+            : (IReadOnlyList<string>)["namespace:_Source scope:subtree"];
+
         var codeFiles = new List<CodeConfiguration>();
-        var codeParentPath = node.Content is NodeTypeDefinition
-            ? $"{node.Path}/_Source"    // NodeType node - use its own _Source path
-            : $"{node.NodeType}/_Source"; // Instance node - use NodeType's _Source path
+        var matchedCodePaths = new List<string>();
+        var executedQueries = new List<string>();
         if (meshQuery != null)
         {
-            var codeQuery = $"namespace:{codeParentPath} scope:subtree";
-            await foreach (var codeNode in meshQuery.QueryAsync<MeshNode>(codeQuery, ct: ct).WithCancellation(ct))
+            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (var rawQuery in sourceQueries)
             {
-                if (codeNode.Content is CodeConfiguration cf && !string.IsNullOrWhiteSpace(cf.Code))
+                if (string.IsNullOrWhiteSpace(rawQuery)) continue;
+
+                foreach (var finalQuery in ExpandSourceQuery(rawQuery, selfPath))
                 {
-                    codeFiles.Add(cf);
+                    executedQueries.Add(finalQuery);
+                    var matchesForThisQuery = 0;
+                    await foreach (var codeNode in meshQuery.QueryAsync<MeshNode>(finalQuery, ct: ct).WithCancellation(ct))
+                    {
+                        if (codeNode.Content is CodeConfiguration cf
+                            && !string.IsNullOrWhiteSpace(cf.Code)
+                            && seen.Add(codeNode.Path ?? cf.Code!))
+                        {
+                            codeFiles.Add(cf);
+                            if (!string.IsNullOrEmpty(codeNode.Path))
+                                matchedCodePaths.Add(codeNode.Path);
+                            matchesForThisQuery++;
+                        }
+                    }
+                    logger.LogInformation(
+                        "Source discovery for {NodePath}: query '{Query}' matched {Count} Code nodes",
+                        node.Path, finalQuery, matchesForThisQuery);
                 }
             }
         }
@@ -260,31 +369,8 @@ private async Task<string> ResolveCodeIncludesAsync(
             _ => new CodeConfiguration { Code = string.Join("\n\n", codeFiles.Select(cf => cf.Code)) }
         };
 
-        // Get Configuration and ContentCollections from the NodeTypeDefinition content
-        // Configuration is the source code that gets compiled into HubConfiguration
-        // For NodeType nodes (where node.Content is NodeTypeDefinition), use the node's own content
-        // For instance nodes, look up the NodeType node to get its Configuration
-        string? configuration = null;
-        List<ContentCollectionConfig>? contentCollections = null;
-        if (node.Content is NodeTypeDefinition selfDef)
-        {
-            // Node is itself a NodeType definition - use its own Configuration
-            configuration = selfDef.Configuration;
-            contentCollections = selfDef.ContentCollections;
-        }
-        else if (meshQuery != null)
-        {
-            // Instance node - look up the NodeType to get its Configuration
-            await foreach (var nodeTypeNode in meshQuery.QueryAsync<MeshNode>($"path:{node.NodeType}", ct: ct).WithCancellation(ct))
-            {
-                if (nodeTypeNode?.Content is NodeTypeDefinition ntd)
-                {
-                    configuration = ntd.Configuration;
-                    contentCollections = ntd.ContentCollections;
-                }
-                break;
-            }
-        }
+        var configuration = ntDef?.Configuration;
+        var contentCollections = ntDef?.ContentCollections;
 
         try
         {
@@ -310,6 +396,18 @@ private async Task<string> ResolveCodeIncludesAsync(
             logger.LogInformation("Compiled assembly for node {NodePath} (in-memory)", node.Path);
             return $"memory://{nodeName}";
         }
+        catch (CompilationException ex)
+        {
+            // Re-throw enriched with the actual queries that ran + which Code nodes matched,
+            // so the error overlay can tell the user *why* references are missing (usually:
+            // 0 Code nodes matched the configured sources).
+            var diag = BuildSourceDiscoveryReport(executedQueries, matchedCodePaths);
+            logger.LogError(ex, "Failed to compile assembly for node {NodePath}. {Diagnostics}", node.Path, diag);
+            throw new CompilationException(
+                ex.NodePath,
+                $"{ex.Message}\n\n--- Source discovery ---\n{diag}",
+                ex);
+        }
         catch (Exception ex) when (ex is not OperationCanceledException)
         {
             logger.LogError(ex, "Failed to compile assembly for node {NodePath}", node.Path);
@@ -317,6 +415,21 @@ private async Task<string> ResolveCodeIncludesAsync(
         }
     }
 
+    private static string BuildSourceDiscoveryReport(IReadOnlyList<string> executedQueries, IReadOnlyList<string> matchedCodePaths)
+    {
+        var sb = new System.Text.StringBuilder();
+        sb.AppendLine($"Executed source queries ({executedQueries.Count}):");
+        foreach (var q in executedQueries)
+            sb.AppendLine($"  - {q}");
+        sb.AppendLine($"Matched Code nodes ({matchedCodePaths.Count}):");
+        if (matchedCodePaths.Count == 0)
+            sb.AppendLine("  (none) — the configuration lambda cannot reference types because no source files were included. Check that your _Source Code nodes exist and that the NodeType's `sources` list points at them.");
+        else
+            foreach (var p in matchedCodePaths)
+                sb.AppendLine($"  - {p}");
+        return sb.ToString();
+    }
+
     /// <inheritdoc />
     public async Task<NodeCompilationResult?> CompileAndGetConfigurationsAsync(MeshNode node, CancellationToken ct = default)
     {
diff --git a/src/MeshWeaver.Graph/Configuration/NodeMenuItemsExtensions.cs b/src/MeshWeaver.Graph/Configuration/NodeMenuItemsExtensions.cs
index 23b1f49cf..893270138 100644
--- a/src/MeshWeaver.Graph/Configuration/NodeMenuItemsExtensions.cs
+++ b/src/MeshWeaver.Graph/Configuration/NodeMenuItemsExtensions.cs
@@ -106,6 +106,12 @@ private static async IAsyncEnumerable<NodeMenuItemDefinition> DefaultNodeMenuPro
 
         yield return MeshNodeLayoutAreas.GetThreadsMenuItem(menuPath);
 
+        var accessService = host.Hub.ServiceProvider.GetService<AccessService>();
+        var viewerId = accessService?.Context?.ObjectId
+                       ?? accessService?.CircuitContext?.ObjectId;
+        var pin = PinLayoutArea.GetMenuItem(menuPath, viewerId);
+        if (pin != null) yield return pin;
+
         var versions = VersionLayoutArea.GetMenuItem(menuPath, perms);
         if (versions != null) yield return versions;
 
@@ -115,6 +121,9 @@ private static async IAsyncEnumerable<NodeMenuItemDefinition> DefaultNodeMenuPro
         var move = MoveLayoutArea.GetMenuItem(menuPath, perms);
         if (move != null) yield return move;
 
+        var recycle = RecycleLayoutArea.GetMenuItem(menuPath, perms);
+        if (recycle != null) yield return recycle;
+
         var delete = DeleteLayoutArea.GetMenuItem(menuPath, perms);
         if (delete != null) yield return delete;
     }
diff --git a/src/MeshWeaver.Graph/Configuration/NodeTypeDefinition.cs b/src/MeshWeaver.Graph/Configuration/NodeTypeDefinition.cs
index a6c417258..7288d3f2a 100644
--- a/src/MeshWeaver.Graph/Configuration/NodeTypeDefinition.cs
+++ b/src/MeshWeaver.Graph/Configuration/NodeTypeDefinition.cs
@@ -110,4 +110,32 @@ public record NodeTypeDefinition
     /// When set, the Create form only allows selection from these namespaces.
     /// </summary>
     public List<string>? RestrictedToNamespaces { get; init; }
+
+    /// <summary>
+    /// Locations of the Code nodes to compile with this NodeType's
+    /// <see cref="Configuration"/> lambda. Each entry is either:
+    /// <list type="bullet">
+    ///   <item>A mesh query — e.g. <c>"namespace:_Source scope:subtree"</c>,
+    ///     <c>"namespace:SocialMedia/Post/_Source scope:subtree"</c>. A
+    ///     <c>namespace:X</c> with a single segment (no <c>/</c>, like
+    ///     <c>_Source</c>) is automatically rebased onto the owning NodeType's
+    ///     path. The macro <c>$self</c> can be used anywhere in the query and
+    ///     expands to that path.</item>
+    ///   <item>A single-node shorthand — <c>"@path/to/code"</c> or
+    ///     <c>"@@path/to/code"</c>. Resolves to both an exact-path match and a
+    ///     namespace-subtree match, so it works for either a leaf Code node or a
+    ///     folder of them.</item>
+    /// </list>
+    /// Every resolved query is ANDed with <c>nodeType:Code</c>, so non-code
+    /// children never leak in. Matches are de-duplicated across entries.
+    /// </summary>
+    /// <remarks>
+    /// If null or empty, defaults to <c>["namespace:_Source scope:subtree"]</c>
+    /// — the conventional <c>_Source/</c> sibling folder. Add more entries to pull
+    /// in shared code, e.g.
+    /// <c>["namespace:_Source scope:subtree", "@SocialMedia/Post/_Source/Platform"]</c>.
+    /// (Note: the <c>@@path</c> form used inside a <em>code file's body</em> is a
+    /// separate feature — inline include — handled during code-content resolution.)
+    /// </remarks>
+    public IReadOnlyList<string>? Sources { get; init; }
 }
diff --git a/src/MeshWeaver.Graph/Configuration/NodeTypeService.cs b/src/MeshWeaver.Graph/Configuration/NodeTypeService.cs
index 3127b66b9..1000a8641 100644
--- a/src/MeshWeaver.Graph/Configuration/NodeTypeService.cs
+++ b/src/MeshWeaver.Graph/Configuration/NodeTypeService.cs
@@ -50,9 +50,17 @@ internal class NodeTypeService : INodeTypeService, IDisposable
     // Compilation errors by nodeTypePath - tracks last compilation failure for error reporting
     private readonly ConcurrentDictionary<string, string> _compilationErrors = new();
 
+    // NodeType paths whose compilation is currently running. Populated the moment a compile
+    // task is kicked off; cleaned up when it finishes (success OR failure). Used by
+    // GetDiagnostics / progress overlays so callers can show "Compiling…" while they wait.
+    private readonly ConcurrentDictionary<string, DateTimeOffset> _compilingInProgress = new();
+
     // Cached access rules extracted from hub configurations
     private readonly ConcurrentDictionary<string, INodeTypeAccessRule> _accessRules = new();
 
+    // Subscription to the cross-silo change feed — disposed with the service.
+    private readonly IDisposable? _changeFeedSubscription;
+
     public NodeTypeService(
         IMessageHub hub,
         IEnumerable<IMeshQueryProvider> queryProviders,
@@ -61,7 +69,8 @@ public NodeTypeService(
         ILogger<NodeTypeService> logger,
         ICompilationCacheService cacheService,
         IOptions<CompilationCacheOptions> cacheOptions,
-        MeshNodeCompilationService? compilationService = null)
+        MeshNodeCompilationService? compilationService = null,
+        IMeshChangeFeed? changeFeed = null)
     {
         this.hub = hub;
         this.queryProviders = queryProviders;
@@ -74,6 +83,45 @@ public NodeTypeService(
 
         // Initialize cache from pre-registered nodes in MeshConfiguration
         InitializeFromMeshConfiguration();
+
+        // Subscribe to the mesh change feed so cache invalidations reach every silo.
+        // Defensive: wrap in try/catch because a construction-time throw here would
+        // take down *every* silo's DI and deadlock the whole cluster — the feed impl
+        // might not be ready, might throw on early subscription, etc. Log and move on.
+        if (changeFeed != null)
+        {
+            try
+            {
+                _changeFeedSubscription = changeFeed.Subscribe(evt =>
+                {
+                    try
+                    {
+                        if (string.IsNullOrEmpty(evt.Path)) return;
+                        if (_hubConfigurations.ContainsKey(evt.Path)
+                            || _compilationTasks.ContainsKey(evt.Path)
+                            || _compilationErrors.ContainsKey(evt.Path)
+                            || string.Equals(evt.NodeType, MeshNode.NodeTypePath, StringComparison.Ordinal))
+                        {
+                            logger.LogInformation(
+                                "Cross-silo cache invalidation for {NodeTypePath} via MeshChangeFeed ({Kind})",
+                                evt.Path, evt.Kind);
+                            InvalidateCache(evt.Path);
+                        }
+                    }
+                    catch (Exception handlerEx)
+                    {
+                        logger.LogWarning(handlerEx,
+                            "MeshChangeFeed handler faulted while processing event for {Path}",
+                            evt.Path);
+                    }
+                });
+            }
+            catch (Exception subscribeEx)
+            {
+                logger.LogWarning(subscribeEx,
+                    "Failed to subscribe to IMeshChangeFeed — cross-silo cache invalidation disabled");
+            }
+        }
     }
 
     /// <summary>
@@ -152,15 +200,46 @@ public bool IsNotCreatable(string nodeTypePath)
         return _compilationErrors.GetValueOrDefault(nodeTypePath);
     }
 
+    /// <summary>
+    /// Returns <c>true</c> if compilation for the given NodeType path is currently running
+    /// (started but not yet completed). Use this to render a "Compiling…" progress overlay
+    /// so the user sees activity instead of a blank layout while they wait.
+    /// </summary>
+    public bool IsCompiling(string nodeTypePath) =>
+        _compilingInProgress.ContainsKey(nodeTypePath);
+
+    /// <summary>
+    /// When compilation for <paramref name="nodeTypePath"/> is running, returns when it
+    /// started (UTC); otherwise <c>null</c>. Consumers can display the elapsed time in a
+    /// progress overlay.
+    /// </summary>
+    public DateTimeOffset? GetCompilationStartedAt(string nodeTypePath) =>
+        _compilingInProgress.TryGetValue(nodeTypePath, out var start) ? start : null;
+
+    /// <inheritdoc />
+    public IReadOnlyCollection<string> GetCompilingPaths() =>
+        _compilingInProgress.Keys.ToArray();
+
     private Task<string?> GetAssemblyPathAsync(string nodeTypePath, CancellationToken ct = default)
     {
+        var wasNewCompile = false;
         // Use ConcurrentDictionary.GetOrAdd with a Task to ensure only one compilation runs per key.
         // On failure, remove from dictionary to allow retry on next access.
         var task = _compilationTasks.GetOrAdd(nodeTypePath, path =>
-            CompileWithReleaseAsync(path, ct));
+        {
+            // Only the first caller to miss the cache kicks off a compile — mark it started.
+            wasNewCompile = true;
+            _compilingInProgress[path] = DateTimeOffset.UtcNow;
+            return CompileWithReleaseAsync(path, ct);
+        });
 
         return task.ContinueWith(t =>
         {
+            // Clear the in-progress marker whether we win the race or not; the task we
+            // awaited on is finished, so the state ceases to be "running" for this caller.
+            if (wasNewCompile)
+                _compilingInProgress.TryRemove(nodeTypePath, out _);
+
             // On failure, remove from cache to allow retry and return null
             if (t.IsFaulted || t.IsCanceled)
             {
@@ -206,12 +285,21 @@ public bool IsNotCreatable(string nodeTypePath)
         return _hubConfigurations.GetValueOrDefault(nodeTypePath);
     }
 
-    internal void InvalidateCache(string nodeTypePath)
+    /// <summary>
+    /// Invalidates all cached state for <paramref name="nodeTypePath"/>. Public surface so
+    /// MCP's Recycle tool (and other front-ends) can flush a stuck NodeType — disposing
+    /// the hub alone is not enough, because `_compilationErrors` / `_compilationTasks`
+    /// live on this singleton service and survive hub teardown.
+    /// </summary>
+    public void InvalidateCache(string nodeTypePath)
     {
         logger.LogDebug("Invalidating cache for {NodeTypePath}", nodeTypePath);
 
-        // Remove from all caches
+        // Remove from all caches — including the sticky error + in-progress markers
+        // (previously forgotten, which meant a stuck error kept showing after Recycle).
         _compilationTasks.TryRemove(nodeTypePath, out _);
+        _compilationErrors.TryRemove(nodeTypePath, out _);
+        _compilingInProgress.TryRemove(nodeTypePath, out _);
         _releaseKeys.TryRemove(nodeTypePath, out _);
         _hubConfigurations.TryRemove(nodeTypePath, out _);
         _creatableTypesRules.TryRemove(nodeTypePath, out _);
@@ -504,6 +592,62 @@ private MeshNode CopyIconFromNodeType(MeshNode node, string nodeType)
         }
     }
 
+    /// <summary>
+    /// Turns the NodeType's <see cref="NodeTypeDefinition.Sources"/> list into concrete
+    /// storage paths to probe for Code nodes. Lines understood:
+    /// <list type="bullet">
+    ///   <item><c>"_Source"</c> (or any value without <c>/</c>) — rebased onto <paramref name="nodeTypePath"/>.</item>
+    ///   <item><c>"namespace:X"</c> / <c>"path:X"</c> — the X part is used as a storage path.</item>
+    ///   <item><c>"@X"</c> / <c>"@@X"</c> — shorthand for the path X.</item>
+    ///   <item><c>$self</c> inside any entry — expanded to <paramref name="nodeTypePath"/>.</item>
+    /// </list>
+    /// If the list is null or empty, defaults to <c>"{nodeTypePath}/_Source"</c>.
+    /// Query-syntax decoration like <c>scope:subtree</c> and <c>nodeType:Code</c> is
+    /// stripped — this helper is only concerned with the path segment, since we feed
+    /// <see cref="IMeshStorage.GetDescendantsAsync"/> below.
+    /// </summary>
+    private static IReadOnlyList<string> ResolveSourcePaths(
+        IReadOnlyList<string>? sources,
+        string nodeTypePath)
+    {
+        if (sources == null || sources.Count == 0)
+            return [$"{nodeTypePath}/_Source"];
+
+        var result = new List<string>(sources.Count);
+        foreach (var raw in sources)
+        {
+            if (string.IsNullOrWhiteSpace(raw)) continue;
+            var expanded = raw.Replace("$self", nodeTypePath).Trim();
+
+            // Strip the @/@@ shorthand.
+            if (expanded.StartsWith("@@")) expanded = expanded[2..].TrimStart();
+            else if (expanded.StartsWith("@")) expanded = expanded[1..].TrimStart();
+            if (expanded.Length == 0) continue;
+
+            // Pull out the value of the first recognised qualifier (namespace:/path:), if any.
+            var value = expanded;
+            foreach (var qualifier in new[] { "namespace:", "path:" })
+            {
+                var idx = value.IndexOf(qualifier, StringComparison.OrdinalIgnoreCase);
+                if (idx < 0) continue;
+                var valueStart = idx + qualifier.Length;
+                var valueEnd = valueStart;
+                while (valueEnd < value.Length && !char.IsWhiteSpace(value[valueEnd]))
+                    valueEnd++;
+                value = value[valueStart..valueEnd];
+                break;
+            }
+
+            // If the value is a single segment (no /), treat as self-relative folder.
+            if (value.Length > 0 && !value.Contains('/'))
+                value = $"{nodeTypePath}/{value}";
+
+            if (value.Length > 0)
+                result.Add(value);
+        }
+        return result.Count > 0 ? result : [$"{nodeTypePath}/_Source"];
+    }
+
     /// <summary>
     /// Gathers all inputs needed for compilation from persistence.
     /// Returns a NodeTypeRelease with all compilation inputs and the MeshNode.
@@ -533,16 +677,44 @@ private MeshNode CopyIconFromNodeType(MeshNode node, string nodeType)
             return (null, null);
         }
 
-        // Get CodeConfigurations from child MeshNodes under /_Source path directly
+        // Collect Code nodes from the configured sources. Default: the sibling "_Source"
+        // subtree. `GetAllDescendantsAsync` (not `GetDescendantsAsync`) is used because
+        // Code nodes are persisted as satellites — CreateNodeRequest auto-sets
+        // MainNode to the parent namespace for any NodeType registered as satellite.
+        // The regular `GetDescendantsAsync` in InMemoryPersistenceService excludes
+        // satellites from browsing; the `All` variant includes them.
+        // We also check the parent path as a single-node fetch so `path:X` shorthand
+        // with a leaf Code node path works.
         var codeFiles = new List<string>();
-        await foreach (var codeNode in meshStorage.GetChildrenAsync($"{nodeTypePath}/_Source"))
+        var codeFilePaths = new List<string>();
+        var seenCodePaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        var sourcePaths = ResolveSourcePaths(definition.Sources, nodeTypePath);
+        foreach (var sourcePath in sourcePaths)
         {
-            if (codeNode.Content is CodeConfiguration codeConfig && !string.IsNullOrEmpty(codeConfig.Code))
-            {
-                codeFiles.Add(codeConfig.Code);
-            }
+            // Path-exact fetch first (handles `path:X` / `@X` pointing at a single Code node).
+            var single = await meshStorage.GetNodeAsync(sourcePath, ct);
+            if (single != null) AddIfCodeNode(single);
+
+            // Then all descendants INCLUDING satellites — that's the Code-file case.
+            await foreach (var descendant in meshStorage.GetAllDescendantsAsync(sourcePath))
+                AddIfCodeNode(descendant);
         }
 
+        void AddIfCodeNode(MeshNode candidate)
+        {
+            if (candidate.NodeType != CodeNodeType.NodeType) return;
+            if (candidate.Content is not CodeConfiguration codeConfig) return;
+            if (string.IsNullOrEmpty(codeConfig.Code)) return;
+            if (candidate.Path is { Length: > 0 } p && !seenCodePaths.Add(p)) return;
+            codeFiles.Add(codeConfig.Code);
+            if (candidate.Path != null) codeFilePaths.Add(candidate.Path);
+        }
+
+        logger.LogInformation(
+            "NodeType '{NodeTypePath}' source discovery: {Count} Code nodes from [{Paths}]",
+            nodeTypePath, codeFiles.Count, string.Join(", ", codeFilePaths));
+
         // Resolve @@ include references in code files (e.g., @@FutuRe/LineOfBusiness/_Source/LineOfBusiness)
         if (compilationService != null)
         {
@@ -680,15 +852,37 @@ private void OnStreamUpdated(string nodeTypePath)
 
     /// <summary>
     /// Creates a hub configuration that shows a compilation error in the Overview area.
+    /// Renders as markdown so it respects the current theme (readable in both light and
+    /// dark modes) and gets code-block formatting for the Roslyn diagnostics.
     /// </summary>
     private static Func<MessageHubConfiguration, MessageHubConfiguration> CreateCompilationErrorConfiguration(string errorMessage)
     {
         return config => config.AddLayout(layout =>
             layout.WithView(MeshNodeLayoutAreas.OverviewArea, (host, ctx) =>
-                Observable.Return<UiControl?>(
-                    Controls.Stack
-                        .WithView(Controls.Html(
-                            $"<div style=\"color:#d32f2f;background:#fce4ec;padding:16px;border:1px solid #d32f2f;border-radius:4px;font-family:monospace;white-space:pre-wrap\">{WebUtility.HtmlEncode(errorMessage)}</div>")))));
+                Observable.Return<UiControl?>(BuildCompilationErrorMarkdown(errorMessage))));
+    }
+
+    private static UiControl BuildCompilationErrorMarkdown(string errorMessage)
+    {
+        // Split "Compilation failed for 'X':\n<diagnostics>" into header + body so the
+        // diagnostics land in a fenced code block — much easier to read than one long
+        // HTML blob, and uses the theme's code/text colours.
+        var newlineIdx = errorMessage.IndexOf('\n');
+        var header = newlineIdx >= 0 ? errorMessage[..newlineIdx].TrimEnd(':') : errorMessage;
+        var body = newlineIdx >= 0 ? errorMessage[(newlineIdx + 1)..].TrimEnd() : string.Empty;
+
+        var markdown =
+$@"> **⚠ {header}**
+>
+> Fix the source code or the NodeType's `sources` list, then use the **Recycle** menu to flush the cached grain (or call `GetDiagnostics` via MCP to re-check).
+
+```text
+{body}
+```";
+
+        return Controls.Stack
+            .WithStyle("padding: 16px;")
+            .WithView(Controls.Markdown(markdown));
     }
 
     #region Creatable Types
@@ -936,6 +1130,7 @@ private static string GetLastPathSegment(string path)
 
     public void Dispose()
     {
+        _changeFeedSubscription?.Dispose();
         foreach (var subscription in _subscriptions.Values)
         {
             subscription.Dispose();
diff --git a/src/MeshWeaver.Graph/Configuration/RoleNodeType.cs b/src/MeshWeaver.Graph/Configuration/RoleNodeType.cs
index 7c6044b4a..4cb96c388 100644
--- a/src/MeshWeaver.Graph/Configuration/RoleNodeType.cs
+++ b/src/MeshWeaver.Graph/Configuration/RoleNodeType.cs
@@ -46,6 +46,33 @@ public static TBuilder AddRoleType<TBuilder>(this TBuilder builder) where TBuild
             .AddDefaultLayoutAreas()
     };
 
+    // Inline SVGs for the four built-in roles — rendered directly by MeshNodeImageHelper.IsInlineSvg.
+    // Each uses a 20x20 rounded-square badge matching shield.svg's visual language, with a distinct
+    // hue per role so they read at a glance in menus, thumbnails, and permission pickers.
+    private const string AdminIcon =
+        "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 20 20\">" +
+        "<rect width=\"20\" height=\"20\" rx=\"4\" fill=\"#B91C1C\"/>" +
+        "<path d=\"M10 3.2a.6.6 0 0 1 .5.28 5.2 5.2 0 0 0 4.2 2.15.6.6 0 0 1 .6.56c.1 1.02.12 2.08.04 3.16A8 8 0 0 1 10.3 16a.6.6 0 0 1-.6 0 8 8 0 0 1-5.04-6.65 16 16 0 0 1 .04-3.16.6.6 0 0 1 .6-.56A5.2 5.2 0 0 0 9.5 3.48a.6.6 0 0 1 .5-.28Zm-2.2 5.3 1.6 1.6 2.8-2.8.8.8-3.6 3.6-2.4-2.4.8-.8Z\" fill=\"white\"/>" +
+        "</svg>";
+
+    private const string EditorIcon =
+        "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 20 20\">" +
+        "<rect width=\"20\" height=\"20\" rx=\"4\" fill=\"#16A34A\"/>" +
+        "<path d=\"M13.47 3.97a1.6 1.6 0 0 1 2.26 2.26l-.85.85-2.26-2.26.85-.85Zm-1.56 1.56 2.26 2.26-6.9 6.9-2.83.57.57-2.83 6.9-6.9Z\" fill=\"white\"/>" +
+        "</svg>";
+
+    private const string ViewerIcon =
+        "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 20 20\">" +
+        "<rect width=\"20\" height=\"20\" rx=\"4\" fill=\"#2563EB\"/>" +
+        "<path d=\"M10 5.5c3.2 0 5.9 1.9 7 4.5-1.1 2.6-3.8 4.5-7 4.5S4.1 12.6 3 10c1.1-2.6 3.8-4.5 7-4.5Zm0 1.8a2.7 2.7 0 1 0 0 5.4 2.7 2.7 0 0 0 0-5.4Zm0 1.2a1.5 1.5 0 1 1 0 3 1.5 1.5 0 0 1 0-3Z\" fill=\"white\"/>" +
+        "</svg>";
+
+    private const string CommenterIcon =
+        "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 20 20\">" +
+        "<rect width=\"20\" height=\"20\" rx=\"4\" fill=\"#F59E0B\"/>" +
+        "<path d=\"M5 6.5A1.5 1.5 0 0 1 6.5 5h7A1.5 1.5 0 0 1 15 6.5v5A1.5 1.5 0 0 1 13.5 13H9.4l-2.8 2.3A.5.5 0 0 1 5.8 15v-2A1.5 1.5 0 0 1 4.5 11.5v-5H5Zm2.5 1.75a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm2.5 0a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm2.5 0a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Z\" fill=\"white\"/>" +
+        "</svg>";
+
     /// <summary>
     /// Provides the four built-in roles as static MeshNodes
     /// so they appear in query results regardless of scope.
@@ -68,10 +95,10 @@ private class BuiltInRolesProvider : IStaticNodeProvider
                     Thread = false
                 }
             },
-            new("Admin", "Role") { Name = "Admin", NodeType = NodeType, Content = Role.Admin },
-            new("Editor", "Role") { Name = "Editor", NodeType = NodeType, Content = Role.Editor },
-            new("Viewer", "Role") { Name = "Viewer", NodeType = NodeType, Content = Role.Viewer },
-            new("Commenter", "Role") { Name = "Commenter", NodeType = NodeType, Content = Role.Commenter },
+            new("Admin", "Role") { Name = "Admin", NodeType = NodeType, Icon = AdminIcon, Content = Role.Admin },
+            new("Editor", "Role") { Name = "Editor", NodeType = NodeType, Icon = EditorIcon, Content = Role.Editor },
+            new("Viewer", "Role") { Name = "Viewer", NodeType = NodeType, Icon = ViewerIcon, Content = Role.Viewer },
+            new("Commenter", "Role") { Name = "Commenter", NodeType = NodeType, Icon = CommenterIcon, Content = Role.Commenter },
         ];
 
         public IEnumerable<MeshNode> GetStaticNodes() => Nodes;
diff --git a/src/MeshWeaver.Graph/CreateLayoutArea.cs b/src/MeshWeaver.Graph/CreateLayoutArea.cs
index 3e2c8454e..13bd07a47 100644
--- a/src/MeshWeaver.Graph/CreateLayoutArea.cs
+++ b/src/MeshWeaver.Graph/CreateLayoutArea.cs
@@ -1,4 +1,5 @@
 using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
 using System.Text.Json;
 using System.Text.RegularExpressions;
 using MeshWeaver.Application.Styles;
@@ -43,8 +44,10 @@ public static class CreateLayoutArea
     }
     /// <summary>
     /// Main entry point for the Create layout area.
-    /// - If current node is Transient: shows Create editor (own content type).
-    /// - Otherwise: shows unified Create New form with type autocomplete.
+    /// - If current node is Transient: renders the Create editor inline (same UI as Edit).
+    ///   The user confirms via Save, which flips state to Active. No auto-redirect to Edit
+    ///   (that would race with workspace replication and report "node does not exist").
+    /// - Otherwise: shows the unified Create New form with type picker.
     /// </summary>
     public static IObservable<UiControl?> Create(LayoutAreaHost host, RenderingContext _)
     {
@@ -53,22 +56,13 @@ public static class CreateLayoutArea
         var nodeStream = host.Workspace.GetStream<MeshNode>()?.Select(nodes => nodes ?? Array.Empty<MeshNode>())
             ?? Observable.Return<MeshNode[]>(Array.Empty<MeshNode>());
 
-        return nodeStream.Take(1).SelectMany(async nodes =>
+        return nodeStream.Take(1).Select(nodes =>
         {
             var currentNode = nodes.FirstOrDefault(n => n.Path == currentPath);
 
-            // If current node is Transient, confirm it (set Active) and redirect to Edit
             if (currentNode?.State == MeshNodeState.Transient)
-            {
-                var nodeFactory = host.Hub.ServiceProvider.GetRequiredService<IMeshService>();
-                var activeNode = currentNode with { State = MeshNodeState.Active };
-                await nodeFactory.UpdateNodeAsync(activeNode);
-
-                var editUrl = MeshNodeLayoutAreas.BuildUrl(currentPath, MeshNodeLayoutAreas.EditArea);
-                return (UiControl?)Controls.Redirect(editUrl);
-            }
+                return (UiControl?)BuildCreateEditor(host, currentNode);
 
-            // Not transient — show the Create New form inline
             return (UiControl?)BuildCreateNewForm(host, nodes, currentPath);
         });
     }
@@ -504,11 +498,22 @@ private static UiControl BuildCreateNewForm(
             ["namespace"] = defaultNamespace,
             ["type"] = defaultType,
             ["name"] = "",
-            ["id"] = ""
+            ["id"] = "",
+            ["description"] = ""
         });
         var dataContext = LayoutAreaReference.GetDataPointer(formId);
 
-        // 4. Name field (required)
+        // 4. Description — free-text seed for future AI-assisted Name/Id/Icon generation.
+        // Stored on the final node so Settings can display / re-generate from it.
+        stack = stack.WithView(new TextAreaControl(new JsonPointerReference("description"))
+        {
+            Label = "Description",
+            Placeholder = "Briefly describe what you're creating. Used to seed Name/Id/Icon generation.",
+            Immediate = true,
+            DataContext = dataContext
+        }.WithRows(3).WithStyle("width: 100%; margin-bottom: 16px;"));
+
+        // 5. Name field (required)
         stack = stack.WithView(new TextFieldControl(new JsonPointerReference("name"))
         {
             Label = "Name *",
@@ -635,6 +640,7 @@ private static UiControl BuildCreateNewForm(
                 var selectedType = formValues.GetValueOrDefault("type")?.ToString()?.Trim();
                 var name = formValues.GetValueOrDefault("name")?.ToString()?.Trim();
                 var id = formValues.GetValueOrDefault("id")?.ToString()?.Trim();
+                var description = formValues.GetValueOrDefault("description")?.ToString()?.Trim();
 
                 if (string.IsNullOrWhiteSpace(selectedType))
                 {
@@ -682,10 +688,18 @@ private static UiControl BuildCreateNewForm(
                         return;
                     }
 
+                    // Pull Icon/Category from the registered NodeType definition so the transient
+                    // has a usable appearance immediately (before ConfigResolver enrichment kicks in).
+                    var typeRegistration = meshConfiguration.Nodes.Values
+                        .FirstOrDefault(n => n.Path == selectedType);
+
                     var newNode = MeshNode.FromPath(nodePath) with
                     {
                         Name = name.Trim(),
+                        Description = string.IsNullOrEmpty(description) ? null : description,
                         NodeType = selectedType,
+                        Icon = typeRegistration?.Icon,
+                        Category = typeRegistration?.Category,
                         DesiredId = id,
                         State = MeshNodeState.Transient
                     };
@@ -694,6 +708,21 @@ private static UiControl BuildCreateNewForm(
                     await nodeFactory.CreateTransientAsync(newNode, CancellationToken.None);
                     logger?.LogInformation("Successfully created transient node at {NodePath}", nodePath);
 
+                    // Wait for the workspace stream to observe the new node before navigating,
+                    // otherwise /{nodePath}/Create races replication and renders an empty form.
+                    try
+                    {
+                        await host.Workspace.GetStream<MeshNode>()!
+                            .Where(ns => ns?.Any(n => n.Path == nodePath) == true)
+                            .Take(1)
+                            .Timeout(TimeSpan.FromSeconds(5))
+                            .ToTask();
+                    }
+                    catch (TimeoutException)
+                    {
+                        logger?.LogWarning("Timed out waiting for workspace to observe {NodePath}", nodePath);
+                    }
+
                     var createUrl = MeshNodeLayoutAreas.BuildUrl(nodePath, MeshNodeLayoutAreas.CreateNodeArea);
                     actx.NavigateTo(createUrl);
                 }
diff --git a/src/MeshWeaver.Graph/DeleteLayoutArea.cs b/src/MeshWeaver.Graph/DeleteLayoutArea.cs
index bc4962ccd..1725f7c58 100644
--- a/src/MeshWeaver.Graph/DeleteLayoutArea.cs
+++ b/src/MeshWeaver.Graph/DeleteLayoutArea.cs
@@ -31,6 +31,9 @@ public static class DeleteLayoutArea
     }
     /// <summary>
     /// Entry point for the Delete layout area.
+    /// Fully reactive composition — no <c>await</c> on the rendering path.
+    /// Permission and descendant-count streams are combined via <c>CombineLatest</c>;
+    /// a blocked hub cannot produce an emission so the render stays empty instead of deadlocking.
     /// </summary>
     [Browsable(false)]
     public static IObservable<UiControl?> Delete(LayoutAreaHost host, RenderingContext _)
@@ -39,45 +42,56 @@ public static class DeleteLayoutArea
         var backHref = MeshNodeLayoutAreas.BuildUrl(nodePath, MeshNodeLayoutAreas.OverviewArea);
         var meshQuery = host.Hub.ServiceProvider.GetService<IMeshService>();
 
-        // Count descendants and check permissions asynchronously
-        return Observable.FromAsync(async () =>
-        {
-            // Permission gate: check Delete permission
-            var canDelete = await PermissionHelper.CanDeleteAsync(host.Hub, nodePath);
-            if (!canDelete)
-                return -1; // Sentinel value for access denied
+        // Both source streams must emit at least once for the page to render. Add Timeout
+        // + Catch so a stuck permission lookup or a hanging descendant count can never
+        // leave the user with an eternal spinner. We render conservatively on failure
+        // (deny, zero descendants) rather than blocking.
+        var permissionsObs = PermissionHelper.ObservePermissions(host.Hub, nodePath)
+            .Take(1)
+            .Timeout(TimeSpan.FromSeconds(10))
+            .Catch<Permission, Exception>(_ => Observable.Return(Permission.None));
+
+        var descendantsObs = (meshQuery != null
+            ? Observable.FromAsync(token => CountDescendantsAsync(meshQuery, nodePath, token))
+            : Observable.Return(0))
+            .Timeout(TimeSpan.FromSeconds(10))
+            .Catch<int, Exception>(_ => Observable.Return(0));
+
+        var placeholder = (UiControl?)Controls.Stack.WithStyle("padding: 24px;")
+            .WithView(Controls.Html(
+                "<p style=\"color: var(--neutral-foreground-hint);\">Loading delete confirmation…</p>"));
+
+        return permissionsObs.CombineLatest(descendantsObs,
+            (perms, count) => (canDelete: perms.HasFlag(Permission.Delete), count))
+            .Select(tuple => (UiControl?)(tuple.canDelete
+                ? BuildDeletePage(host, nodePath, backHref, tuple.count)
+                : BuildAccessDenied(backHref)))
+            .StartWith(placeholder);
+    }
 
-            var descendantCount = 0;
-            if (meshQuery != null)
-            {
-                await foreach (var _ in meshQuery.QueryAsync(
-                    MeshQueryRequest.FromQuery($"path:{nodePath} scope:descendants")))
-                    descendantCount++;
-            }
-            return descendantCount;
-        }).Select(descendantCount =>
-        {
-            // Access denied
-            if (descendantCount < 0)
-            {
-                return (UiControl?)Controls.Stack.WithWidth("100%").WithStyle("padding: 24px;")
-                    .WithView(Controls.Stack
-                        .WithOrientation(Orientation.Horizontal)
-                        .WithHorizontalGap(16)
-                        .WithStyle("align-items: center; margin-bottom: 24px;")
-                        .WithView(Controls.Button("Back")
-                            .WithAppearance(Appearance.Lightweight)
-                            .WithIconStart(FluentIcons.ArrowLeft())
-                            .WithNavigateToHref(backHref))
-                        .WithView(Controls.H2("Access Denied").WithStyle("margin: 0; color: var(--error);")))
-                    .WithView(Controls.Html(
-                        "<p style=\"color: var(--neutral-foreground-hint);\">You do not have permission to delete this node.</p>"));
-            }
-
-            return BuildDeletePage(host, nodePath, backHref, descendantCount);
-        });
+    private static async Task<int> CountDescendantsAsync(IMeshService meshQuery, string nodePath, CancellationToken ct)
+    {
+        var count = 0;
+        await foreach (var _ in meshQuery.QueryAsync(
+                           MeshQueryRequest.FromQuery($"path:{nodePath} scope:descendants"), ct))
+            count++;
+        return count;
     }
 
+    private static UiControl BuildAccessDenied(string backHref) =>
+        Controls.Stack.WithWidth("100%").WithStyle("padding: 24px;")
+            .WithView(Controls.Stack
+                .WithOrientation(Orientation.Horizontal)
+                .WithHorizontalGap(16)
+                .WithStyle("align-items: center; margin-bottom: 24px;")
+                .WithView(Controls.Button("Back")
+                    .WithAppearance(Appearance.Lightweight)
+                    .WithIconStart(FluentIcons.ArrowLeft())
+                    .WithNavigateToHref(backHref))
+                .WithView(Controls.H2("Access Denied").WithStyle("margin: 0; color: var(--error);")))
+            .WithView(Controls.Html(
+                "<p style=\"color: var(--neutral-foreground-hint);\">You do not have permission to delete this node.</p>"));
+
     private static UiControl BuildDeletePage(LayoutAreaHost host, string nodePath, string backHref, int descendantCount)
     {
         // Set up data binding for confirmation field
@@ -138,31 +152,38 @@ private static UiControl BuildDeletePage(LayoutAreaHost host, string nodePath, s
                 .WithAppearance(Appearance.Accent)
                 .WithStyle("background: var(--error, #d32f2f); color: white;")
                 .WithIconStart(FluentIcons.Delete())
-                .WithClickAction(async ctx =>
+                .WithClickAction(ctx =>
                 {
-                    var formValues = await ctx.Host.Stream
-                        .GetDataStream<Dictionary<string, object?>>(dataId).FirstAsync();
-
-                    var confirmation = formValues.GetValueOrDefault("confirmation")?.ToString()?.Trim();
-                    if (confirmation != "DELETE")
-                    {
-                        ShowDialog(ctx, "Confirmation Required",
-                            "Please type **DELETE** in the confirmation field to proceed.");
-                        return;
-                    }
-
-                    // Reactive delete — subscribe with onNext/onError to surface failures.
-                    host.Hub.ServiceProvider.GetRequiredService<IMeshService>()
-                        .DeleteNode(nodePath).Subscribe(
-                            _ =>
-                            {
-                                // Empty the area in-place — no redirect. The user can navigate via menu/back.
-                                ctx.Host.UpdateArea(MeshNodeLayoutAreas.DeleteArea, null);
-                            },
-                            ex =>
+                    // Fully reactive: no await anywhere on the hub thread.
+                    // 1) Read the form data synchronously via Take(1).Subscribe
+                    // 2) Validate
+                    // 3) Call IMeshService.DeleteNode (Post + RegisterCallback under the hood)
+                    //    and propagate onNext/onError via Subscribe.
+                    ctx.Host.Stream
+                        .GetDataStream<Dictionary<string, object?>>(dataId)
+                        .Take(1)
+                        .Subscribe(formValues =>
+                        {
+                            var confirmation = formValues.GetValueOrDefault("confirmation")?.ToString()?.Trim();
+                            if (confirmation != "DELETE")
                             {
-                                ShowDialog(ctx, "Delete Failed", $"Could not delete node: {ex.Message}");
-                            });
+                                ShowDialog(ctx, "Confirmation Required",
+                                    "Please type **DELETE** in the confirmation field to proceed.");
+                                return;
+                            }
+
+                            host.Hub.ServiceProvider.GetRequiredService<IMeshService>()
+                                .DeleteNode(nodePath)
+                                .Subscribe(
+                                    _ =>
+                                    {
+                                        // Empty the area in-place — no redirect. The user can navigate via menu/back.
+                                        ctx.Host.UpdateArea(MeshNodeLayoutAreas.DeleteArea, null);
+                                    },
+                                    ex => ShowDialog(ctx, "Delete Failed", $"Could not delete node: {ex.Message}"));
+                        });
+
+                    return Task.CompletedTask;
                 })));
 
         return stack;
diff --git a/src/MeshWeaver.Graph/Icons/meshweaver-logo.svg b/src/MeshWeaver.Graph/Icons/meshweaver-logo.svg
new file mode 100644
index 000000000..96946bae4
--- /dev/null
+++ b/src/MeshWeaver.Graph/Icons/meshweaver-logo.svg
@@ -0,0 +1,42 @@
+<svg viewBox="0 0 750 750" xmlns="http://www.w3.org/2000/svg">
+    <!-- Primary color paths -->
+    <g fill="#0655bf">
+        <path d="M415.41 392.39L388.85 410.45L429.04 466.72L475.29 435.17L415.41 392.39" />
+        <path d="M429.32 311.05L450.02 280.76L403.32 219.75L370.41 267.49L429.32 311.05" />
+        <path d="M334.85 334.85L374.81 390.8L387.4 372.38L334.85 334.85" />
+        <path d="M530.42 385.82L494.35 338.68L479.94 348.49L530.42 385.82" />
+        <path d="M257.07 431.89L362.17 512.33L368.99 507.67L284.03 392.78L257.07 431.89" />
+        <path d="M400.67 216.28L346.71 145.78L286.81 205.68L358.36 258.59L400.67 216.28" />
+        <path d="M153.79 581.69L197.06 624.95L290.29 561.36L208.17 502.82L153.79 581.69" />
+        <path d="M32.3 460.19L94.53 522.42L153.27 463.68L80.61 411.88L32.3 460.19" />
+        <path d="M258.59 358.36L205.68 286.81L145.78 346.71L216.28 400.67L258.59 358.36" />
+        <path d="M258.1 685.99L322.11 750L418.99 653.12L344.26 599.84L258.1 685.99" />
+        <path d="M494.91 449.18L449.18 494.91L502.52 569.59L569.59 502.52L494.91 449.18" />
+        <path d="M750 322.11L656.36 228.47L562.71 292.18L653.12 418.99L750 322.11" />
+        <path d="M555.02 127.12L460.19 32.3L411.88 80.61L501.19 205.89L555.02 127.12" />
+        <path d="M257.07 431.89L208.17 502.82L290.29 561.36L362.17 512.33L257.07 431.89" />
+        <path d="M530.42 385.82L479.94 348.49L415.41 392.39L475.29 435.17L581.09 363L494.91 449.18L569.59 502.52L653.12 418.99L562.71 292.18L494.35 338.68L530.42 385.82" />
+        <path d="M358.36 258.59L286.81 205.68L205.68 286.81L258.59 358.36L358.36 258.59" />
+    </g>
+
+    <!-- Secondary color paths -->
+    <g fill="#f26363">
+        <path d="M416.93 200.02L400.67 216.28L403.32 219.75L416.93 200.02" />
+        <path d="M370.41 267.49L358.36 258.59L258.59 358.36L284.03 392.78L370.41 267.49" />
+        <path d="M499.6 710.59L560.06 650.14L502.52 569.59L418.99 653.12L499.6 710.59" />
+        <path d="M650.14 560.06L710.59 499.6L653.12 418.99L569.59 502.52L650.14 560.06" />
+        <path d="M387.4 372.38L415.41 392.39L479.94 348.49L429.32 311.05L387.4 372.38" />
+        <path d="M429.04 466.72L368.99 507.67L385.82 530.42L362.17 512.33L290.29 561.36L344.26 599.84L449.18 494.91L429.04 466.72" />
+        <path d="M337.51 445.38L374.81 390.8L334.85 334.85L387.4 372.38L429.32 311.05L370.41 267.49L284.03 392.78L368.99 507.67L429.04 466.72L388.85 410.45L337.51 445.38" />
+        <path d="M344.26 599.84L418.99 653.12L502.52 569.59L449.18 494.91L344.26 599.84" />
+        <path d="M337.51 445.38L388.85 410.45L374.81 390.8L337.51 445.38" />
+        <path d="M475.29 435.17L494.91 449.18L581.09 363L475.29 435.17" />
+        <path d="M67.56 286.84L0 354.41L80.61 411.88L145.78 346.71L67.56 286.84" />
+        <path d="M207.43 146.98L146.98 207.43L205.68 286.81L286.81 205.68L207.43 146.98" />
+        <path d="M354.41 0L286.84 67.56L346.71 145.78L411.88 80.61L354.41 0" />
+        <path d="M216.28 400.67L153.27 463.68L208.17 502.82L257.07 431.89L216.28 400.67" />
+        <path d="M494.35 338.68L562.71 292.18L501.19 205.89L450.02 280.76L494.35 338.68" />
+        <path d="M416.93 200.02L403.32 219.75L450.02 280.76L501.19 205.89L411.88 80.61L346.71 145.78L400.67 216.28L416.93 200.02" />
+        <path d="M145.78 346.71L80.61 411.88L153.27 463.68L216.28 400.67L145.78 346.71" />
+    </g>
+</svg>
diff --git a/src/MeshWeaver.Graph/MarkdownEditLayoutArea.cs b/src/MeshWeaver.Graph/MarkdownEditLayoutArea.cs
index b8bc1f8e5..03cade874 100644
--- a/src/MeshWeaver.Graph/MarkdownEditLayoutArea.cs
+++ b/src/MeshWeaver.Graph/MarkdownEditLayoutArea.cs
@@ -51,7 +51,8 @@ private static UiControl BuildEditContent(
         string initialContent,
         bool trackChanges)
     {
-        var backHref = MeshNodeLayoutAreas.BuildUrl(hubPath, MarkdownLayoutAreas.OverviewArea);
+        // Back to the node's default area (no hardcoded "/Overview")
+        var backHref = $"/{hubPath}";
 
         var container = Controls.Stack
             .WithWidth("100%")
diff --git a/src/MeshWeaver.Graph/MeshDataSourceLayoutAreas.cs b/src/MeshWeaver.Graph/MeshDataSourceLayoutAreas.cs
index e8b37ab68..25bdc9499 100644
--- a/src/MeshWeaver.Graph/MeshDataSourceLayoutAreas.cs
+++ b/src/MeshWeaver.Graph/MeshDataSourceLayoutAreas.cs
@@ -378,7 +378,13 @@ private static async Task ExecuteCopyInstall(
                     LastSyncedAt = DateTimeOffset.UtcNow
                 };
                 var updatedNode = sourceNode with { Content = updatedConfig };
-                await persistence.SaveNodeAsync(updatedNode);
+                persistence.SaveNode(updatedNode).Subscribe(
+                    saved => logger?.LogInformation(
+                        "Marked data source {Path} as installed to {Target}",
+                        saved.Path, updatedConfig.InstalledTo),
+                    ex => logger?.LogError(ex,
+                        "Failed to mark data source {Path} as installed",
+                        updatedNode.Path));
             }
 
             var resultDialog = Controls.Dialog(
diff --git a/src/MeshWeaver.Graph/MeshNodeLayoutAreas.cs b/src/MeshWeaver.Graph/MeshNodeLayoutAreas.cs
index 9ad2d93db..8a31159bf 100644
--- a/src/MeshWeaver.Graph/MeshNodeLayoutAreas.cs
+++ b/src/MeshWeaver.Graph/MeshNodeLayoutAreas.cs
@@ -72,6 +72,7 @@ public static class MeshNodeLayoutAreas
     public const string ExportArea = "Export";
     public const string CopyArea = "Copy";
     public const string MoveArea = "Move";
+    public const string RecycleArea = "Recycle";
     public const string VersionsArea = "Versions";
     public const string VersionDiffArea = "VersionDiff";
 
@@ -115,9 +116,13 @@ public static LayoutDefinition AddDefaultLayoutAreas(this LayoutDefinition layou
             .WithView(ExportArea, ExportLayoutArea.Export)
             .WithView(CopyArea, CopyLayoutArea.Copy)
             .WithView(MoveArea, MoveLayoutArea.Move)
+            .WithView(RecycleArea, RecycleLayoutArea.Recycle)
             .WithView(VersionsArea, VersionLayoutArea.Versions)
             .WithView(VersionDiffArea, VersionLayoutArea.VersionDiff)
             .WithView(DeleteArea, DeleteLayoutArea.Delete)
+            .WithView(PinLayoutArea.PinArea, PinLayoutArea.Pin)
+            .WithView(PinLayoutArea.UnpinArea, PinLayoutArea.Unpin)
+            .WithView(PinLayoutArea.PinnedThumbnailArea, PinLayoutArea.PinnedThumbnail)
             // UCR special areas
             .WithView(DataArea, Data)
             .WithView(SchemaArea, Schema)
@@ -259,10 +264,12 @@ internal static UiControl BuildHeader(LayoutAreaHost host, MeshNode? node, bool
         var title = node?.Name ?? node?.Id ?? host.Hub.Address.ToString();
         var iconValue = MeshNodeImageHelper.ResolveNodeIcon(node);
 
-        // Build title with icon
+        // Build title with icon.
+        // Extra top margin separates the icon+title row from whatever sits above it
+        // (e.g. the parent back-link / breadcrumb rendered by the surrounding page).
         var titleContent = Controls.Stack
             .WithOrientation(Orientation.Horizontal)
-            .WithStyle("align-items: center; gap: 16px;");
+            .WithStyle("align-items: center; gap: 20px; margin-top: 16px;");
 
         // Add icon/image if available
         if (!string.IsNullOrEmpty(iconValue))
@@ -323,7 +330,9 @@ internal static UiControl BuildHeader(LayoutAreaHost host, MeshNode? node, bool
         }
         else
         {
-            titleContent = titleContent.WithView(Controls.Html($"<h1 style=\"margin: 0;\">{System.Web.HttpUtility.HtmlEncode(title)}</h1>"));
+            titleContent = titleContent.WithView(Controls.Html(
+                $"<h1 style=\"margin: 0; font-size: 2rem; font-weight: 700; letter-spacing: -0.02em; line-height: 1.15;\">" +
+                $"{System.Web.HttpUtility.HtmlEncode(title)}</h1>"));
         }
 
         return Controls.Stack
@@ -690,7 +699,7 @@ private static string GetNodeContent(MeshNode? node)
                 .WithPlaceholder("Search... (use @ for references)")
                 .WithRenderMode(MeshSearchRenderMode.Hierarchical)
                 .WithMaxColumns(3)
-                .WithCreateHref($"/create?type=Markdown&namespace={Uri.EscapeDataString(instanceNs)}");
+                .WithCreateHref($"/create?namespace={Uri.EscapeDataString(instanceNs)}");
         });
     }
 
@@ -717,7 +726,7 @@ public static UiControl Children(LayoutAreaHost host, RenderingContext _)
             .WithItemLimit(50)
             .WithMaxRows(3)
             .WithCollapsibleSections(true)
-            .WithCreateHref($"/{hubPath}/{CreateNodeArea}?type=Markdown&namespace={Uri.EscapeDataString(hubPath)}");
+            .WithCreateHref($"/{hubPath}/{CreateNodeArea}?namespace={Uri.EscapeDataString(hubPath)}");
     }
 
     /// <summary>
diff --git a/src/MeshWeaver.Graph/PinLayoutArea.cs b/src/MeshWeaver.Graph/PinLayoutArea.cs
new file mode 100644
index 000000000..97ad32a0d
--- /dev/null
+++ b/src/MeshWeaver.Graph/PinLayoutArea.cs
@@ -0,0 +1,178 @@
+using System.Collections.Immutable;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using MeshWeaver.Application.Styles;
+using MeshWeaver.Data;
+using MeshWeaver.Layout;
+using MeshWeaver.Layout.Composition;
+using MeshWeaver.Layout.Domain;
+using MeshWeaver.Mesh;
+using MeshWeaver.Mesh.Security;
+using MeshWeaver.Messaging;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace MeshWeaver.Graph;
+
+/// <summary>
+/// Pin / Unpin actions for a node, plus a <c>PinnedThumbnail</c> renderer that shows a
+/// node as a compact card with an overlay unpin icon.
+/// Pin state lives in <see cref="User.PinnedPaths"/> on the current user's MeshNode.
+/// </summary>
+public static class PinLayoutArea
+{
+    /// <summary>Area name for the Pin action (adds this node's path to the viewer's pinned list).</summary>
+    public const string PinArea = "Pin";
+
+    /// <summary>Area name for the Unpin action (removes this node's path from the viewer's pinned list).</summary>
+    public const string UnpinArea = "Unpin";
+
+    /// <summary>Area name for the compact pinned-card renderer (used as MeshSearch ItemArea).</summary>
+    public const string PinnedThumbnailArea = "PinnedThumbnail";
+
+    /// <summary>
+    /// Returns the Pin menu item. Always yields — pinning is idempotent.
+    /// Hidden on the viewer's own User node (pinning your own profile is pointless).
+    /// </summary>
+    public static NodeMenuItemDefinition? GetMenuItem(string hubPath, string? viewerId)
+    {
+        if (string.IsNullOrEmpty(viewerId))
+            return null;
+        if (hubPath.Equals($"User/{viewerId}", StringComparison.OrdinalIgnoreCase))
+            return null;
+        return new("Pin", PinArea,
+            Icon: "Bookmark",
+            Order: 50,
+            Href: MeshNodeLayoutAreas.BuildUrl(hubPath, PinArea));
+    }
+
+    /// <summary>
+    /// Pin layout area — performs an idempotent add of the current node's path to the
+    /// viewer's <see cref="User.PinnedPaths"/>, then renders a confirmation with a back link.
+    /// </summary>
+    [Browsable(false)]
+    public static IObservable<UiControl?> Pin(LayoutAreaHost host, RenderingContext _)
+        => TogglePinAndRender(host, unpin: false);
+
+    /// <summary>
+    /// Unpin layout area — removes the current node's path from the viewer's pinned list.
+    /// Used by the unpin icon on pinned cards via a Href link, and by the Unpin menu item.
+    /// </summary>
+    [Browsable(false)]
+    public static IObservable<UiControl?> Unpin(LayoutAreaHost host, RenderingContext _)
+        => TogglePinAndRender(host, unpin: true);
+
+    /// <summary>
+    /// Compact pinned card: standard node thumbnail with an overlay unpin button.
+    /// Rendered per search result when the enclosing MeshSearch sets
+    /// <see cref="MeshSearchControl.ItemArea"/> to <see cref="PinnedThumbnailArea"/>.
+    /// </summary>
+    [Browsable(false)]
+    public static IObservable<UiControl?> PinnedThumbnail(LayoutAreaHost host, RenderingContext _)
+    {
+        var hubPath = host.Hub.Address.ToString();
+        var accessService = host.Hub.ServiceProvider.GetService<AccessService>();
+        var viewerId = accessService?.Context?.ObjectId
+                       ?? accessService?.CircuitContext?.ObjectId
+                       ?? "";
+
+        return host.StreamView<MeshNode>(
+            (nodes, _) =>
+            {
+                var node = nodes.FirstOrDefault(n => n.Path == hubPath);
+                return BuildPinnedCard(host, node, hubPath, viewerId);
+            },
+            hubPath);
+    }
+
+    private static UiControl BuildPinnedCard(LayoutAreaHost host, MeshNode? node, string hubPath, string viewerId)
+    {
+        var thumbnail = MeshNodeThumbnailControl.FromNode(node, hubPath);
+
+        var stack = Controls.Stack
+            .WithStyle("position: relative; width: 100%; height: 100%;")
+            .WithView(thumbnail);
+
+        if (string.IsNullOrEmpty(viewerId))
+            return stack;
+
+        // Overlay unpin button, top-right corner.
+        // The click handler mutates PinnedPaths on the viewer's User node via workspace.UpdateMeshNode,
+        // which dispatches remotely since the viewer's hub differs from this item's hub.
+        // The viewer's dashboard observes the user stream and re-renders — the card disappears.
+        var userPath = $"User/{viewerId}";
+        var userAddress = new Address(userPath);
+        var unpinButton = Controls.Button("")
+            .WithIconStart(FluentIcons.Dismiss())
+            .WithAppearance(Appearance.Stealth)
+            .WithStyle("position: absolute; top: 4px; right: 4px; z-index: 5; " +
+                       "min-width: 24px; width: 24px; height: 24px; padding: 0; " +
+                       "border-radius: 50%; background: rgba(0,0,0,0.55); color: #fff;")
+            .WithClickAction(ctx =>
+            {
+                ctx.Host.Workspace.UpdateMeshNode<User>(userAddress, userPath, (n, user) =>
+                {
+                    var paths = user.PinnedPaths?.ToImmutableList() ?? ImmutableList<string>.Empty;
+                    var updated = paths.RemoveAll(p =>
+                        string.Equals(p, hubPath, StringComparison.OrdinalIgnoreCase));
+                    return n with { Content = user with { PinnedPaths = updated } };
+                });
+                return Task.CompletedTask;
+            });
+
+        return stack.WithView(unpinButton);
+    }
+
+    private static IObservable<UiControl?> TogglePinAndRender(LayoutAreaHost host, bool unpin)
+    {
+        var hubPath = host.Hub.Address.ToString();
+        var backHref = MeshNodeLayoutAreas.BuildUrl(hubPath, MeshNodeLayoutAreas.OverviewArea);
+        var accessService = host.Hub.ServiceProvider.GetService<AccessService>();
+        var viewerId = accessService?.Context?.ObjectId
+                       ?? accessService?.CircuitContext?.ObjectId;
+
+        if (string.IsNullOrEmpty(viewerId))
+            return Observable.Return<UiControl?>(BuildSimpleMessage(
+                "Sign-in required",
+                "You must be signed in to pin nodes.",
+                backHref));
+
+        var userPath = $"User/{viewerId}";
+        var userAddress = new Address(userPath);
+
+        // Apply the update remotely on the user hub. workspace.UpdateMeshNode<User>
+        // dispatches via GetRemoteStream when the address differs from the current hub.
+        host.Workspace.UpdateMeshNode<User>(userAddress, userPath, (node, user) =>
+        {
+            var paths = user.PinnedPaths?.ToImmutableList() ?? ImmutableList<string>.Empty;
+            var updated = unpin
+                ? paths.RemoveAll(p => string.Equals(p, hubPath, StringComparison.OrdinalIgnoreCase))
+                : (paths.Any(p => string.Equals(p, hubPath, StringComparison.OrdinalIgnoreCase))
+                    ? paths
+                    : paths.Add(hubPath));
+            return node with { Content = user with { PinnedPaths = updated } };
+        });
+
+        var title = unpin ? "Unpinned" : "Pinned";
+        var message = unpin
+            ? $"Removed <code>{System.Net.WebUtility.HtmlEncode(hubPath)}</code> from your pinned items."
+            : $"Added <code>{System.Net.WebUtility.HtmlEncode(hubPath)}</code> to your pinned items.";
+
+        return Observable.Return<UiControl?>(BuildSimpleMessage(title, message, backHref));
+    }
+
+    private static UiControl BuildSimpleMessage(string title, string messageHtml, string backHref)
+        => Controls.Stack
+            .WithWidth("100%")
+            .WithStyle("padding: 24px;")
+            .WithView(Controls.Stack
+                .WithOrientation(Orientation.Horizontal)
+                .WithHorizontalGap(16)
+                .WithStyle("align-items: center; margin-bottom: 16px;")
+                .WithView(Controls.Button("Back")
+                    .WithAppearance(Appearance.Lightweight)
+                    .WithIconStart(FluentIcons.ArrowLeft())
+                    .WithNavigateToHref(backHref))
+                .WithView(Controls.H2(title).WithStyle("margin: 0;")))
+            .WithView(Controls.Html(
+                $"<p style=\"color: var(--neutral-foreground-hint);\">{messageHtml}</p>"));
+}
diff --git a/src/MeshWeaver.Graph/RecycleLayoutArea.cs b/src/MeshWeaver.Graph/RecycleLayoutArea.cs
new file mode 100644
index 000000000..72898f934
--- /dev/null
+++ b/src/MeshWeaver.Graph/RecycleLayoutArea.cs
@@ -0,0 +1,59 @@
+using System.ComponentModel;
+using System.Reactive.Linq;
+using MeshWeaver.Layout;
+using MeshWeaver.Layout.Composition;
+using MeshWeaver.Mesh;
+using MeshWeaver.Mesh.Security;
+using MeshWeaver.Messaging;
+
+namespace MeshWeaver.Graph;
+
+/// <summary>
+/// Layout area for recycling the current node's hub — sends <see cref="DisposeRequest"/>
+/// to the hub address, waits 100ms, and redirects back to Overview. Lets the user clear
+/// a cached / stuck grain (e.g. after fixing a compilation error) without restarting the
+/// whole portal.
+/// </summary>
+public static class RecycleLayoutArea
+{
+    /// <summary>
+    /// Returns the Recycle menu item if the user has Update permission.
+    /// Sort order 90 places it just above Delete (100).
+    /// </summary>
+    public static NodeMenuItemDefinition? GetMenuItem(string hubPath, Permission perms)
+    {
+        if (!perms.HasFlag(Permission.Update))
+            return null;
+        return new("Recycle", MeshNodeLayoutAreas.RecycleArea,
+            RequiredPermission: Permission.Update, Order: 90,
+            Href: MeshNodeLayoutAreas.BuildUrl(hubPath, MeshNodeLayoutAreas.RecycleArea));
+    }
+
+    /// <summary>
+    /// Entry point for the Recycle layout area. Posts DisposeRequest immediately,
+    /// then emits a transient "Recycling…" message followed by a RedirectControl
+    /// back to Overview after 100ms — enough time for the hub to tear down and
+    /// come up fresh on the next request.
+    /// </summary>
+    [Browsable(false)]
+    public static IObservable<UiControl?> Recycle(LayoutAreaHost host, RenderingContext _)
+    {
+        var nodePath = host.Hub.Address.Path;
+        var targetAddress = host.Hub.Address;
+        var overviewHref = MeshNodeLayoutAreas.BuildUrl(nodePath, MeshNodeLayoutAreas.OverviewArea);
+
+        // Fire the dispose synchronously — no await. The hub receives it and shuts
+        // down; the grain's next access will re-initialize (and, in Orleans setups,
+        // a fresh activation compiles with whatever sources the NodeType now lists).
+        host.Hub.Post(new DisposeRequest(), o => o.WithTarget(targetAddress));
+
+        var recyclingMessage = (UiControl?)Controls.Stack
+            .WithStyle("padding: 24px;")
+            .WithView(Controls.Markdown("**Recycling hub…** redirecting in a moment."));
+
+        var redirect = (UiControl?)new RedirectControl(overviewHref);
+
+        return Observable.Return(recyclingMessage)
+            .Concat(Observable.Timer(TimeSpan.FromMilliseconds(100)).Select(_ => redirect));
+    }
+}
diff --git a/src/MeshWeaver.Graph/SettingsLayoutArea.cs b/src/MeshWeaver.Graph/SettingsLayoutArea.cs
index 32e60c62d..9caa369a6 100644
--- a/src/MeshWeaver.Graph/SettingsLayoutArea.cs
+++ b/src/MeshWeaver.Graph/SettingsLayoutArea.cs
@@ -415,6 +415,14 @@ private static UiControl BuildDisplaySection(LayoutAreaHost host, string dataId)
             DataContext = dataPointer
         });
 
+        stack = stack.WithView(new TextAreaControl(new JsonPointerReference("Description"))
+        {
+            Label = "Description",
+            Placeholder = "Long-form description. Seeds AI Name/Id/Icon generation and appears in detail views.",
+            Immediate = true,
+            DataContext = dataPointer
+        }.WithRows(3));
+
         stack = stack.WithView(new TextFieldControl(new JsonPointerReference("Category"))
         {
             Label = "Category",
@@ -477,11 +485,15 @@ private static UiControl BuildIconPicker(LayoutAreaHost host, string metadataDat
         section = section.WithView(new TextFieldControl(new JsonPointerReference("Icon"))
         {
             Label = "Icon Path",
-            Placeholder = "e.g., /static/collection/icon.svg",
+            Placeholder = "e.g., /static/collection/icon.svg, or an inline data:image/svg+xml URI",
             Immediate = true,
             DataContext = LayoutAreaReference.GetDataPointer(metadataDataId)
         });
 
+        section = section.WithView(Controls.Body(
+            "Upload an image via the file browser above, paste a URL, or paste an inline SVG as a data: URI (e.g. data:image/svg+xml;utf8,<svg…/>).")
+            .WithStyle("color: var(--neutral-foreground-hint); font-size: 12px; margin-top: 4px;"));
+
         return section;
     }
 
@@ -518,9 +530,10 @@ private static void SetupNodeMetadataAutoSave(
 
                     var updatedNode = updatedMeta.ApplyTo(node);
 
-                    host.Hub.Post(
-                        new DataChangeRequest { ChangedBy = host.Stream.ClientId }.WithUpdates(updatedNode),
-                        o => o.WithTarget(host.Hub.Address));
+                    // Use UpdateNodeRequest (the routed MeshNode write path) instead of
+                    // DataChangeRequest — MeshNode has no data-source key mapping and
+                    // DataChangeRequest fails with "No key mapping is defined for type MeshNode".
+                    host.Hub.Post(new UpdateNodeRequest(updatedNode));
                 }));
     }
 
@@ -565,6 +578,8 @@ public record MeshNodeMetadata
 
     public string? Name { get; init; }
 
+    public string? Description { get; init; }
+
     [Editable(false)]
     public string? Namespace { get; init; }
 
@@ -593,6 +608,7 @@ public record MeshNodeMetadata
     {
         Id = node.Id,
         Name = node.Name,
+        Description = node.Description,
         Namespace = node.Namespace,
         NodeType = node.NodeType,
         Category = node.Category,
@@ -607,6 +623,7 @@ public record MeshNodeMetadata
     public MeshNode ApplyTo(MeshNode node) => node with
     {
         Name = Name,
+        Description = Description,
         Category = Category,
         Icon = Icon,
         Order = Order,
diff --git a/src/MeshWeaver.Graph/UserActivityLayoutAreas.cs b/src/MeshWeaver.Graph/UserActivityLayoutAreas.cs
index a4eec8e4d..4cfa7cee8 100644
--- a/src/MeshWeaver.Graph/UserActivityLayoutAreas.cs
+++ b/src/MeshWeaver.Graph/UserActivityLayoutAreas.cs
@@ -50,17 +50,17 @@ public static MessageHubConfiguration AddUserActivityLayoutAreas(this MessageHub
             var isOwner = string.Equals(viewerId, nodeOwnerId, StringComparison.OrdinalIgnoreCase);
 
             if (isOwner)
-                return (UiControl?)BuildOwnerDashboard(host, nodePath, ownerName, nodeOwnerId);
+                return (UiControl?)BuildOwnerDashboard(host, nodePath, ownerName, nodeOwnerId, ownerNode);
             else
                 return (UiControl?)BuildVisitorProfile(nodePath, ownerName, ownerNode);
         });
     }
 
     /// <summary>
-    /// Personal dashboard shown to the node owner — welcome banner, chat, threads,
-    /// activity feed, recently viewed, and child items.
+    /// Personal dashboard shown to the node owner — welcome banner, pinned items, threads,
+    /// child items, activity feed, recently viewed, and the chat input pinned to the bottom.
     /// </summary>
-    private static UiControl BuildOwnerDashboard(LayoutAreaHost host, string nodePath, string ownerName, string nodeOwnerId)
+    private static UiControl BuildOwnerDashboard(LayoutAreaHost host, string nodePath, string ownerName, string nodeOwnerId, MeshNode? ownerNode)
     {
         // Outer shell: flex column, fills the available main area (height managed by CSS grid)
         var dashboard = Controls.Stack
@@ -75,18 +75,20 @@ private static UiControl BuildOwnerDashboard(LayoutAreaHost host, string nodePat
             $"<div style=\"font-size: 0.85rem; color: var(--neutral-foreground-hint); margin-top: 2px;\">Here's what's happening across your workspace</div>" +
             "</div>"));
 
-        // Chat — full width
-        dashboard = dashboard.WithView(BuildChatSection(host, nodePath));
-
         // Scrollable content area — full-width layout grid
         var content = Controls.LayoutGrid
             .WithStyle("padding: 0 24px; flex: 1; min-height: 0; overflow-y: auto; gap: 24px; width: 100%; " + ThinScrollbar);
 
-        // Latest Threads — full width, above My Items
+        // Pinned items — compact, first section
+        var pinnedSection = BuildPinnedItems(ownerNode);
+        if (pinnedSection != null)
+            content = content.WithView(pinnedSection, skin => skin.WithXs(12));
+
+        // Latest Threads — full width
         content = content.WithView(BuildLatestThreads(nodePath, nodeOwnerId),
             skin => skin.WithXs(12));
 
-        // My Items — full width, below Latest Threads
+        // My Items — full width
         content = content.WithView(BuildChildren(nodePath),
             skin => skin.WithXs(12));
 
@@ -102,6 +104,9 @@ private static UiControl BuildOwnerDashboard(LayoutAreaHost host, string nodePat
 
         dashboard = dashboard.WithView(content);
 
+        // Chat input — pinned to the bottom of the dashboard column
+        dashboard = dashboard.WithView(BuildChatSection(host, nodePath));
+
         return dashboard;
     }
 
@@ -194,18 +199,12 @@ private static UiControl BuildChatSection(LayoutAreaHost host, string nodePath)
     }
 
     /// <summary>
-    /// Activity timeline — shows main content nodes with recent changes, plus a pinned docs card.
+    /// Activity timeline — shows main content nodes with recent changes.
     /// source:activity JOINs with Activity satellites and orders by most recent activity.
     /// </summary>
     private static UiControl BuildActivityFeed()
     {
-        var section = Controls.Stack;
-
-        // Pinned documentation card
-        section = section.WithView(BuildDocumentationCard());
-
-        // Activity feed
-        section = section.WithView(Controls.MeshSearch
+        return Controls.MeshSearch
             .WithTitle("Activity Feed")
             .WithHiddenQuery("source:activity scope:subtree is:main sort:LastModified-desc")
             .WithShowSearchBox(false)
@@ -215,46 +214,34 @@ private static UiControl BuildActivityFeed()
             .WithMaxColumns(2)
             .WithItemLimit(50)
             .WithMaxRows(4)
-            .WithReactiveMode(true));
-
-        return section;
+            .WithReactiveMode(true);
     }
 
     /// <summary>
-    /// Pinned welcome card linking to the documentation — styled like a social feed post.
+    /// Pinned items — compact cards of everything in the owner's <see cref="User.PinnedPaths"/>.
+    /// Each card is rendered via <see cref="PinLayoutArea.PinnedThumbnailArea"/>, which overlays
+    /// an unpin icon so owners can remove items inline. Returns <c>null</c> when nothing is pinned.
     /// </summary>
-    private static UiControl BuildDocumentationCard()
+    private static UiControl? BuildPinnedItems(MeshNode? ownerNode)
     {
-        return Controls.Html(
-            "<a href=\"/Doc\" style=\"text-decoration: none; color: inherit; display: block;\">" +
-            "<div style=\"display: flex; gap: 14px; padding: 14px 16px; border-radius: 12px; " +
-            "background: var(--neutral-layer-2); border-left: 3px solid var(--accent-fill-rest); " +
-            "transition: transform 0.15s ease, box-shadow 0.15s ease;\" " +
-            "onmouseenter=\"this.style.transform='translateY(-1px)'; this.style.boxShadow='0 4px 16px rgba(0,0,0,0.12)'\" " +
-            "onmouseleave=\"this.style.transform='none'; this.style.boxShadow='none'\">" +
-
-            // Logo avatar
-            "<div style=\"flex-shrink: 0; width: 40px; height: 40px; border-radius: 50%; " +
-            "background: var(--neutral-layer-3); " +
-            "display: flex; align-items: center; justify-content: center;\">" +
-            "<img src=\"/static/storage/content/MeshWeaver/logo.svg\" alt=\"\" style=\"width: 24px; height: 24px;\" />" +
-            "</div>" +
-
-            // Content
-            "<div style=\"flex: 1; min-width: 0;\">" +
-            "<div style=\"display: flex; align-items: center; gap: 8px;\">" +
-            "<span style=\"font-weight: 600; font-size: 0.9rem;\">MeshWeaver</span>" +
-            "<span style=\"font-size: 0.7rem; padding: 2px 8px; border-radius: 10px; " +
-            "background: rgba(100,100,100,0.12); color: var(--accent-fill-rest); font-weight: 500;\">Pinned</span>" +
-            "</div>" +
-            "<div style=\"font-size: 0.9rem; margin-top: 6px; line-height: 1.5;\">" +
-            "Explore the documentation, try the use cases, or just <strong>open the chat below</strong> and ask anything.</div>" +
-            "<div style=\"display: inline-flex; align-items: center; gap: 4px; " +
-            "margin-top: 8px; padding: 4px 12px; border-radius: 6px; " +
-            "background: var(--neutral-layer-3); " +
-            "color: var(--accent-foreground-rest); font-size: 0.8rem; font-weight: 500;\">" +
-            "&#8594; Documentation</div>" +
-            "</div></div></a>");
+        var pinnedPaths = (ownerNode?.Content as User)?.PinnedPaths;
+        if (pinnedPaths == null || pinnedPaths.Count == 0)
+            return null;
+
+        var pathsClause = string.Join(" OR ", pinnedPaths);
+        return Controls.MeshSearch
+            .WithTitle("Pinned")
+            .WithHiddenQuery($"path:({pathsClause}) sort:LastModified-desc")
+            .WithShowSearchBox(false)
+            .WithShowEmptyMessage(false)
+            .WithRenderMode(MeshSearchRenderMode.Flat)
+            .WithCollapsibleSections(false)
+            .WithSectionCounts(false)
+            .WithItemArea(PinLayoutArea.PinnedThumbnailArea)
+            .WithMaxColumns(6)
+            .WithItemLimit(24)
+            .WithMaxRows(1)
+            .WithReactiveMode(true);
     }
 
     /// <summary>
diff --git a/src/MeshWeaver.Graph/VersionLayoutArea.cs b/src/MeshWeaver.Graph/VersionLayoutArea.cs
index 193504669..50cb969a9 100644
--- a/src/MeshWeaver.Graph/VersionLayoutArea.cs
+++ b/src/MeshWeaver.Graph/VersionLayoutArea.cs
@@ -102,21 +102,18 @@ public static class VersionLayoutArea
     }
 
     /// <summary>
-    /// Renders the diff view comparing a historical version to the current version.
-    /// Reads ?version= query parameter to determine which version to compare.
+    /// Renders the diff view for a node. Supports two modes:
+    ///   <list type="bullet">
+    ///     <item><c>?from=X&amp;to=Y</c> — compare two historical versions.</item>
+    ///     <item><c>?version=X</c> — compare a historical version to the current node.</item>
+    ///   </list>
+    /// Emits the diff once — the Monaco diff editor is expensive to re-create, so we
+    /// avoid re-emitting on every node-stream tick.
     /// </summary>
     [Browsable(false)]
     public static IObservable<UiControl?> VersionDiff(LayoutAreaHost host, RenderingContext _)
     {
         var hubPath = host.Hub.Address.ToString();
-        var versionStr = host.GetQueryStringParamValue("version");
-
-        if (!long.TryParse(versionStr, out var targetVersion))
-        {
-            return Observable.Return<UiControl?>(
-                Controls.Html("<p>Invalid version parameter.</p>"));
-        }
-
         var versionQuery = host.Hub.ServiceProvider.GetService<IVersionQuery>();
         if (versionQuery == null)
         {
@@ -124,67 +121,110 @@ public static class VersionLayoutArea
                 Controls.Html("<p>Version history is not available.</p>"));
         }
 
-        var nodeStream = host.Workspace.GetStream<MeshNode>()
-            ?.Select(nodes => nodes ?? Array.Empty<MeshNode>())
-            ?? Observable.Return(Array.Empty<MeshNode>());
+        var options = host.Hub.JsonSerializerOptions;
+        var fromStr = host.GetQueryStringParamValue("from");
+        var toStr = host.GetQueryStringParamValue("to");
 
-        return nodeStream.SelectMany(async nodes =>
+        // Mode 1: from=X&to=Y — compare two historical versions.
+        if (long.TryParse(fromStr, out var fromVersion) && long.TryParse(toStr, out var toVersion))
         {
-            var currentNode = nodes.FirstOrDefault(n => n.Path == hubPath);
-            var options = host.Hub.JsonSerializerOptions;
-            var historicalNode = await versionQuery.GetVersionAsync(hubPath, targetVersion, options);
-
-            if (historicalNode == null)
+            return Observable.FromAsync(async () =>
             {
-                return (UiControl?)Controls.Html($"<p>Version {targetVersion} not found.</p>");
-            }
-
-            var stack = Controls.Stack.WithWidth("100%").WithStyle(MeshNodeLayoutAreas.GetContainerStyle(host));
-
-            // Back button
-            var backHref = MeshNodeLayoutAreas.BuildUrl(hubPath, MeshNodeLayoutAreas.VersionsArea);
-            stack = stack.WithView(
-                Controls.Stack.WithOrientation(Orientation.Horizontal)
-                    .WithStyle("align-items: center; gap: 8px; margin-bottom: 16px;")
-                    .WithView(Controls.Button("Back to Versions")
-                        .WithAppearance(Appearance.Lightweight)
-                        .WithIconStart(FluentIcons.ArrowLeft())
-                        .WithNavigateToHref(backHref)));
+                var fromNode = await versionQuery.GetVersionAsync(hubPath, fromVersion, options);
+                var toNode = await versionQuery.GetVersionAsync(hubPath, toVersion, options);
+                if (fromNode == null)
+                    return (UiControl?)Controls.Html($"<p>Version {fromVersion} not found.</p>");
+                if (toNode == null)
+                    return (UiControl?)Controls.Html($"<p>Version {toVersion} not found.</p>");
+
+                return (UiControl?)BuildDiffStack(host, hubPath, fromNode, toNode, options,
+                    $"Version {fromVersion}", $"Version {toVersion}",
+                    $"Comparing Version {fromVersion} to Version {toVersion}",
+                    restoreVersion: fromVersion);
+            });
+        }
 
-            stack = stack.WithView(Controls.Html(
-                $"<h2 style=\"margin: 0 0 16px 0;\">Comparing Version {targetVersion} to Current</h2>"));
+        // Mode 2: version=X — compare historical version to current.
+        var versionStr = host.GetQueryStringParamValue("version");
+        if (!long.TryParse(versionStr, out var targetVersion))
+        {
+            return Observable.Return<UiControl?>(
+                Controls.Html("<p>Invalid version parameter. Use <code>?version=X</code> or <code>?from=X&to=Y</code>.</p>"));
+        }
 
-            // Determine content type and extract text for diff
-            var originalContent = ExtractDiffContent(historicalNode, options);
-            var modifiedContent = ExtractDiffContent(currentNode, options);
-            var language = IsMarkdownContent(historicalNode) ? "markdown" : "json";
+        var nodeStream = host.Workspace.GetStream<MeshNode>()
+            ?.Select(nodes => nodes ?? Array.Empty<MeshNode>())
+            ?? Observable.Return(Array.Empty<MeshNode>());
 
-            var diffControl = new DiffEditorControl
+        // Take the first emission that actually contains the node — avoid re-creating
+        // the Monaco diff editor on every subsequent stream tick.
+        return nodeStream
+            .Where(nodes => nodes.Any(n => n.Path == hubPath))
+            .Take(1)
+            .SelectMany(async nodes =>
             {
-                OriginalContent = originalContent,
-                ModifiedContent = modifiedContent,
-                OriginalLabel = $"Version {targetVersion}",
-                ModifiedLabel = "Current",
-                Language = language,
-                Height = "500px"
-            };
+                var currentNode = nodes.First(n => n.Path == hubPath);
+                var historicalNode = await versionQuery.GetVersionAsync(hubPath, targetVersion, options);
 
-            stack = stack.WithView(diffControl);
+                if (historicalNode == null)
+                    return (UiControl?)Controls.Html($"<p>Version {targetVersion} not found.</p>");
 
-            // Restore button
-            stack = stack.WithView(
-                Controls.Stack.WithStyle("margin-top: 16px;")
-                    .WithView(Controls.Button($"Restore Version {targetVersion}")
-                        .WithAppearance(Appearance.Accent)
-                        .WithIconStart(FluentIcons.ArrowUndo())
-                        .WithClickAction(ctx =>
-                        {
-                            ctx.Hub.Post(new RollbackNodeRequest(hubPath, targetVersion));
-                            return Task.CompletedTask;
-                        })));
+                return (UiControl?)BuildDiffStack(host, hubPath, historicalNode, currentNode, options,
+                    $"Version {targetVersion}", "Current",
+                    $"Comparing Version {targetVersion} to Current",
+                    restoreVersion: targetVersion);
+            });
+    }
 
-            return (UiControl?)stack;
+    private static UiControl BuildDiffStack(
+        LayoutAreaHost host, string hubPath,
+        MeshNode originalNode, MeshNode modifiedNode,
+        JsonSerializerOptions options,
+        string originalLabel, string modifiedLabel,
+        string title, long restoreVersion)
+    {
+        var stack = Controls.Stack.WithWidth("100%").WithStyle(MeshNodeLayoutAreas.GetContainerStyle(host));
+
+        var backHref = MeshNodeLayoutAreas.BuildUrl(hubPath, MeshNodeLayoutAreas.VersionsArea);
+        stack = stack.WithView(
+            Controls.Stack.WithOrientation(Orientation.Horizontal)
+                .WithStyle("align-items: center; gap: 8px; margin-bottom: 16px;")
+                .WithView(Controls.Button("Back to Versions")
+                    .WithAppearance(Appearance.Lightweight)
+                    .WithIconStart(FluentIcons.ArrowLeft())
+                    .WithNavigateToHref(backHref)));
+
+        stack = stack.WithView(Controls.Html(
+            $"<h2 style=\"margin: 0 0 16px 0;\">{System.Web.HttpUtility.HtmlEncode(title)}</h2>"));
+
+        var originalContent = ExtractDiffContent(originalNode, options);
+        var modifiedContent = ExtractDiffContent(modifiedNode, options);
+        var language = IsMarkdownContent(originalNode) || IsMarkdownContent(modifiedNode)
+            ? "markdown"
+            : "json";
+
+        stack = stack.WithView(new DiffEditorControl
+        {
+            OriginalContent = originalContent,
+            ModifiedContent = modifiedContent,
+            OriginalLabel = originalLabel,
+            ModifiedLabel = modifiedLabel,
+            Language = language,
+            Height = "600px"
         });
+
+        stack = stack.WithView(
+            Controls.Stack.WithStyle("margin-top: 16px;")
+                .WithView(Controls.Button($"Restore Version {restoreVersion}")
+                    .WithAppearance(Appearance.Accent)
+                    .WithIconStart(FluentIcons.ArrowUndo())
+                    .WithClickAction(ctx =>
+                    {
+                        ctx.Hub.Post(new RollbackNodeRequest(hubPath, restoreVersion));
+                        return Task.CompletedTask;
+                    })));
+
+        return stack;
     }
 
     /// <summary>
diff --git a/src/MeshWeaver.Hosting.Blazor/NavigationService.cs b/src/MeshWeaver.Hosting.Blazor/NavigationService.cs
index 480a3af25..29e016a1d 100644
--- a/src/MeshWeaver.Hosting.Blazor/NavigationService.cs
+++ b/src/MeshWeaver.Hosting.Blazor/NavigationService.cs
@@ -191,7 +191,10 @@ private async Task ProcessResolvedPathAsync(string path, AddressResolution resol
         };
 
         _context = context;
-        CurrentNamespace = context.Namespace;
+        // On satellite pages (thread/comment/activity), CurrentNamespace points at the
+        // main node — callers that resolve relative paths, autocomplete, attachments,
+        // and chat context all need the primary node, not the `_Thread/...` sub-address.
+        CurrentNamespace = context.PrimaryPath;
 
         // Track navigation activity for "Recently Viewed"
         if (node != null)
@@ -200,7 +203,7 @@ private async Task ProcessResolvedPathAsync(string path, AddressResolution resol
         OnNavigationContextChanged?.Invoke(context);
 
         // Load creatable types in background when namespace changes
-        var currentNodePath = context.Namespace ?? "";
+        var currentNodePath = context.PrimaryPath ?? "";
         if (currentNodePath != _lastLoadedNodePath)
         {
             _ = LoadCreatableTypesAsync(currentNodePath);
diff --git a/src/MeshWeaver.Hosting/Activity/ActivityTrackingExtensions.cs b/src/MeshWeaver.Hosting/Activity/ActivityTrackingExtensions.cs
index 30978319a..a5c9046c6 100644
--- a/src/MeshWeaver.Hosting/Activity/ActivityTrackingExtensions.cs
+++ b/src/MeshWeaver.Hosting/Activity/ActivityTrackingExtensions.cs
@@ -4,6 +4,7 @@
 using MeshWeaver.Mesh.Services;
 using MeshWeaver.Messaging;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace MeshWeaver.Hosting.Activity;
 
@@ -53,7 +54,11 @@ public static MeshBuilder AddActivityTracking(this MeshBuilder builder)
                         State = MeshNodeState.Active,
                         Content = log
                     };
-                    await persistence.SaveNodeAsync(node);
+                    persistence.SaveNode(node).Subscribe(
+                        _ => { },
+                        ex => hub.ServiceProvider.GetService<ILoggerFactory>()
+                            ?.CreateLogger("ActivityLogBundler")
+                            ?.LogWarning(ex, "Failed to persist activity log for {Path}", node.Path));
                 });
             });
             return services;
diff --git a/src/MeshWeaver.Hosting/HubNodePersistence.cs b/src/MeshWeaver.Hosting/HubNodePersistence.cs
index 20647dbb2..bffe95c92 100644
--- a/src/MeshWeaver.Hosting/HubNodePersistence.cs
+++ b/src/MeshWeaver.Hosting/HubNodePersistence.cs
@@ -147,5 +147,5 @@ public IObservable<bool> DeleteNode(string path)
     }
 
     public IObservable<MeshNode> CreateTransient(MeshNode node)
-        => Observable.FromAsync(() => catalog.CreateTransientNodeAsync(node));
+        => catalog.CreateTransientNode(node);
 }
diff --git a/src/MeshWeaver.Hosting/MeshCatalog.cs b/src/MeshWeaver.Hosting/MeshCatalog.cs
index e8f47b55e..c5c221fd8 100644
--- a/src/MeshWeaver.Hosting/MeshCatalog.cs
+++ b/src/MeshWeaver.Hosting/MeshCatalog.cs
@@ -1,4 +1,5 @@
-using MeshWeaver.Hosting.Persistence.Query;
+using System.Reactive.Linq;
+using MeshWeaver.Hosting.Persistence.Query;
 using MeshWeaver.Mesh;
 using MeshWeaver.Mesh.Security;
 using MeshWeaver.Mesh.Services;
@@ -64,9 +65,6 @@ internal sealed class MeshCatalog(
         return persistenceNode;
     }
 
-    public Task UpdateAsync(MeshNode node) =>
-        Persistence.SaveNodeAsync(node);
-
     // IMeshCatalog — delegate to HubNodePersistence
     private HubNodePersistence NodePersistence => new(hub, this);
 
@@ -79,16 +77,18 @@ public Task<MeshNode> CreateTransientAsync(MeshNode node, CancellationToken ct =
 
     /// <summary>
     /// Creates a new node in Transient state without confirming it.
-    /// This is internal - used by handlers that need direct node creation after validation.
+    /// Returns an observable emitting the saved node, or OnError on failure.
+    /// Subscribe to drive — do not await.
     /// </summary>
-    internal async Task<MeshNode> CreateTransientNodeAsync(MeshNode node, CancellationToken ct = default)
+    internal IObservable<MeshNode> CreateTransientNode(MeshNode node)
     {
-        // Validate NodeType is registered (in-memory check only — no DB round-trip)
         if (!string.IsNullOrEmpty(node.NodeType) && !Configuration.Nodes.ContainsKey(node.NodeType))
-            throw new InvalidOperationException($"NodeType '{node.NodeType}' is not registered");
+            return Observable.Throw<MeshNode>(
+                new InvalidOperationException($"NodeType '{node.NodeType}' is not registered"));
 
         if (!ValidatePath(node))
-            throw new InvalidOperationException($"Invalid path structure for node: {node.Path}");
+            return Observable.Throw<MeshNode>(
+                new InvalidOperationException($"Invalid path structure for node: {node.Path}"));
 
         var transientNode = node with { State = MeshNodeState.Transient };
 
@@ -101,53 +101,13 @@ internal async Task<MeshNode> CreateTransientNodeAsync(MeshNode node, Cancellati
             transientNode = transientNode with { MainNode = transientNode.Namespace };
         }
 
-        if (ConfigResolver != null)
-            transientNode = await ConfigResolver.ResolveConfigurationAsync(transientNode, ct);
-
-        // Storage is the source of truth — no preflight ExistsAsync. If it conflicts, storage will throw.
-        var savedNode = await Persistence.SaveNodeAsync(transientNode, ct);
-        logger?.LogInformation("Created transient node at path {Path}", savedNode.Path);
-        return savedNode;
-    }
-
-    /// <summary>
-    /// Confirms a transient node, updating its state to Active.
-    /// This is internal - used by handlers after validation.
-    /// </summary>
-    internal async Task<MeshNode> ConfirmNodeAsync(string path, CancellationToken ct = default)
-    {
-        // Get the current node
-        var node = await Persistence.GetNodeAsync(path, ct);
-        if (node == null)
-        {
-            throw new InvalidOperationException($"Node not found at path: {path}");
-        }
+        var resolvedObs = ConfigResolver != null
+            ? Observable.FromAsync(ct => ConfigResolver.ResolveConfigurationAsync(transientNode, ct))
+            : Observable.Return(transientNode);
 
-        if (node.State != MeshNodeState.Transient)
-        {
-            throw new InvalidOperationException($"Node at path '{path}' is not in Transient state (current state: {node.State})");
-        }
-
-        // Update to Confirmed state
-        var confirmedNode = node with { State = MeshNodeState.Active };
-        await Persistence.SaveNodeAsync(confirmedNode, ct);
-
-        // Enrich with HubConfiguration based on NodeType (same as cold start in GetNodeAsync)
-        if (ConfigResolver != null)
-            confirmedNode = await ConfigResolver.ResolveConfigurationAsync(confirmedNode, ct);
-
-        logger?.LogInformation("Confirmed node at path {Path}", confirmedNode.Path);
-        return confirmedNode;
-    }
-
-    /// <summary>
-    /// IMeshCatalog.DeleteNodeAsync — internal, called by the DeleteNodeRequest handler.
-    /// Deletes directly from persistence. Storage cascade handles descendants.
-    /// </summary>
-    async Task IMeshCatalog.DeleteNodeAsync(string path, bool recursive, CancellationToken ct)
-    {
-        await Persistence.DeleteNodeAsync(path, recursive, ct);
-        logger?.LogInformation("Deleted node at path {Path}, recursive: {Recursive}", path, recursive);
+        return resolvedObs
+            .SelectMany(resolved => Persistence.SaveNode(resolved))
+            .Do(saved => logger?.LogInformation("Created transient node at path {Path}", saved.Path));
     }
 
     private static bool ValidatePath(MeshNode node)
diff --git a/src/MeshWeaver.Hosting/MeshService.cs b/src/MeshWeaver.Hosting/MeshService.cs
index a05bde9f8..323fba175 100644
--- a/src/MeshWeaver.Hosting/MeshService.cs
+++ b/src/MeshWeaver.Hosting/MeshService.cs
@@ -153,13 +153,10 @@ public IObservable<MeshNode> CreateTransient(MeshNode node)
         if (persistence == null)
             return CreateNode(node);
 
-        return Observable.FromAsync(async ct =>
-        {
-            // Persist directly with Transient state — bypasses the CreateNodeRequest handler
-            // which would force Active state.
-            var transientNode = node with { State = MeshNodeState.Transient };
-            return await persistence.SaveNodeAsync(transientNode, ct);
-        });
+        // Persist directly with Transient state — bypasses the CreateNodeRequest handler
+        // which would force Active state.
+        var transientNode = node with { State = MeshNodeState.Transient };
+        return persistence.SaveNode(transientNode);
     }
 
     // === Query (delegated to MeshQuery) ===
diff --git a/src/MeshWeaver.Hosting/Persistence/PersistenceService.cs b/src/MeshWeaver.Hosting/Persistence/PersistenceService.cs
index 76f6d1bc5..7599603f2 100644
--- a/src/MeshWeaver.Hosting/Persistence/PersistenceService.cs
+++ b/src/MeshWeaver.Hosting/Persistence/PersistenceService.cs
@@ -1,3 +1,4 @@
+using System.Reactive.Linq;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
 using MeshWeaver.Mesh;
@@ -36,14 +37,18 @@ public IAsyncEnumerable<MeshNode> GetChildrenAsync(string? parentPath)
     public IAsyncEnumerable<MeshNode> GetDescendantsAsync(string? parentPath)
         => core.GetDescendantsAsync(parentPath, Options);
 
-    public Task<MeshNode> SaveNodeAsync(MeshNode node, CancellationToken ct = default)
-        => core.SaveNodeAsync(node, Options, ct);
+    public IAsyncEnumerable<MeshNode> GetAllDescendantsAsync(string? parentPath)
+        => core.GetAllDescendantsAsync(parentPath, Options);
 
-    public Task DeleteNodeAsync(string path, bool recursive = false, CancellationToken ct = default)
-        => core.DeleteNodeAsync(path, recursive, ct);
+    public IObservable<MeshNode> SaveNode(MeshNode node)
+        => Observable.FromAsync(ct => core.SaveNodeAsync(node, Options, ct));
 
-    public Task<MeshNode> MoveNodeAsync(string sourcePath, string targetPath, CancellationToken ct = default)
-        => core.MoveNodeAsync(sourcePath, targetPath, Options, ct);
+    public IObservable<string> DeleteNode(string path, bool recursive = false)
+        => Observable.FromAsync(ct => core.DeleteNodeAsync(path, recursive, ct))
+            .Select(_ => path);
+
+    public IObservable<MeshNode> MoveNode(string sourcePath, string targetPath)
+        => Observable.FromAsync(ct => core.MoveNodeAsync(sourcePath, targetPath, Options, ct));
 
     public IAsyncEnumerable<MeshNode> SearchAsync(string? parentPath, string query)
         => core.SearchAsync(parentPath, query, Options);
@@ -63,11 +68,12 @@ public Task InitializeAsync(CancellationToken ct = default)
     public IAsyncEnumerable<Comment> GetCommentsAsync(string nodePath)
         => core.GetCommentsAsync(nodePath, Options);
 
-    public Task<Comment> AddCommentAsync(Comment comment, CancellationToken ct = default)
-        => core.AddCommentAsync(comment, Options, ct);
+    public IObservable<Comment> AddComment(Comment comment)
+        => Observable.FromAsync(ct => core.AddCommentAsync(comment, Options, ct));
 
-    public Task DeleteCommentAsync(string commentId, CancellationToken ct = default)
-        => core.DeleteCommentAsync(commentId, ct);
+    public IObservable<string> DeleteComment(string commentId)
+        => Observable.FromAsync(ct => core.DeleteCommentAsync(commentId, ct))
+            .Select(_ => commentId);
 
     public Task<Comment?> GetCommentAsync(string commentId, CancellationToken ct = default)
         => core.GetCommentAsync(commentId, ct);
@@ -79,11 +85,13 @@ public Task DeleteCommentAsync(string commentId, CancellationToken ct = default)
     public IAsyncEnumerable<object> GetPartitionObjectsAsync(string nodePath, string? subPath)
         => core.GetPartitionObjectsAsync(nodePath, subPath, Options);
 
-    public Task SavePartitionObjectsAsync(string nodePath, string? subPath, IReadOnlyCollection<object> objects, CancellationToken ct = default)
-        => core.SavePartitionObjectsAsync(nodePath, subPath, objects, Options, ct);
+    public IObservable<IReadOnlyCollection<object>> SavePartitionObjects(string nodePath, string? subPath, IReadOnlyCollection<object> objects)
+        => Observable.FromAsync(ct => core.SavePartitionObjectsAsync(nodePath, subPath, objects, Options, ct))
+            .Select(_ => objects);
 
-    public Task DeletePartitionObjectsAsync(string nodePath, string? subPath = null, CancellationToken ct = default)
-        => core.DeletePartitionObjectsAsync(nodePath, subPath, ct);
+    public IObservable<string> DeletePartitionObjects(string nodePath, string? subPath = null)
+        => Observable.FromAsync(ct => core.DeletePartitionObjectsAsync(nodePath, subPath, ct))
+            .Select(_ => subPath ?? nodePath);
 
     public Task<DateTimeOffset?> GetPartitionMaxTimestampAsync(string nodePath, string? subPath = null, CancellationToken ct = default)
         => core.GetPartitionMaxTimestampAsync(nodePath, subPath, ct);
diff --git a/src/MeshWeaver.Layout/Composition/LayoutDefinition.cs b/src/MeshWeaver.Layout/Composition/LayoutDefinition.cs
index 2813065ab..c12b4c3d7 100644
--- a/src/MeshWeaver.Layout/Composition/LayoutDefinition.cs
+++ b/src/MeshWeaver.Layout/Composition/LayoutDefinition.cs
@@ -81,6 +81,22 @@ public async ValueTask<EntityStoreAndUpdates> RenderAsync(
                 "Named renderers: [{Named}], predicate renderers: {Count}",
                 context.Area, host.Hub.Address,
                 string.Join(", ", NamedRenderers.Keys), AsyncRenderers.Count);
+
+            // Surface a visible "area not found" placeholder so the client doesn't spin forever
+            // waiting for an Update that no renderer is going to produce.
+            var availableAreas = NamedRenderers.Keys.OrderBy(k => k).ToArray();
+            var availableLine = availableAreas.Length == 0
+                ? "_no named areas registered on this hub_"
+                : "Available named areas: " + string.Join(", ", availableAreas.Select(a => $"`{a}`"));
+            var notFound = new MarkdownControl(
+                $"**Area not found**\n\nNo renderer is registered for area `{context.Area}` on hub `{host.Hub.Address}`.\n\n{availableLine}");
+            result = result with
+            {
+                Store = result.Store.Update(LayoutAreaReference.Areas,
+                    coll => coll.SetItem(context.Area, notFound)),
+                Updates = result.Updates.Append(
+                    new EntityUpdate(LayoutAreaReference.Areas, context.Area, notFound))
+            };
         }
 
         return result;
diff --git a/src/MeshWeaver.Layout/ThreadMessageBubbleControl.cs b/src/MeshWeaver.Layout/ThreadMessageBubbleControl.cs
index 173145f9f..9d3ddba96 100644
--- a/src/MeshWeaver.Layout/ThreadMessageBubbleControl.cs
+++ b/src/MeshWeaver.Layout/ThreadMessageBubbleControl.cs
@@ -52,6 +52,13 @@ public record ThreadMessageBubbleControl() : UiControl<ThreadMessageBubbleContro
     /// </summary>
     public object? ToolCalls { get; init; }
 
+    /// <summary>
+    /// Data-bound list of nodes created/updated/deleted by this message's execution.
+    /// The bubble cross-references tool-call target paths against this list to show
+    /// inline Diff + Restore links on Create/Update/Delete/Patch tool chips.
+    /// </summary>
+    public object? UpdatedNodes { get; init; }
+
     /// <summary>Model name used for this response (e.g., "claude-sonnet-4-6").</summary>
     public string? ModelName { get; init; }
 
@@ -68,4 +75,5 @@ public record ThreadMessageBubbleControl() : UiControl<ThreadMessageBubbleContro
     public ThreadMessageBubbleControl WithMessageId(string? id) => this with { MessageId = id };
     public ThreadMessageBubbleControl WithThreadPath(string? path) => this with { ThreadPath = path };
     public ThreadMessageBubbleControl WithToolCalls(object? toolCalls) => this with { ToolCalls = toolCalls };
+    public ThreadMessageBubbleControl WithUpdatedNodes(object? updatedNodes) => this with { UpdatedNodes = updatedNodes };
 }
diff --git a/src/MeshWeaver.Markdown/PathUtils.cs b/src/MeshWeaver.Markdown/PathUtils.cs
index fc60be7a6..1c517c0f6 100644
--- a/src/MeshWeaver.Markdown/PathUtils.cs
+++ b/src/MeshWeaver.Markdown/PathUtils.cs
@@ -10,6 +10,9 @@ public static class PathUtils
     /// <summary>
     /// Resolves a relative path against the current node path.
     /// Returns the path unchanged if it's already absolute, external, or an anchor.
+    /// Satellite partitions (path segments starting with '_', e.g., _Thread, _Comment)
+    /// are stripped from the base path so that links in satellite content resolve
+    /// relative to the main entity, not the satellite node itself.
     /// </summary>
     /// <param name="path">The path to resolve (may be relative or absolute)</param>
     /// <param name="currentNodePath">The full path of the current node (e.g., "Doc/Architecture")</param>
@@ -21,8 +24,10 @@ public static string ResolveRelativePath(string path, string? currentNodePath)
         if (string.IsNullOrEmpty(currentNodePath))
             return path;
 
-        // Handle ../ segments (go up to parent)
-        var basePath = currentNodePath;
+        // Strip satellite partitions: segments starting with '_' (e.g., _Thread, _Comment)
+        // and everything after them. Links in satellite content should resolve relative
+        // to the main entity, not the satellite path.
+        var basePath = StripSatellitePartition(currentNodePath);
         while (path.StartsWith("../"))
         {
             var lastSlash = basePath.LastIndexOf('/');
@@ -39,4 +44,20 @@ public static string ResolveRelativePath(string path, string? currentNodePath)
 
         return string.IsNullOrEmpty(basePath) ? path : $"{basePath}/{path}";
     }
+
+    /// <summary>
+    /// Strips the first satellite partition segment (starting with '_') and everything
+    /// after it from a path. E.g., "Org/Project/_Thread/slug/msgId" → "Org/Project".
+    /// Returns the path unchanged if no satellite partition is found.
+    /// </summary>
+    internal static string StripSatellitePartition(string path)
+    {
+        var segments = path.Split('/');
+        for (var i = 0; i < segments.Length; i++)
+        {
+            if (segments[i].StartsWith('_'))
+                return i == 0 ? "" : string.Join('/', segments[..i]);
+        }
+        return path;
+    }
 }
diff --git a/src/MeshWeaver.Mesh.Contract/MeshExtensions.cs b/src/MeshWeaver.Mesh.Contract/MeshExtensions.cs
index 2137054a7..a82259a92 100644
--- a/src/MeshWeaver.Mesh.Contract/MeshExtensions.cs
+++ b/src/MeshWeaver.Mesh.Contract/MeshExtensions.cs
@@ -64,6 +64,17 @@ public static MessageHubConfiguration WithNodeOperationHandlers(this MessageHubC
             .WithHandler<HeartBeatEvent>(HandleHeartBeat);
     }
 
+    /// <summary>
+    /// Registers only the <see cref="HeartBeatEvent"/> handler. Use on hubs that
+    /// should swallow heartbeats silently (e.g. per-node hubs spawned from a
+    /// NodeType's configuration) without pulling in the full node-operation
+    /// handler set. Without this handler the message service logs a warning per
+    /// heartbeat, so targets that receive heartbeats but don't need to keep an
+    /// Orleans grain alive should still register it as a no-op.
+    /// </summary>
+    public static MessageHubConfiguration WithHeartBeatHandler(this MessageHubConfiguration config)
+        => config.WithHandler<HeartBeatEvent>(HandleHeartBeat);
+
     /// <summary>
     /// Handles HeartBeatEvent: signals the Orleans grain to delay deactivation.
     /// Walks up the parent hub chain because GrainKeepAliveCallback is set on the
@@ -164,7 +175,7 @@ private static IMessageDelivery HandleCreateNodeRequest(
                             Content = node.Content ?? existingNode.Content
                         };
                         var saveObs = persistence != null
-                            ? Observable.FromAsync(token => persistence.SaveNodeAsync(confirmedNode, token))
+                            ? persistence.SaveNode(confirmedNode)
                             : Observable.Return(confirmedNode);
                         return saveObs.Select(savedConfirmed => (mode: "confirm", node: savedConfirmed));
                     }
@@ -248,7 +259,7 @@ private static IMessageDelivery HandleCreateNodeRequest(
                             return enrichedObs.SelectMany(enriched =>
                             {
                                 var saveObs = persistence != null
-                                    ? Observable.FromAsync(token => persistence.SaveNodeAsync(enriched, token))
+                                    ? persistence.SaveNode(enriched)
                                     : Observable.Return(enriched);
                                 return saveObs.Select(saved => (mode: "create", node: saved));
                             });
@@ -617,8 +628,7 @@ private static IMessageDelivery HandleDeleteNodeRequest(
                     return handleObs;
 
                 var saveExtras = additional
-                    .Select(extra => Observable.FromAsync(token =>
-                            persistence.SaveNodeAsync(extra with { State = MeshNodeState.Active }, token))
+                    .Select(extra => persistence.SaveNode(extra with { State = MeshNodeState.Active })
                         .Do(saved =>
                         {
                             hub.Post(DataChangeRequest.Update([saved]),
@@ -657,22 +667,32 @@ private static void DeleteSelfFromStorage(
         IMeshStorage persistence,
         ILogger logger)
     {
-        Observable.FromAsync(token => persistence.DeleteNodeAsync(path, recursive: false, token))
+        // Post the response AFTER the storage delete actually commits so callers see a
+        // consistent view: an awaited DeleteNode returns only once the node is gone from
+        // persistence. Without this, race conditions occur — e.g. tests (and UI flows)
+        // that query right after the delete can still observe the pre-delete node.
+        //
+        // The previous "reply first" approach guarded against Orleans/monolith hub
+        // teardown during self-deletion. HandleDeleteNodeRequest runs on the mesh hub,
+        // and a child-node delete does not tear down that hub — so the teardown concern
+        // does not apply here. If a true self-teardown case emerges we post Fail from
+        // OnError and the caller still unblocks.
+        persistence.DeleteNode(path, recursive: false)
             .Subscribe(
                 _ =>
                 {
+                    hub.Post(DeleteNodeResponse.Ok(), o => o.ResponseFor(request));
                     hub.ServiceProvider.GetService<IMeshChangeFeed>()
                         ?.Publish(MeshChangeEvent.Deleted(path));
-                    hub.Post(DeleteNodeResponse.Ok(), o => o.ResponseFor(request));
                     logger.LogInformation(
                         "Node deleted at {Path} by {DeletedBy}",
                         path, capturedRequest.DeletedBy ?? "system");
                 },
                 ex =>
                 {
-                    logger.LogError(ex, "Error deleting node at {Path}", path);
+                    logger.LogError(ex, "Storage delete failed for {Path}", path);
                     hub.Post(
-                        DeleteNodeResponse.Fail($"Unexpected error: {ex.Message}",
+                        DeleteNodeResponse.Fail($"Storage delete failed: {ex.Message}",
                             NodeDeletionRejectionReason.Unknown),
                         o => o.ResponseFor(request));
                 });
@@ -815,7 +835,7 @@ private static IMessageDelivery HandleUpdateNodeRequest(
                             HubConfiguration = existingNode.HubConfiguration
                         };
 
-                        return Observable.FromAsync(token => persistence.SaveNodeAsync(nodeToSave, token));
+                        return persistence.SaveNode(nodeToSave);
                     });
             })
             .Subscribe(
@@ -990,17 +1010,27 @@ private static async Task<IMessageDelivery> HandleMoveNodeRequest(
                 return request.Processed();
             }
 
-            // 4. Move the node
-            var movedNode = await persistence.MoveNodeAsync(moveRequest.SourcePath, moveRequest.TargetPath, ct);
-            var changeFeed = hub.ServiceProvider.GetService<IMeshChangeFeed>();
-            changeFeed?.Publish(MeshChangeEvent.Deleted(moveRequest.SourcePath));
-            changeFeed?.Publish(MeshChangeEvent.Created(movedNode));
-
-            // 5. Return success
-            hub.Post(MoveNodeResponse.Ok(movedNode), o => o.ResponseFor(request));
+            // 4. Move the node — subscribe and post response in the callback.
+            persistence.MoveNode(moveRequest.SourcePath, moveRequest.TargetPath)
+                .Subscribe(
+                    movedNode =>
+                    {
+                        var changeFeed = hub.ServiceProvider.GetService<IMeshChangeFeed>();
+                        changeFeed?.Publish(MeshChangeEvent.Deleted(moveRequest.SourcePath));
+                        changeFeed?.Publish(MeshChangeEvent.Created(movedNode));
+                        hub.Post(MoveNodeResponse.Ok(movedNode), o => o.ResponseFor(request));
+                        logger.LogInformation("Node moved from {Source} to {Target}",
+                            moveRequest.SourcePath, moveRequest.TargetPath);
+                    },
+                    ex =>
+                    {
+                        logger.LogError(ex, "Error moving node from {Source} to {Target}",
+                            moveRequest.SourcePath, moveRequest.TargetPath);
+                        hub.Post(
+                            MoveNodeResponse.Fail($"Unexpected error: {ex.Message}"),
+                            o => o.ResponseFor(request));
+                    });
 
-            logger.LogInformation("Node moved from {Source} to {Target}",
-                moveRequest.SourcePath, moveRequest.TargetPath);
             return request.Processed();
         }
         catch (Exception ex)
diff --git a/src/MeshWeaver.Mesh.Contract/MeshNode.cs b/src/MeshWeaver.Mesh.Contract/MeshNode.cs
index 79a3e2b41..457657154 100644
--- a/src/MeshWeaver.Mesh.Contract/MeshNode.cs
+++ b/src/MeshWeaver.Mesh.Contract/MeshNode.cs
@@ -146,6 +146,12 @@ public static MeshNode FromPath(string path)
     /// </summary>
     public string? Name { get; init; }
 
+    /// <summary>
+    /// Long-form description of this node. Used as the seed prompt for AI-assisted
+    /// Name/Id/Icon generation in the Create dialog, and displayed in detail views.
+    /// </summary>
+    public string? Description { get; init; }
+
     /// <summary>
     /// The type/category of this node (e.g., "Northwind", "Todo", "Insurance").
     /// Used to identify the application type for routing and configuration.
diff --git a/src/MeshWeaver.Mesh.Contract/Security/User.cs b/src/MeshWeaver.Mesh.Contract/Security/User.cs
index 17d94ae69..10716c89e 100644
--- a/src/MeshWeaver.Mesh.Contract/Security/User.cs
+++ b/src/MeshWeaver.Mesh.Contract/Security/User.cs
@@ -17,4 +17,7 @@ public record User : AccessObject
 
     /// <summary>Profile role (e.g. Developer, Manager, Designer).</summary>
     public string? Role { get; init; }
+
+    /// <summary>Ordered list of node paths the user has pinned to their dashboard.</summary>
+    public IReadOnlyList<string> PinnedPaths { get; init; } = [];
 }
diff --git a/src/MeshWeaver.Mesh.Contract/Services/IMeshCatalog.cs b/src/MeshWeaver.Mesh.Contract/Services/IMeshCatalog.cs
index 18fe30cb0..58471e849 100644
--- a/src/MeshWeaver.Mesh.Contract/Services/IMeshCatalog.cs
+++ b/src/MeshWeaver.Mesh.Contract/Services/IMeshCatalog.cs
@@ -43,14 +43,6 @@ internal interface IMeshCatalog : IPathResolver
     /// </summary>
     Task<MeshNode> CreateTransientAsync(MeshNode node, CancellationToken ct = default);
 
-    /// <summary>
-    /// Deletes a node from the catalog.
-    /// </summary>
-    /// <param name="path">The path of the node to delete</param>
-    /// <param name="recursive">If true, also delete all descendant nodes</param>
-    /// <param name="ct">Cancellation token</param>
-    Task DeleteNodeAsync(string path, bool recursive = false, CancellationToken ct = default);
-
     /// <summary>
     /// Resolves a full URL path to an address using score-based matching.
     /// Returns the best matching node's address and the remaining path segments.
diff --git a/src/MeshWeaver.Mesh.Contract/Services/IMeshStorage.cs b/src/MeshWeaver.Mesh.Contract/Services/IMeshStorage.cs
index 7c95cfe1e..4a2fc7d54 100644
--- a/src/MeshWeaver.Mesh.Contract/Services/IMeshStorage.cs
+++ b/src/MeshWeaver.Mesh.Contract/Services/IMeshStorage.cs
@@ -37,20 +37,32 @@ internal interface IMeshStorage
     IAsyncEnumerable<MeshNode> GetDescendantsAsync(string? parentPath);
 
     /// <summary>
-    /// Creates or updates a node.
+    /// Gets ALL descendant nodes including satellites (nodes where
+    /// <c>MainNode != Path</c>). Default implementation delegates to
+    /// <see cref="GetDescendantsAsync"/> which excludes satellites — impls that
+    /// know how to include satellites (e.g. the full persistence service)
+    /// override this.
+    /// </summary>
+    IAsyncEnumerable<MeshNode> GetAllDescendantsAsync(string? parentPath)
+        => GetDescendantsAsync(parentPath);
+
+    /// <summary>
+    /// Creates or updates a node. Returns an observable that emits the saved node on success
+    /// or signals OnError on failure. Subscribe to drive — do not await.
     /// </summary>
     /// <param name="node">The node to save</param>
-    /// <param name="ct">Cancellation token</param>
-    /// <returns>The saved node</returns>
-    Task<MeshNode> SaveNodeAsync(MeshNode node, CancellationToken ct = default);
+    /// <returns>Observable emitting the saved node (OnNext + OnCompleted) or OnError</returns>
+    IObservable<MeshNode> SaveNode(MeshNode node);
 
     /// <summary>
-    /// Deletes a node and optionally its descendants.
+    /// Deletes a node and optionally its descendants. Returns an observable that emits the
+    /// deleted path on success or OnError on failure. Subscribe to drive — do not await.
+    /// Atomic at the storage layer; no pre-read (avoids TOCTOU).
     /// </summary>
     /// <param name="path">The node path</param>
     /// <param name="recursive">If true, also delete all descendants</param>
-    /// <param name="ct">Cancellation token</param>
-    Task DeleteNodeAsync(string path, bool recursive = false, CancellationToken ct = default);
+    /// <returns>Observable emitting the deleted path, or OnError</returns>
+    IObservable<string> DeleteNode(string path, bool recursive = false);
 
     /// <summary>
     /// Moves a node and all its descendants to a new path.
@@ -58,10 +70,9 @@ internal interface IMeshStorage
     /// </summary>
     /// <param name="sourcePath">The current node path</param>
     /// <param name="targetPath">The new node path</param>
-    /// <param name="ct">Cancellation token</param>
-    /// <returns>The moved node at the new path</returns>
+    /// <returns>Observable emitting the moved node at the new path, or OnError</returns>
     /// <exception cref="InvalidOperationException">If source doesn't exist or target already exists</exception>
-    Task<MeshNode> MoveNodeAsync(string sourcePath, string targetPath, CancellationToken ct = default);
+    IObservable<MeshNode> MoveNode(string sourcePath, string targetPath);
 
     /// <summary>
     /// Searches nodes by query text within their Name or Content.
@@ -108,16 +119,15 @@ internal interface IMeshStorage
     /// Adds a comment to a node.
     /// </summary>
     /// <param name="comment">The comment to add</param>
-    /// <param name="ct">Cancellation token</param>
-    /// <returns>The saved comment</returns>
-    Task<Comment> AddCommentAsync(Comment comment, CancellationToken ct = default);
+    /// <returns>Observable emitting the saved comment, or OnError</returns>
+    IObservable<Comment> AddComment(Comment comment);
 
     /// <summary>
     /// Deletes a comment by ID.
     /// </summary>
     /// <param name="commentId">The comment ID to delete</param>
-    /// <param name="ct">Cancellation token</param>
-    Task DeleteCommentAsync(string commentId, CancellationToken ct = default);
+    /// <returns>Observable emitting the deleted comment id on completion, or OnError</returns>
+    IObservable<string> DeleteComment(string commentId);
 
     /// <summary>
     /// Gets a single comment by ID.
@@ -147,16 +157,16 @@ internal interface IMeshStorage
     /// <param name="nodePath">The node path</param>
     /// <param name="subPath">Optional sub-path within partition</param>
     /// <param name="objects">Objects to save</param>
-    /// <param name="ct">Cancellation token</param>
-    Task SavePartitionObjectsAsync(string nodePath, string? subPath, IReadOnlyCollection<object> objects, CancellationToken ct = default);
+    /// <returns>Observable that signals completion or OnError</returns>
+    IObservable<IReadOnlyCollection<object>> SavePartitionObjects(string nodePath, string? subPath, IReadOnlyCollection<object> objects);
 
     /// <summary>
     /// Deletes all objects from a node's partition folder (or sub-path).
     /// </summary>
     /// <param name="nodePath">The node path</param>
     /// <param name="subPath">Optional sub-path within partition</param>
-    /// <param name="ct">Cancellation token</param>
-    Task DeletePartitionObjectsAsync(string nodePath, string? subPath = null, CancellationToken ct = default);
+    /// <returns>Observable that signals completion or OnError</returns>
+    IObservable<string> DeletePartitionObjects(string nodePath, string? subPath = null);
 
     /// <summary>
     /// Gets the newest modification timestamp across all objects in a partition (or sub-path).
diff --git a/src/MeshWeaver.Mesh.Contract/Services/INodeTypeService.cs b/src/MeshWeaver.Mesh.Contract/Services/INodeTypeService.cs
index 75a780711..cf3adec60 100644
--- a/src/MeshWeaver.Mesh.Contract/Services/INodeTypeService.cs
+++ b/src/MeshWeaver.Mesh.Contract/Services/INodeTypeService.cs
@@ -35,4 +35,49 @@ public interface INodeTypeService
     /// Returns null if no access rules are defined in the hub config.
     /// </summary>
     INodeTypeAccessRule? GetAccessRule(string nodeTypePath) => null;
+
+    /// <summary>
+    /// Returns the last compilation error recorded for the given NodeType path,
+    /// or <c>null</c> if compilation has not failed. The error text includes the
+    /// formatted Roslyn diagnostics as produced by
+    /// <c>MeshNodeCompilationService</c>.
+    /// </summary>
+    /// <remarks>
+    /// Used by MCP <c>Get</c> / <c>GetDiagnostics</c> so callers (e.g. the Coder
+    /// agent) can verify that a NodeType they just created or updated actually
+    /// compiles. The error is cached by <c>NodeTypeService</c> each time a compile
+    /// fails and cleared when it succeeds.
+    /// </remarks>
+    string? GetCompilationError(string nodeTypePath) => null;
+
+    /// <summary>
+    /// Returns <c>true</c> if compilation for the given NodeType path is currently
+    /// running (the task has been kicked off but not yet completed). Consumers can use
+    /// this to render a "Compiling…" progress indicator so the user sees activity
+    /// rather than a blank layout while they wait.
+    /// </summary>
+    bool IsCompiling(string nodeTypePath) => false;
+
+    /// <summary>
+    /// When compilation for <paramref name="nodeTypePath"/> is running, returns when
+    /// it started (UTC). Otherwise <c>null</c>. Paired with <see cref="IsCompiling"/>
+    /// to show elapsed-time feedback in progress overlays.
+    /// </summary>
+    DateTimeOffset? GetCompilationStartedAt(string nodeTypePath) => null;
+
+    /// <summary>
+    /// Flushes all cached state (compilation errors, cached tasks, cached hub
+    /// configurations, etc.) for the given NodeType path, forcing a fresh compile
+    /// on the next access. Paired with <c>DisposeRequest</c> to fully reset a
+    /// stuck NodeType — disposing the hub alone is not enough because the
+    /// service-level caches survive hub teardown.
+    /// </summary>
+    void InvalidateCache(string nodeTypePath) { }
+
+    /// <summary>
+    /// Snapshot of NodeType paths currently being compiled. Used by the portal
+    /// to render a "Compiling…" progress indicator while a navigation request is
+    /// blocked waiting on a compile.
+    /// </summary>
+    IReadOnlyCollection<string> GetCompilingPaths() => Array.Empty<string>();
 }
diff --git a/src/MeshWeaver.Messaging.Contract/HeartBeatEvent.cs b/src/MeshWeaver.Messaging.Contract/HeartBeatEvent.cs
index 14f94bb23..c99212298 100644
--- a/src/MeshWeaver.Messaging.Contract/HeartBeatEvent.cs
+++ b/src/MeshWeaver.Messaging.Contract/HeartBeatEvent.cs
@@ -4,6 +4,8 @@ namespace MeshWeaver.Messaging;
 /// Published by executing hubs (e.g., _Exec during AI streaming) to their parent hub
 /// to signal that the grain should stay alive during long-running operations.
 /// Handled by every mesh node hub — calls GrainKeepAliveCallback if registered.
+/// Emitters should stop sending after the first DeliveryFailure response to avoid
+/// periodic warning spam when the owner has no handler.
 /// </summary>
 public record HeartBeatEvent;
 
diff --git a/src/MeshWeaver.Messaging.Hub/MessageHubExtensions.cs b/src/MeshWeaver.Messaging.Hub/MessageHubExtensions.cs
index 14db1d22a..d3c5f1060 100644
--- a/src/MeshWeaver.Messaging.Hub/MessageHubExtensions.cs
+++ b/src/MeshWeaver.Messaging.Hub/MessageHubExtensions.cs
@@ -1,4 +1,5 @@
 using System.Collections.Immutable;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Text.Json;
 using System.Text.Json.Nodes;
@@ -154,8 +155,25 @@ public static IDisposable BeginAsyncOperation(this IMessageHub hub)
             current = parent;
         }
 
-        // Fallback: heartbeat via Observable.Interval (monolith or no grain callback)
-        return Observable.Interval(TimeSpan.FromSeconds(25))
-            .Subscribe(_ => hub.Post(new HeartBeatEvent()));
+        // Fallback: heartbeat via Observable.Interval (monolith or no grain callback).
+        // Stop on the first DeliveryFailure so we don't spam warnings when no handler is registered.
+        var cts = new CancellationTokenSource();
+        IDisposable? sub = null;
+        sub = Observable.Interval(TimeSpan.FromSeconds(25))
+            .Subscribe(_ =>
+            {
+                var delivery = hub.Post(new HeartBeatEvent());
+                if (delivery == null) return;
+                hub.RegisterCallback(delivery, (d, _) =>
+                {
+                    if (d.Message is DeliveryFailure)
+                    {
+                        sub?.Dispose();
+                        cts.Cancel();
+                    }
+                    return Task.FromResult(d);
+                }, cts.Token);
+            });
+        return new CompositeDisposable(sub, Disposable.Create(() => cts.Cancel()));
     }
 }
diff --git a/src/MeshWeaver.Messaging.Hub/MessageService.cs b/src/MeshWeaver.Messaging.Hub/MessageService.cs
index 1f4ded64c..78ece95af 100644
--- a/src/MeshWeaver.Messaging.Hub/MessageService.cs
+++ b/src/MeshWeaver.Messaging.Hub/MessageService.cs
@@ -128,8 +128,11 @@ public bool OpenGate(string name)
 
     private IMessageDelivery ReportFailure(IMessageDelivery delivery)
     {
-        logger.LogWarning("An exception occurred processing {MessageType} (ID: {MessageId}) in {Address}",
-            delivery.Message.GetType().Name, delivery.Id, Address);
+        var error = delivery.Properties.TryGetValue("Error", out var e) ? e?.ToString() : null;
+        logger.LogWarning(
+            "Message delivery failed for {MessageType} (ID: {MessageId}) in {Address}: {Error}",
+            delivery.Message.GetType().Name, delivery.Id, Address,
+            error ?? "(no error details)");
 
         // Don't post DeliveryFailure during shutdown - recipients are likely also disposing
         // and the messages just clog the pipeline
@@ -141,7 +144,7 @@ private IMessageDelivery ReportFailure(IMessageDelivery delivery)
         {
             try
             {
-                var message = delivery.Properties.TryGetValue("Error", out var error) ? error.ToString() : $"Message delivery failed in address {Address}";
+                var message = error ?? $"Message delivery failed in address {Address}";
                 Post(new DeliveryFailure(delivery, message), new PostOptions(Address).ResponseFor(delivery));
             }
             catch (Exception ex)
diff --git a/test/MeshWeaver.AI.Test/DelegationTest.cs b/test/MeshWeaver.AI.Test/DelegationTest.cs
index c83a03394..40ec87684 100644
--- a/test/MeshWeaver.AI.Test/DelegationTest.cs
+++ b/test/MeshWeaver.AI.Test/DelegationTest.cs
@@ -25,6 +25,18 @@ public class DelegationTest
 {
     private const string AgentBResponseText = "This is the specialized response from Agent B.";
 
+    /// <summary>
+    /// Test helper: convert a Task-returning body into an IAsyncEnumerable{string} by
+    /// yielding the final string as a single chunk. Lets tests keep their existing
+    /// Task-based delegation logic while the production tool signature is streaming.
+    /// </summary>
+    private static async IAsyncEnumerable<string> ToStream(
+        Func<CancellationToken, Task<string>> body,
+        [EnumeratorCancellation] CancellationToken ct = default)
+    {
+        yield return await body(ct);
+    }
+
     #region Fake Chat Client Infrastructure
 
     /// <summary>
@@ -197,45 +209,22 @@ public async Task Delegation_BothSessionsCreated_ChildRunsInIsolatedContext()
         var delegationTool = DelegationTool.CreateUnifiedDelegationTool(
             agentAConfig,
             [agentAConfig, agentBConfig],
-            executeAsync: async (agentName, task, context, ct) =>
+            executeAsync: (agentName, task, context, ct) => ToStream(async innerCt =>
             {
                 capturedAgentName = agentName;
                 capturedTask = task;
-
                 var targetId = agentName.Split('/').Last();
                 if (!allAgents.TryGetValue(targetId, out var targetAgent))
-                {
-                    return new DelegationResult
-                    {
-                        AgentName = agentName,
-                        Task = task,
-                        Result = $"Agent '{agentName}' not found",
-                        Success = false
-                    };
-                }
-
-                // Create isolated session for the child agent (same as production code)
+                    return $"Agent '{agentName}' not found";
                 childSession = await targetAgent.CreateSessionAsync();
-
-                // Run the child agent
-                var response = await targetAgent.RunAsync(task, childSession, cancellationToken: ct);
-
-                // Extract text from response
-                var resultText = string.Join("\n", response.Messages
+                var response = await targetAgent.RunAsync(task, childSession, cancellationToken: innerCt);
+                return string.Join("\n", response.Messages
                     .Where(m => m.Role == ChatRole.Assistant)
                     .SelectMany(m => m.Contents)
                     .OfType<TextContent>()
                     .Select(t => t.Text)
                     .Where(t => !string.IsNullOrEmpty(t)));
-
-                return new DelegationResult
-                {
-                    AgentName = targetId,
-                    Task = task,
-                    Result = resultText,
-                    Success = true
-                };
-            });
+            }, ct));
 
         // Create agent A (the delegator) with a chat client that triggers the delegation tool
         var agentAClient = new DelegatingFakeChatClient(
@@ -318,28 +307,19 @@ public async Task Delegation_ChildThreadInParentNamespace_ResultAppearsAsFunctio
         var delegationTool = DelegationTool.CreateUnifiedDelegationTool(
             agentAConfig,
             [agentAConfig, agentBConfig],
-            executeAsync: async (agentName, task, context, ct) =>
+            executeAsync: (agentName, task, context, ct) => ToStream(async innerCt =>
             {
                 var targetId = agentName.Split('/').Last();
                 var targetAgent = allAgents[targetId];
                 var session = await targetAgent.CreateSessionAsync();
-                var response = await targetAgent.RunAsync(task, session, cancellationToken: ct);
-
-                var resultText = string.Join("\n", response.Messages
+                var response = await targetAgent.RunAsync(task, session, cancellationToken: innerCt);
+                return string.Join("\n", response.Messages
                     .Where(m => m.Role == ChatRole.Assistant)
                     .SelectMany(m => m.Contents)
                     .OfType<TextContent>()
                     .Select(t => t.Text)
                     .Where(t => !string.IsNullOrEmpty(t)));
-
-                return new DelegationResult
-                {
-                    AgentName = targetId,
-                    Task = task,
-                    Result = resultText,
-                    Success = true
-                };
-            });
+            }, ct));
 
         var agentAClient = new DelegatingFakeChatClient(
             toolName: "delegate_to_agent",
@@ -407,31 +387,15 @@ public async Task Delegation_TargetAgentNotFound_ReturnsFailureResult()
         var delegationTool = DelegationTool.CreateUnifiedDelegationTool(
             agentAConfig,
             [agentAConfig],
-            executeAsync: async (agentName, task, context, ct) =>
+            executeAsync: (agentName, task, context, ct) => ToStream(async innerCt =>
             {
                 delegationExecuted = true;
                 var targetId = agentName.Split('/').Last();
-                if (!allAgents.TryGetValue(targetId, out var targetAgent))
-                {
-                    return new DelegationResult
-                    {
-                        AgentName = agentName,
-                        Task = task,
-                        Result = $"Agent '{agentName}' not found",
-                        Success = false
-                    };
-                }
-
-                // Should not reach here
+                if (!allAgents.TryGetValue(targetId, out var _))
+                    return $"Agent '{agentName}' not found";
                 await Task.CompletedTask;
-                return new DelegationResult
-                {
-                    AgentName = targetId,
-                    Task = task,
-                    Result = "unexpected",
-                    Success = true
-                };
-            });
+                return "unexpected";
+            }, ct));
 
         var agentAClient = new DelegatingFakeChatClient(
             toolName: "delegate_to_agent",
diff --git a/test/MeshWeaver.AI.Test/MeshPluginContentAccessTest.cs b/test/MeshWeaver.AI.Test/MeshPluginContentAccessTest.cs
index 5ab864b44..6fd9d514c 100644
--- a/test/MeshWeaver.AI.Test/MeshPluginContentAccessTest.cs
+++ b/test/MeshWeaver.AI.Test/MeshPluginContentAccessTest.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
@@ -10,6 +11,7 @@
 using MeshWeaver.AI.Persistence;
 using MeshWeaver.ContentCollections;
 using MeshWeaver.Data;
+using MeshWeaver.Data.Completion;
 using MeshWeaver.Graph;
 using MeshWeaver.Graph.Configuration;
 using MeshWeaver.Hosting.Monolith;
@@ -200,6 +202,209 @@ await NodeFactory.CreateNodeAsync(
         response.Message.Error.Should().BeNull();
     }
 
+    /// <summary>
+    /// Repro for the prod symptom: agent emits an absolute path where the SPACED filename
+    /// portion is wrapped in double quotes (e.g. content/"My File.docx"). The full path
+    /// looks like @/Org/Sub/content/"Diskussion Thomas Final Report.docx".
+    /// MeshOperations.ResolvePath only strips SURROUNDING quotes, so embedded quotes
+    /// survive, the address part is parsed correctly but the file lookup goes after a
+    /// quoted-literal filename that doesn't exist.
+    /// </summary>
+    [Fact]
+    public async Task Get_AbsolutePath_QuotedSpacedFilename_ReturnsFileContent()
+    {
+        var nodePath = $"ContentTest_{_testId}_Q";
+        var contentDir = Path.Combine(ContentBasePath, nodePath);
+        Directory.CreateDirectory(contentDir);
+        const string SpacedFile = "Diskussion Thomas Final Report.txt";
+        await File.WriteAllTextAsync(Path.Combine(contentDir, SpacedFile),
+            "the actual report content", TestContext.Current.CancellationToken);
+
+        await NodeFactory.CreateNodeAsync(
+            new MeshNode(nodePath) { Name = "Quoted Test", NodeType = "Markdown" },
+            TestContext.Current.CancellationToken);
+
+        var plugin = new MeshPlugin(Mesh, new MockAgentChat());
+
+        // Exact prod-shape path: absolute (@/) + spaced filename wrapped in quotes.
+        var path = $"@/{nodePath}/content/\"{SpacedFile}\"";
+        var result = await plugin.Get(path);
+
+        Output.WriteLine($"Path: {path}");
+        Output.WriteLine($"Result: {result}");
+
+        result.Should().NotStartWith("Error");
+        result.Should().NotStartWith("Not found");
+        result.Should().Contain("the actual report content");
+    }
+
+    /// <summary>
+    /// Same as above but quotes wrap the WHOLE relative portion after content/ —
+    /// i.e. content/"name" vs "content/name" — both shapes appear in agent output.
+    /// </summary>
+    [Fact]
+    public async Task Get_AbsolutePath_QuotesAroundContentSegment_ReturnsFileContent()
+    {
+        var nodePath = $"ContentTest_{_testId}_Q2";
+        var contentDir = Path.Combine(ContentBasePath, nodePath);
+        Directory.CreateDirectory(contentDir);
+        const string SpacedFile = "Input Markus Apr 15.txt";
+        await File.WriteAllTextAsync(Path.Combine(contentDir, SpacedFile),
+            "markus input notes", TestContext.Current.CancellationToken);
+
+        await NodeFactory.CreateNodeAsync(
+            new MeshNode(nodePath) { Name = "Markus Test", NodeType = "Markdown" },
+            TestContext.Current.CancellationToken);
+
+        var plugin = new MeshPlugin(Mesh, new MockAgentChat());
+
+        // Quote wraps "content/<file>" together rather than just <file>.
+        var path = $"@/{nodePath}/\"content/{SpacedFile}\"";
+        var result = await plugin.Get(path);
+
+        Output.WriteLine($"Path: {path}");
+        Output.WriteLine($"Result: {result}");
+
+        result.Should().NotStartWith("Error");
+        result.Should().NotStartWith("Not found");
+        result.Should().Contain("markus input notes");
+    }
+
+    /// <summary>
+    /// Tolerance matrix — every shape we've actually observed an agent or autocomplete
+    /// emit for the SAME spaced file. They must all return the file content. Keep this
+    /// table extended with new shapes the agents come up with in the wild.
+    /// {NODE} is replaced with the per-test node path so the parameterization stays
+    /// readable; {FILE} is the spaced filename. Both sit under a per-test temp dir.
+    /// </summary>
+    [Theory]
+    [InlineData("@/{NODE}/content/{FILE}",                  "no quotes, absolute")]
+    [InlineData("\"@/{NODE}/content/{FILE}\"",              "wrapping quotes around the whole reference")]
+    [InlineData("@/{NODE}/content/\"{FILE}\"",              "quotes around filename only")]
+    [InlineData("@/{NODE}/\"content/{FILE}\"",              "quotes around content/filename together")]
+    [InlineData("@\"/{NODE}/content/{FILE}\"",              "quote right after @")]
+    [InlineData("@\"{NODE}/content/{FILE}\"",               "quote after @, no leading slash")]
+    [InlineData("@/{NODE}/content/{FILE}   ",               "trailing whitespace")]
+    [InlineData("   @/{NODE}/content/{FILE}",               "leading whitespace")]
+    [InlineData("@/{NODE}/content/'{FILE}'",                "single quotes around filename")]
+    public async Task Get_AgentEmittedShapes_AllReturnFileContent(string template, string description)
+    {
+        var nodePath = $"ContentTest_{_testId}_{Math.Abs(template.GetHashCode()):X}";
+        var contentDir = Path.Combine(ContentBasePath, nodePath);
+        Directory.CreateDirectory(contentDir);
+        const string SpacedFile = "Diskussion Thomas Final Report.txt";
+        const string Body = "agent-shape tolerance body";
+        await File.WriteAllTextAsync(Path.Combine(contentDir, SpacedFile), Body,
+            TestContext.Current.CancellationToken);
+
+        await NodeFactory.CreateNodeAsync(
+            new MeshNode(nodePath) { Name = "Tolerance", NodeType = "Markdown" },
+            TestContext.Current.CancellationToken);
+
+        var path = template.Replace("{NODE}", nodePath).Replace("{FILE}", SpacedFile);
+        Output.WriteLine($"[{description}] path: {path}");
+
+        var plugin = new MeshPlugin(Mesh, new MockAgentChat());
+        var result = await plugin.Get(path);
+        Output.WriteLine($"  result: {result}");
+
+        result.Should().Contain(Body, $"shape '{description}' should resolve to the file");
+    }
+
+    /// <summary>
+    /// Yet another shape an agent (or model) sometimes emits: @"content/some path" — the
+    /// quote sits right after @ and wraps everything that follows. Same fix applies
+    /// (strip every quote), this just nails the regression.
+    /// </summary>
+    [Fact]
+    public async Task Get_AbsolutePath_QuoteAfterAtSign_ReturnsFileContent()
+    {
+        var nodePath = $"ContentTest_{_testId}_Q3";
+        var contentDir = Path.Combine(ContentBasePath, nodePath);
+        Directory.CreateDirectory(contentDir);
+        const string SpacedFile = "some fucking thing.txt";
+        await File.WriteAllTextAsync(Path.Combine(contentDir, SpacedFile),
+            "the contents", TestContext.Current.CancellationToken);
+
+        await NodeFactory.CreateNodeAsync(
+            new MeshNode(nodePath) { Name = "QAfterAt", NodeType = "Markdown" },
+            TestContext.Current.CancellationToken);
+
+        var plugin = new MeshPlugin(Mesh, new MockAgentChat());
+        var path = $"@\"/{nodePath}/content/{SpacedFile}\"";
+        var result = await plugin.Get(path);
+
+        Output.WriteLine($"Path: {path}");
+        Output.WriteLine($"Result: {result}");
+
+        result.Should().NotStartWith("Error");
+        result.Should().NotStartWith("Not found");
+        result.Should().Contain("the contents");
+    }
+
+    /// <summary>
+    /// End-to-end repro: typing lowercase "markus" against the node hub's autocomplete
+    /// must return the spaced file "Input Markus Apr 15.txt", and the InsertText that
+    /// the autocomplete suggests must round-trip through MeshPlugin.Get and return the
+    /// file content. This exercises the full chat pipeline: case-insensitive fuzzy
+    /// match → quoted-reference InsertText → ResolvePath → file lookup.
+    /// </summary>
+    [Fact]
+    public async Task Autocomplete_RoundTrip_LowercaseQuery_QuotedInsertText_GetsContent()
+    {
+        var nodePath = $"ContentTest_{_testId}_RT";
+        var contentDir = Path.Combine(ContentBasePath, nodePath);
+        Directory.CreateDirectory(contentDir);
+        const string SpacedFile = "Input Markus Apr 15.txt";
+        const string FileContent = "the input markus body";
+        await File.WriteAllTextAsync(Path.Combine(contentDir, SpacedFile), FileContent,
+            TestContext.Current.CancellationToken);
+
+        await NodeFactory.CreateNodeAsync(
+            new MeshNode(nodePath) { Name = "Round Trip", NodeType = "Markdown" },
+            TestContext.Current.CancellationToken);
+
+        var client = GetClient();
+
+        // Step 1 — autocomplete, lowercase, treats node as the chat context.
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+        cts.CancelAfter(TimeSpan.FromSeconds(10));
+        var acResponse = await client.AwaitResponse(
+            new AutocompleteRequest("@markus", nodePath),
+            o => o.WithTarget(new Address(nodePath)),
+            cts.Token);
+
+        Output.WriteLine($"Autocomplete items: {acResponse.Message.Items.Count}");
+        foreach (var item in acResponse.Message.Items)
+            Output.WriteLine($"  - Label={item.Label} | InsertText={item.InsertText}");
+
+        var match = acResponse.Message.Items.FirstOrDefault(i =>
+            i.Label != null && i.Label.Contains(SpacedFile, StringComparison.Ordinal));
+        match.Should().NotBeNull("lowercase 'markus' should fuzzy-match 'Input Markus Apr 15.txt'");
+        match!.InsertText.Should().NotBeNullOrEmpty();
+
+        // The InsertText for a spaced filename is wrapped in quotes by FormatInsertText.
+        match.InsertText.Should().Contain("\"", "spaced filenames are quoted in the InsertText");
+
+        // Step 2 — feed the InsertText (verbatim, including quotes) into MeshPlugin.Get,
+        // pretending the agent received it via attachment. Strip trailing whitespace the
+        // way the chat input would when treating it as an @reference.
+        var insertedRef = match.InsertText.TrimEnd();
+        var plugin = new MeshPlugin(Mesh, new MockAgentChat());
+        var contextResolved = MeshOperations.ResolveContextPath(
+            new MockAgentChat { Context = new AgentContext { Address = new Address(nodePath), Context = nodePath } },
+            insertedRef);
+        Output.WriteLine($"Inserted ref: {insertedRef}");
+        Output.WriteLine($"Context-resolved: {contextResolved}");
+
+        var result = await plugin.Get(contextResolved);
+        Output.WriteLine($"Get result: {result}");
+
+        result.Should().NotStartWith("Error");
+        result.Should().NotStartWith("Not found");
+        result.Should().Contain(FileContent);
+    }
+
     private class MockAgentChat : IAgentChat
     {
         public AgentContext? Context { get; set; }
diff --git a/test/MeshWeaver.AI.Test/MeshPluginTest.cs b/test/MeshWeaver.AI.Test/MeshPluginTest.cs
index 41f74c3f5..ecf4e4451 100644
--- a/test/MeshWeaver.AI.Test/MeshPluginTest.cs
+++ b/test/MeshWeaver.AI.Test/MeshPluginTest.cs
@@ -75,13 +75,14 @@ public void CreateTools_ShouldReturnReadOnlyTools()
         var tools = plugin.CreateTools();
 
         tools.Should().NotBeNull();
-        // Read-only tools: Get, Search, NavigateTo
-        tools.Should().HaveCount(3);
+        // Read-only tools: Get, Search, NavigateTo, GetDiagnostics
+        tools.Should().HaveCount(4);
 
         var toolNames = tools.OfType<AIFunction>().Select(t => t.Name).ToList();
         toolNames.Should().Contain("Get");
         toolNames.Should().Contain("Search");
         toolNames.Should().Contain("NavigateTo");
+        toolNames.Should().Contain("GetDiagnostics");
         toolNames.Should().NotContain("Create");
         toolNames.Should().NotContain("Update");
         toolNames.Should().NotContain("Delete");
@@ -96,8 +97,8 @@ public void CreateAllTools_ShouldIncludeWriteOperations()
         var tools = plugin.CreateAllTools();
 
         tools.Should().NotBeNull();
-        // All tools: Get, Search, NavigateTo, Create, Update, Patch, Delete
-        tools.Should().HaveCount(7);
+        // All tools: Get, Search, NavigateTo, Create, Update, Patch, Delete, GetDiagnostics, Recycle
+        tools.Should().HaveCount(9);
 
         var toolNames = tools.OfType<AIFunction>().Select(t => t.Name).ToList();
         toolNames.Should().Contain("Get");
@@ -107,6 +108,8 @@ public void CreateAllTools_ShouldIncludeWriteOperations()
         toolNames.Should().Contain("Update");
         toolNames.Should().Contain("Patch");
         toolNames.Should().Contain("Delete");
+        toolNames.Should().Contain("GetDiagnostics");
+        toolNames.Should().Contain("Recycle");
     }
 
     #endregion
@@ -698,6 +701,115 @@ public async Task ContentCollection_GetSubfolderFileContent()
 
     #endregion
 
+    #region GetDiagnostics / compilation-error surfacing
+
+    /// <summary>
+    /// A NodeType whose Configuration references an undefined type must surface
+    /// the compilation error through <see cref="MeshPlugin.GetDiagnostics"/> so
+    /// the Coder agent can self-diagnose.
+    /// </summary>
+    [Fact(Timeout = 60000)]
+    public async Task GetDiagnostics_BrokenNodeType_ReturnsErrorStatus()
+    {
+        var mockChat = new MockAgentChat();
+        var plugin = new MeshPlugin(Mesh, mockChat);
+
+        var nodeTypeId = $"BrokenType_{Guid.NewGuid():N}";
+        var createJson = JsonSerializer.Serialize(new
+        {
+            id = nodeTypeId,
+            @namespace = "ACME",
+            name = "Broken Type",
+            nodeType = "NodeType",
+            content = new
+            {
+                type = "NodeTypeDefinition",
+                configuration = "config => config.WithContentType<ThisTypeDoesNotExist>()"
+            }
+        });
+        // Wrap "type" → "$type" for JsonPolymorphic
+        createJson = createJson.Replace("\"type\":", "\"$type\":");
+        await plugin.Create(createJson);
+
+        // Force compilation via the hub. Touching the NodeType path via the hub
+        // triggers compile; the error is then cached in NodeTypeService.
+        var nodeTypePath = $"ACME/{nodeTypeId}";
+        var nodeTypeService = Mesh.ServiceProvider.GetRequiredService<INodeTypeService>();
+        try
+        {
+            await nodeTypeService.EnrichWithNodeTypeAsync(
+                new MeshNode(nodeTypeId, "ACME") { NodeType = nodeTypePath },
+                TestContext.Current.CancellationToken);
+        }
+        catch
+        {
+            // Expected: compilation throws; NodeTypeService still records the error.
+        }
+
+        var diagnosticsJson = await plugin.GetDiagnostics($"@{nodeTypePath}");
+        diagnosticsJson.Should().NotBeNullOrEmpty();
+
+        using var doc = JsonDocument.Parse(diagnosticsJson);
+        var root = doc.RootElement;
+        root.GetProperty("status").GetString()
+            .Should().Be("Error", "because the broken NodeType should report compile failure");
+        root.GetProperty("error").GetString()
+            .Should().Contain("ThisTypeDoesNotExist",
+                "the cached error must include the unresolved type");
+    }
+
+    /// <summary>
+    /// <see cref="MeshPlugin.Get"/> on an instance of a broken NodeType must
+    /// wrap the response with a <c>compilationError</c> field so callers that
+    /// only call Get still see the failure.
+    /// </summary>
+    [Fact(Timeout = 60000)]
+    public async Task Get_InstanceOfBrokenNodeType_WrapsResponseWithCompilationError()
+    {
+        var mockChat = new MockAgentChat();
+        var plugin = new MeshPlugin(Mesh, mockChat);
+
+        // Create a broken NodeType and force its compilation to cache the error.
+        var nodeTypeId = $"BrokenType2_{Guid.NewGuid():N}";
+        var nodeTypePath = $"ACME/{nodeTypeId}";
+        var createJson = JsonSerializer.Serialize(new
+        {
+            id = nodeTypeId,
+            @namespace = "ACME",
+            name = "Broken Type 2",
+            nodeType = "NodeType",
+            content = new
+            {
+                type = "NodeTypeDefinition",
+                configuration = "config => config.WithContentType<AlsoNotAType>()"
+            }
+        }).Replace("\"type\":", "\"$type\":");
+        await plugin.Create(createJson);
+
+        var nodeTypeService = Mesh.ServiceProvider.GetRequiredService<INodeTypeService>();
+        try
+        {
+            await nodeTypeService.EnrichWithNodeTypeAsync(
+                new MeshNode(nodeTypeId, "ACME") { NodeType = nodeTypePath },
+                TestContext.Current.CancellationToken);
+        }
+        catch { /* expected */ }
+
+        // Get the NodeType itself — response should include compilationError.
+        var result = await plugin.Get($"@{nodeTypePath}");
+        result.Should().NotBeNullOrEmpty();
+
+        using var doc = JsonDocument.Parse(result);
+        var root = doc.RootElement;
+        root.TryGetProperty("compilationError", out var err).Should().BeTrue(
+            "Get on a broken NodeType must include a compilationError field");
+        err.GetString().Should().Contain("AlsoNotAType");
+        root.TryGetProperty("node", out _).Should().BeTrue(
+            "the original node payload must still be included under 'node'");
+    }
+
+    #endregion
+
     private class MockAgentChat : IAgentChat
     {
         public AgentContext? Context { get; set; }
diff --git a/test/MeshWeaver.AI.Test/ThreadSubmissionIntegrationTest.cs b/test/MeshWeaver.AI.Test/ThreadSubmissionIntegrationTest.cs
index 961de3d9b..6160b9fe6 100644
--- a/test/MeshWeaver.AI.Test/ThreadSubmissionIntegrationTest.cs
+++ b/test/MeshWeaver.AI.Test/ThreadSubmissionIntegrationTest.cs
@@ -72,7 +72,7 @@ public async Task Submit_ExistingThread_UserMessageIngested_OutputCellAppears()
         var committed = await WaitForThreadAsync(
             threadPath,
             t => t.IngestedMessageIds.Count >= 1 && t.Messages.Count >= 2,
-            timeoutMs: 10_000,
+            timeoutMs: 30_000,
             ct);
 
         committed.IngestedMessageIds.Should().HaveCount(1);
@@ -151,7 +151,7 @@ public async Task Submit_ThreeRapidSubmissions_AllIngestedIntoOneRound()
         await WaitForThreadAsync(
             threadPath,
             t => t.IngestedMessageIds.Count == 3,
-            timeoutMs: 10_000,
+            timeoutMs: 30_000,
             ct);
 
         var final = await ReadThreadAsync(threadPath, ct);
@@ -179,7 +179,7 @@ public async Task Resubmit_TruncatesAfterReplayedMessage_NewRoundCreated()
         var afterRoundOne = await WaitForThreadAsync(
             threadPath,
             t => !t.IsExecuting && t.IngestedMessageIds.Count == 1 && t.Messages.Count == 2,
-            timeoutMs: 10_000, ct);
+            timeoutMs: 30_000, ct);
 
         var u1 = afterRoundOne.UserMessageIds[0];
         var r1 = afterRoundOne.Messages[1];
@@ -394,6 +394,62 @@ await WaitForThreadAsync(
         final.Messages.Should().HaveCount(4);
     }
 
+    // ─── Single submit must produce exactly one response cell ───
+
+    /// <summary>
+    /// Repro for the prod symptom: ONE submit produces TWO "Generating response" rounds.
+    /// Hypothesis: the user-cell creation emits a workspace stream event that re-fires the
+    /// server watcher BEFORE DispatchRound's IsExecuting=true commit lands. The watcher sees
+    /// IsExecuting=false + the user msg still unprocessed, dispatches a second round, second
+    /// response cell is created.
+    /// </summary>
+    [Fact]
+    public async Task Submit_SingleSubmit_ProducesExactlyOneResponseCell()
+    {
+        var ct = TestContext.Current.CancellationToken;
+        var threadPath = await SeedEmptyThreadAsync(ct);
+        var client = GetClient();
+
+        ThreadSubmission.Submit(new SubmitContext
+        {
+            Hub = client,
+            ThreadPath = threadPath,
+            UserText = "exactly once",
+            CreatedBy = "rbuergi@systemorph.com",
+            AuthorName = "Tester"
+        });
+
+        // Wait for the round to settle.
+        var settled = await WaitForThreadAsync(
+            threadPath,
+            t => !t.IsExecuting && t.IngestedMessageIds.Count == 1,
+            timeoutMs: 30_000, ct);
+
+        // Give any racing second-dispatch a chance to land.
+        await Task.Delay(500, ct);
+
+        var final = await ReadThreadAsync(threadPath, ct);
+
+        // The thread should record exactly: [user, response]. If a second round dispatched,
+        // Messages would contain a second response cell id.
+        final.Messages.Should().HaveCount(2,
+            $"one submit must produce exactly one user + one response cell, got Messages=[{string.Join(",", final.Messages)}]");
+        final.IngestedMessageIds.Should().HaveCount(1);
+        final.UserMessageIds.Should().HaveCount(1);
+
+        // Cross-check at the node level: count actual ThreadMessage assistant cells.
+        var msgNodes = new List<MeshNode>();
+        await foreach (var n in MeshQuery.QueryAsync<MeshNode>(
+            $"namespace:{threadPath} nodeType:{ThreadMessageNodeType.NodeType}", null, ct))
+            msgNodes.Add(n);
+        var responseCells = msgNodes
+            .Where(n => (n.Content as ThreadMessage)?.Role == "assistant")
+            .ToList();
+        responseCells.Should().HaveCount(1,
+            $"exactly one response cell node should exist, got {responseCells.Count}: " +
+            string.Join(",", responseCells.Select(c => c.Id)));
+    }
+
     // ─── Helpers ───
 
     private async Task<string> SeedEmptyThreadAsync(CancellationToken ct)
diff --git a/test/MeshWeaver.AI.Test/UnifiedContentAccessTest.cs b/test/MeshWeaver.AI.Test/UnifiedContentAccessTest.cs
index e88af7b91..31adec85d 100644
--- a/test/MeshWeaver.AI.Test/UnifiedContentAccessTest.cs
+++ b/test/MeshWeaver.AI.Test/UnifiedContentAccessTest.cs
@@ -4,6 +4,7 @@
 using System.IO;
 using System.Linq;
 using System.Reactive.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
 using MeshWeaver.ContentCollections;
@@ -430,6 +431,150 @@ public async Task GetDataRequest_UnifiedReference_LayoutAreas_ReturnsAreaDefinit
 
     #endregion
 
+    #region Slash-format and spaced-filename repro (PartnerRe / .docx symptom)
+
+    // The prod symptom was: AI agent calls Get("@/PartnerRe/AIConsulting/content/Diskussion Thomas Final Report.docx").
+    // MeshOperations.TryResolveUnifiedPathAsync splits the path into addressPart="PartnerRe/AIConsulting"
+    // and remainder="content/Diskussion Thomas Final Report.docx", then posts
+    //   GetDataRequest(new UnifiedReference("content/Diskussion Thomas Final Report.docx"))
+    // to the address. The user observed a 10-second AwaitResponse timeout — symptom said
+    // "no response received". These tests pin down whether the GetDataRequest handler returns at
+    // all for the slash-format default-collection lookup, with and without spaces.
+
+    [Fact]
+    public async Task GetDataRequest_ContentSlashFormat_FileInDefaultCollection_Responds()
+    {
+        var testDir = Path.Combine(Path.GetTempPath(), "MeshWeaverTest_SlashDefault_" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(testDir);
+        await File.WriteAllTextAsync(Path.Combine(testDir, "report.txt"), "default-collection slash format",
+            TestContext.Current.CancellationToken);
+
+        try
+        {
+            var host = GetHostWithFileProvider(testDir, defaultCollection: true);
+            var client = GetClient();
+
+            // Slash format with NO collection segment — what the agent actually emits.
+            var response = await client.AwaitResponse(
+                new GetDataRequest(new UnifiedReference("content/report.txt")),
+                o => o.WithTarget(CreateHostAddress()),
+                TestContext.Current.CancellationToken);
+
+            response.Message.Error.Should().BeNull();
+            (response.Message.Data as string).Should().Contain("default-collection slash format");
+        }
+        finally
+        {
+            if (Directory.Exists(testDir)) Directory.Delete(testDir, true);
+        }
+    }
+
+    [Fact]
+    public async Task GetDataRequest_ContentSlashFormat_SpacedFilename_Responds()
+    {
+        var testDir = Path.Combine(Path.GetTempPath(), "MeshWeaverTest_SlashSpaces_" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(testDir);
+        const string Spaced = "Diskussion Thomas Final Report.txt";
+        await File.WriteAllTextAsync(Path.Combine(testDir, Spaced), "spaced default-collection content",
+            TestContext.Current.CancellationToken);
+
+        try
+        {
+            var host = GetHostWithFileProvider(testDir, defaultCollection: true);
+            var client = GetClient();
+
+            var response = await client.AwaitResponse(
+                new GetDataRequest(new UnifiedReference($"content/{Spaced}")),
+                o => o.WithTarget(CreateHostAddress()),
+                TestContext.Current.CancellationToken);
+
+            response.Message.Error.Should().BeNull();
+            (response.Message.Data as string).Should().Contain("spaced default-collection content");
+        }
+        finally
+        {
+            if (Directory.Exists(testDir)) Directory.Delete(testDir, true);
+        }
+    }
+
+    [Fact]
+    public async Task GetDataRequest_ContentSlashFormat_NamedCollection_SpacedFilename_Responds()
+    {
+        var testDir = Path.Combine(Path.GetTempPath(), "MeshWeaverTest_SlashNamedSpaces_" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(testDir);
+        const string Spaced = "Input Markus Apr 15.txt";
+        await File.WriteAllTextAsync(Path.Combine(testDir, Spaced), "named-collection spaced content",
+            TestContext.Current.CancellationToken);
+
+        try
+        {
+            var host = GetHostWithFileProvider(testDir, defaultCollection: false);
+            var client = GetClient();
+
+            // Slash format WITH collection segment + spaces.
+            var response = await client.AwaitResponse(
+                new GetDataRequest(new UnifiedReference($"content/TestFiles/{Spaced}")),
+                o => o.WithTarget(CreateHostAddress()),
+                TestContext.Current.CancellationToken);
+
+            response.Message.Error.Should().BeNull();
+            (response.Message.Data as string).Should().Contain("named-collection spaced content");
+        }
+        finally
+        {
+            if (Directory.Exists(testDir)) Directory.Delete(testDir, true);
+        }
+    }
+
+    [Fact]
+    public async Task GetDataRequest_ContentSlashFormat_MissingDefaultCollection_ReturnsErrorNotTimeout()
+    {
+        // The prod hub for /PartnerRe/AIConsulting may not have AddContentCollections() registered
+        // under the default "content" name. The handler must return a clear error response — not
+        // hang and force AwaitResponse to time out.
+        GetHost(); // baseline host with NO file content provider configured
+        var client = GetClient();
+
+        // Bound the wait so a hang fails fast (as opposed to the test running forever).
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+        cts.CancelAfter(TimeSpan.FromSeconds(5));
+
+        var act = async () => await client.AwaitResponse(
+            new GetDataRequest(new UnifiedReference("content/Some File.docx")),
+            o => o.WithTarget(CreateHostAddress()),
+            cts.Token);
+
+        var response = await act();
+        response.Message.Error.Should().NotBeNullOrEmpty(
+            "the handler must respond with an error rather than letting AwaitResponse time out");
+    }
+
+    private IMessageHub GetHostWithFileProvider(string testDir, bool defaultCollection)
+    {
+        // For default-collection scenarios we register the collection as "content"; for named-collection
+        // scenarios we register it as "TestFiles". The default-content scenario also wires the legacy
+        // ContentProvider hook so `data:` lookups can still resolve files (matches existing tests).
+        if (hostWithFileProvider != null && currentTestDir == testDir) return hostWithFileProvider;
+        currentTestDir = testDir;
+        var collectionName = defaultCollection ? "content" : "TestFiles";
+        hostWithFileProvider = Mesh.GetHostedHub(CreateHostAddress(), config => config
+            .AddFileSystemContentCollection(collectionName, _ => testDir)
+            .AddData(data => data
+                .AddSource(source => source
+                    .WithType<TestPricing>(t => t
+                        .WithInitialData(_ => Task.FromResult(new List<TestPricing>
+                        {
+                            new() { Id = TestPricingId, Name = "Test Pricing", Status = "Active" }
+                        }.AsEnumerable()))))
+                .WithDefaultDataReference(workspace =>
+                    workspace.GetObservable<TestPricing>().Select(p => p.OrderBy(x => x.Id).FirstOrDefault()))
+                .WithContentProvider(collectionName))
+            .AddLayout(layout => layout.WithView("TestArea", TestAreaView)));
+        return hostWithFileProvider;
+    }
+
+    #endregion
+
     #region Test Configuration
 
     protected override MessageHubConfiguration ConfigureHost(MessageHubConfiguration configuration)
diff --git a/test/MeshWeaver.Query.Test/AutocompleteIconTests.cs b/test/MeshWeaver.Autocomplete.Test/AutocompleteIconTests.cs
similarity index 99%
rename from test/MeshWeaver.Query.Test/AutocompleteIconTests.cs
rename to test/MeshWeaver.Autocomplete.Test/AutocompleteIconTests.cs
index 7950d6e94..9f0d65d2c 100644
--- a/test/MeshWeaver.Query.Test/AutocompleteIconTests.cs
+++ b/test/MeshWeaver.Autocomplete.Test/AutocompleteIconTests.cs
@@ -15,7 +15,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
-namespace MeshWeaver.Query.Test;
+namespace MeshWeaver.Autocomplete.Test;
 
 /// <summary>
 /// Tests that AutocompleteAsync returns Icon data and performs proper text matching.
diff --git a/test/MeshWeaver.Query.Test/AutocompleteIntegrationTest.cs b/test/MeshWeaver.Autocomplete.Test/AutocompleteIntegrationTest.cs
similarity index 99%
rename from test/MeshWeaver.Query.Test/AutocompleteIntegrationTest.cs
rename to test/MeshWeaver.Autocomplete.Test/AutocompleteIntegrationTest.cs
index 13f1ee2ec..781b15460 100644
--- a/test/MeshWeaver.Query.Test/AutocompleteIntegrationTest.cs
+++ b/test/MeshWeaver.Autocomplete.Test/AutocompleteIntegrationTest.cs
@@ -20,7 +20,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
-namespace MeshWeaver.Query.Test;
+namespace MeshWeaver.Autocomplete.Test;
 
 /// <summary>
 /// Integration tests for the full autocomplete pipeline:
diff --git a/test/MeshWeaver.Query.Test/AutocompleteMultiSourceTest.cs b/test/MeshWeaver.Autocomplete.Test/AutocompleteMultiSourceTest.cs
similarity index 99%
rename from test/MeshWeaver.Query.Test/AutocompleteMultiSourceTest.cs
rename to test/MeshWeaver.Autocomplete.Test/AutocompleteMultiSourceTest.cs
index e30197193..43115c43b 100644
--- a/test/MeshWeaver.Query.Test/AutocompleteMultiSourceTest.cs
+++ b/test/MeshWeaver.Autocomplete.Test/AutocompleteMultiSourceTest.cs
@@ -23,7 +23,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
-namespace MeshWeaver.Query.Test;
+namespace MeshWeaver.Autocomplete.Test;
 
 /// <summary>
 /// Multi-source autocomplete integration tests.
diff --git a/test/MeshWeaver.Query.Test/MeshNodeAutocompleteTest.cs b/test/MeshWeaver.Autocomplete.Test/MeshNodeAutocompleteTest.cs
similarity index 99%
rename from test/MeshWeaver.Query.Test/MeshNodeAutocompleteTest.cs
rename to test/MeshWeaver.Autocomplete.Test/MeshNodeAutocompleteTest.cs
index b6a35794a..fe38660b8 100644
--- a/test/MeshWeaver.Query.Test/MeshNodeAutocompleteTest.cs
+++ b/test/MeshWeaver.Autocomplete.Test/MeshNodeAutocompleteTest.cs
@@ -18,7 +18,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
-namespace MeshWeaver.Query.Test;
+namespace MeshWeaver.Autocomplete.Test;
 
 /// <summary>
 /// Tests for MeshNodeAutocomplete functionality including:
diff --git a/test/MeshWeaver.Autocomplete.Test/MeshWeaver.Autocomplete.Test.csproj b/test/MeshWeaver.Autocomplete.Test/MeshWeaver.Autocomplete.Test.csproj
new file mode 100644
index 000000000..06d265a1b
--- /dev/null
+++ b/test/MeshWeaver.Autocomplete.Test/MeshWeaver.Autocomplete.Test.csproj
@@ -0,0 +1,43 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <ProjectGuid>{c3d4e5f6-a7b8-4c9d-0e1f-2a3b4c5d6e7f}</ProjectGuid>
+    <!-- Disable xUnit1051: CancellationToken warnings for test methods -->
+    <NoWarn>$(NoWarn);xUnit1051</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.TestHost" />
+    <PackageReference Include="Namotion.Reflection" />
+    <PackageReference Include="NSubstitute" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <!-- Pre-copy samples/Graph for tests - avoids runtime directory copying -->
+    <Content Include="..\..\samples\Graph\**">
+      <Link>SamplesGraph\%(RecursiveDir)%(Filename)%(Extension)</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="appsettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\MeshWeaver.Fixture\MeshWeaver.Fixture.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Hosting.Monolith\MeshWeaver.Hosting.Monolith.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Hosting\MeshWeaver.Hosting.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Mesh.Contract\MeshWeaver.Mesh.Contract.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Hosting.Monolith.TestBase\MeshWeaver.Hosting.Monolith.TestBase.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Layout\MeshWeaver.Layout.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.AI\MeshWeaver.AI.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Graph\MeshWeaver.Graph.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Documentation\MeshWeaver.Documentation.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Blazor\MeshWeaver.Blazor.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Blazor.AI\MeshWeaver.Blazor.AI.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Markdown.Collaboration\MeshWeaver.Markdown.Collaboration.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Messaging.Hub\MeshWeaver.Messaging.Hub.csproj" />
+    <ProjectReference Include="..\..\src\MeshWeaver.Import\MeshWeaver.Import.csproj" />
+    <ProjectReference Include="..\..\memex\Memex.Portal.Shared\Memex.Portal.Shared.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/test/MeshWeaver.Autocomplete.Test/TestPaths.cs b/test/MeshWeaver.Autocomplete.Test/TestPaths.cs
new file mode 100644
index 000000000..173659510
--- /dev/null
+++ b/test/MeshWeaver.Autocomplete.Test/TestPaths.cs
@@ -0,0 +1,15 @@
+using System;
+using System.IO;
+
+namespace MeshWeaver.Autocomplete.Test;
+
+/// <summary>
+/// Provides paths to test data directories.
+/// Uses pre-copied directories from build output to avoid runtime copying.
+/// </summary>
+public static class TestPaths
+{
+    public static string SamplesGraph => Path.Combine(AppContext.BaseDirectory, "SamplesGraph");
+    public static string SamplesGraphData => Path.Combine(SamplesGraph, "Data");
+    public static string SamplesGraphContent => Path.Combine(SamplesGraph, "content");
+}
diff --git a/test/MeshWeaver.Query.Test/UnifiedReferenceAutocompleteProviderTest.cs b/test/MeshWeaver.Autocomplete.Test/UnifiedReferenceAutocompleteProviderTest.cs
similarity index 99%
rename from test/MeshWeaver.Query.Test/UnifiedReferenceAutocompleteProviderTest.cs
rename to test/MeshWeaver.Autocomplete.Test/UnifiedReferenceAutocompleteProviderTest.cs
index ed7b89f3c..01f0d879e 100644
--- a/test/MeshWeaver.Query.Test/UnifiedReferenceAutocompleteProviderTest.cs
+++ b/test/MeshWeaver.Autocomplete.Test/UnifiedReferenceAutocompleteProviderTest.cs
@@ -20,7 +20,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
-namespace MeshWeaver.Query.Test;
+namespace MeshWeaver.Autocomplete.Test;
 
 /// <summary>
 /// Tests for UnifiedReferenceAutocompleteProvider using samples/Graph/Data.
diff --git a/test/MeshWeaver.Autocomplete.Test/appsettings.json b/test/MeshWeaver.Autocomplete.Test/appsettings.json
new file mode 100644
index 000000000..35e10bbf2
--- /dev/null
+++ b/test/MeshWeaver.Autocomplete.Test/appsettings.json
@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Warning",
+      "Microsoft": "Warning",
+      "System": "Warning"
+    }
+  }
+}
diff --git a/test/MeshWeaver.Graph.Test/MeshNodeCompilationServiceTest.cs b/test/MeshWeaver.Graph.Test/MeshNodeCompilationServiceTest.cs
index 156f8dc8a..945cf0329 100644
--- a/test/MeshWeaver.Graph.Test/MeshNodeCompilationServiceTest.cs
+++ b/test/MeshWeaver.Graph.Test/MeshNodeCompilationServiceTest.cs
@@ -657,4 +657,361 @@ public record Contact
         result.NodeTypeConfigurations.Should().NotBeEmpty("Should extract HubConfiguration from compiled assembly");
         result.NodeTypeConfigurations.First().HubConfiguration.Should().NotBeNull();
     }
+
+    [Fact(Timeout = 25000)]
+    public async Task GetAssemblyLocationAsync_SourcesDefaultsToSelfRelativeUnderscoreSource()
+    {
+        // The default (no Sources set) is "namespace:_Source scope:subtree", which
+        // is auto-rebased onto the NodeType's own path. This is the common case.
+        var persistence = new InMemoryPersistenceService();
+
+        var definition = new NodeTypeDefinition(); // no Sources
+        await SetupNodeType(persistence, "DefaultRel", definition, new CodeConfiguration
+        {
+            Code = @"
+public record DefaultRelType
+{
+    public string Id { get; init; } = string.Empty;
+}"
+        });
+
+        var service = CreateService(persistence);
+        var node = MeshNode.FromPath("org/default-rel/inst") with
+        {
+            Name = "Instance",
+            NodeType = "type/DefaultRel",
+            LastModified = DateTimeOffset.UtcNow
+        };
+
+        var assemblyPath = await service.GetAssemblyLocationAsync(node, TestContext.Current.CancellationToken);
+
+        assemblyPath.Should().NotBeNull();
+        Assembly.LoadFrom(assemblyPath!).GetType("DefaultRelType").Should().NotBeNull(
+            "default 'namespace:_Source' should auto-rebase onto the NodeType's own path");
+    }
+
+    [Fact(Timeout = 25000)]
+    public async Task GetAssemblyLocationAsync_SourcesWithSelfMacro_ExpandsToOwnPath()
+    {
+        // $self must resolve to the owning NodeType's path so JSON doesn't need
+        // to hardcode its own namespace.
+        var persistence = new InMemoryPersistenceService();
+
+        var definition = new NodeTypeDefinition
+        {
+            Sources = ["namespace:$self/_Source scope:subtree"]
+        };
+        await SetupNodeType(persistence, "SelfMacro", definition, new CodeConfiguration
+        {
+            Code = @"
+public record SelfMacroType
+{
+    public string Id { get; init; } = string.Empty;
+}"
+        });
+
+        var service = CreateService(persistence);
+        var node = MeshNode.FromPath("org/self-macro/inst") with
+        {
+            Name = "Instance",
+            NodeType = "type/SelfMacro",
+            LastModified = DateTimeOffset.UtcNow
+        };
+
+        var assemblyPath = await service.GetAssemblyLocationAsync(node, TestContext.Current.CancellationToken);
+
+        assemblyPath.Should().NotBeNull();
+        Assembly.LoadFrom(assemblyPath!).GetType("SelfMacroType").Should().NotBeNull(
+            "$self should expand to type/SelfMacro, finding its _Source code");
+    }
+
+    [Fact(Timeout = 25000)]
+    public async Task GetAssemblyLocationAsync_SourcesFiltersNonCodeChildren()
+    {
+        // Non-Code children in the _Source folder must never sneak into the
+        // compilation — the service always ANDs with nodeType:Code.
+        var persistence = new InMemoryPersistenceService();
+
+        var definition = new NodeTypeDefinition();
+        await SetupNodeType(persistence, "FilterType", definition, new CodeConfiguration
+        {
+            Code = @"
+public record FilterTypeA
+{
+    public string Id { get; init; } = string.Empty;
+}"
+        });
+
+        // A sibling non-Code node under _Source — must be ignored.
+        var junkNode = new MeshNode("notes", "type/FilterType/_Source")
+        {
+            NodeType = "Markdown",
+            Name = "Notes",
+            Content = "# not code"
+        };
+        await persistence.SaveNodeAsync(junkNode, SetupJsonOptions, TestContext.Current.CancellationToken);
+
+        var service = CreateService(persistence);
+        var node = MeshNode.FromPath("org/filter/one") with
+        {
+            Name = "One",
+            NodeType = "type/FilterType",
+            LastModified = DateTimeOffset.UtcNow
+        };
+
+        var assemblyPath = await service.GetAssemblyLocationAsync(node, TestContext.Current.CancellationToken);
+
+        assemblyPath.Should().NotBeNull(
+            "non-Code children must not break compilation — the nodeType:Code filter excludes them");
+        Assembly.LoadFrom(assemblyPath!).GetType("FilterTypeA").Should().NotBeNull();
+    }
+
+    [Fact(Timeout = 25000)]
+    public async Task GetAssemblyLocationAsync_SourcesWithMultipleLocations_PullsInExternalCode()
+    {
+        // This is the SocialMedia scenario: Profile NodeType needs Platform.cs
+        // which lives under Post's _Source folder. Without `Sources` this fails;
+        // with `Sources` listing both paths it compiles.
+        var persistence = new InMemoryPersistenceService();
+
+        // "Post" NodeType with shared Platform.cs in its _Source.
+        var postDef = new NodeTypeDefinition
+        {
+            Configuration = "config => config.WithContentType<Post>()"
+        };
+        await SetupNodeType(persistence, "Post", postDef, new CodeConfiguration
+        {
+            Code = @"
+public record Platform
+{
+    public string Id { get; init; } = string.Empty;
+    public static readonly Platform[] All = [];
+}
+public record Post
+{
+    public string Id { get; init; } = string.Empty;
+}"
+        });
+
+        // "Profile" NodeType with its own SocialMediaProfile, AND Sources pointing
+        // at Post's _Source so it can reference Platform.
+        var profileDef = new NodeTypeDefinition
+        {
+            Configuration = "config => config.WithContentType<Profile>()",
+            Sources =
+            [
+                "namespace:$self/_Source scope:subtree",
+                "namespace:type/Post/_Source scope:subtree"
+            ]
+        };
+        await SetupNodeType(persistence, "Profile", profileDef, new CodeConfiguration
+        {
+            Code = @"
+public record Profile
+{
+    public string Id { get; init; } = string.Empty;
+    public Platform? Platform { get; init; }
+}"
+        });
+
+        var service = CreateService(persistence);
+        var node = MeshNode.FromPath("org/profiles/alice") with
+        {
+            Name = "Alice",
+            NodeType = "type/Profile",
+            LastModified = DateTimeOffset.UtcNow
+        };
+
+        var assemblyPath = await service.GetAssemblyLocationAsync(node, TestContext.Current.CancellationToken);
+
+        assemblyPath.Should().NotBeNull("Profile should compile with external Platform from Post/_Source");
+        var assembly = Assembly.LoadFrom(assemblyPath!);
+        assembly.GetType("Profile").Should().NotBeNull();
+        assembly.GetType("Platform").Should().NotBeNull("Platform from Post/_Source must be included");
+    }
+
+    [Fact(Timeout = 25000)]
+    public async Task GetAssemblyLocationAsync_SourcesOverlap_DedupesSharedNode()
+    {
+        // When two source queries both match the same Code node, we must not
+        // compile its types twice (compiler would reject duplicates).
+        var persistence = new InMemoryPersistenceService();
+
+        var definition = new NodeTypeDefinition
+        {
+            Sources =
+            [
+                "namespace:$self/_Source scope:subtree",
+                "namespace:type/Overlap/_Source" // matches the same node
+            ]
+        };
+        await SetupNodeType(persistence, "Overlap", definition, new CodeConfiguration
+        {
+            Code = @"
+public record OverlapType
+{
+    public string Value { get; init; } = string.Empty;
+}"
+        });
+
+        var service = CreateService(persistence);
+        var node = MeshNode.FromPath("org/overlaps/one") with
+        {
+            Name = "One",
+            NodeType = "type/Overlap",
+            LastModified = DateTimeOffset.UtcNow
+        };
+
+        var assemblyPath = await service.GetAssemblyLocationAsync(node, TestContext.Current.CancellationToken);
+
+        assemblyPath.Should().NotBeNull(
+            "overlapping source queries must be deduped so the same type isn't compiled twice");
+        Assembly.LoadFrom(assemblyPath!).GetType("OverlapType").Should().NotBeNull();
+    }
+
+    /// <summary>
+    /// Regression: Code nodes persisted via MCP set MainNode to the parent _Source
+    /// folder (satellite pattern). <c>InMemoryPersistenceService.GetDescendantsAsync</c>
+    /// excludes every node where <c>MainNode != Path</c>, so the compile-path
+    /// source discovery was seeing zero Code files and the NodeType kept failing
+    /// to compile with "type not found" — even though the Code nodes were in
+    /// persistence. <c>NodeTypeService.GatherInputsAsync</c> must find them
+    /// via the query-provider pipeline, which has no satellite filter.
+    /// </summary>
+    [Fact(Timeout = 25000)]
+    public async Task NodeTypeService_CompilesNodeType_WhenCodeNodesAreSatellites()
+    {
+        // Arrange: NodeType + satellite Code node (MainNode != Path).
+        var persistence = new InMemoryPersistenceService();
+        var nodeTypePath = $"type/Satellite_{Guid.NewGuid():N}";
+        var sourceNs = $"{nodeTypePath}/_Source";
+
+        var nodeTypeDef = new NodeTypeDefinition
+        {
+            Configuration = "config => config.WithContentType<SatelliteModel>()"
+        };
+        var nodeTypeNode = MeshNode.FromPath(nodeTypePath) with
+        {
+            Name = "Satellite",
+            NodeType = MeshNode.NodeTypePath,
+            Content = nodeTypeDef,
+            LastModified = DateTimeOffset.UtcNow
+        };
+        await persistence.SaveNodeAsync(nodeTypeNode, SetupJsonOptions, TestContext.Current.CancellationToken);
+
+        // Explicit MainNode = parent _Source folder — this is the satellite pattern
+        // that the persistence layer's GetDescendantsAsync filters out.
+        var satelliteCode = new MeshNode("SatelliteModel", sourceNs)
+        {
+            NodeType = "Code",
+            Name = "Satellite Model",
+            Content = new CodeConfiguration
+            {
+                Code = @"
+public record SatelliteModel
+{
+    public string Id { get; init; } = string.Empty;
+}",
+                Language = "csharp"
+            },
+            MainNode = sourceNs,  // ← satellite marker — the bug trigger
+            LastModified = DateTimeOffset.UtcNow
+        };
+        await persistence.SaveNodeAsync(satelliteCode, SetupJsonOptions, TestContext.Current.CancellationToken);
+
+        // Sanity check: satellite exclusion is actually active in storage
+        var descendants = new List<MeshNode>();
+        await foreach (var d in persistence.GetDescendantsAsync(sourceNs, SetupJsonOptions))
+            descendants.Add(d);
+        descendants.Should().BeEmpty(
+            "this guards the regression: GetDescendantsAsync filters out satellites — " +
+            "so any compile path that uses it to discover Code nodes will see zero files");
+
+        // Act: wire up the full service graph and ask NodeTypeService to enrich the
+        // NodeType, which triggers CompileWithReleaseAsync → GatherInputsAsync.
+        var nodeTypeService = CreateNodeTypeService(persistence);
+        var enriched = await nodeTypeService.EnrichWithNodeTypeAsync(
+            MeshNode.FromPath($"inst/Alice") with
+            {
+                NodeType = nodeTypePath,
+                LastModified = DateTimeOffset.UtcNow
+            },
+            TestContext.Current.CancellationToken);
+
+        // Assert: compilation succeeded — the SatelliteModel type is reachable.
+        nodeTypeService.GetCompilationError(nodeTypePath).Should().BeNull(
+            "compilation must succeed for satellite-pattern Code nodes. " +
+            "If this fails with 'SatelliteModel could not be found', the compile " +
+            "path is back to using meshStorage.GetDescendantsAsync (which excludes satellites) " +
+            "instead of the query-provider pipeline.");
+        enriched.AssemblyLocation.Should().NotBeNullOrEmpty(
+            "assembly should compile and its location returned");
+    }
+
+    private NodeTypeService CreateNodeTypeService(InMemoryPersistenceService persistence)
+    {
+        IServiceCollection services = new ServiceCollection();
+        services.AddInMemoryPersistence(persistence);
+        services.AddScoped<IMessageHub>(_ => _mockHub);
+        services.AddSingleton(new MeshConfiguration(new Dictionary<string, MeshNode>()));
+        services.AddSingleton(_cacheService);
+        services.AddSingleton(_cacheOptions);
+        services.AddSingleton(NullLogger<MeshNodeCompilationService>.Instance);
+        services.AddSingleton(NullLogger<NodeTypeService>.Instance);
+        services.AddSingleton<MeshNodeCompilationService>();
+        services.AddLogging();
+
+        var sp = services.BuildServiceProvider();
+        var hubSp = NSubstitute.Substitute.For<IServiceProvider>();
+        hubSp.GetService(Arg.Any<Type>()).Returns(ci => sp.GetService(ci.Arg<Type>()));
+        _mockHub.ServiceProvider.Returns(hubSp);
+
+        var scope = sp.CreateScope();
+        // ActivatorUtilities resolves the constructor parameters via DI — no need to
+        // name the (internal) IMeshStorage type here.
+        return ActivatorUtilities.CreateInstance<NodeTypeService>(scope.ServiceProvider);
+    }
+
+    [Theory(Timeout = 25000)]
+    [InlineData("@", "single-at")]
+    [InlineData("@@", "double-at")]
+    public async Task GetAssemblyLocationAsync_SourcesWithAtPrefixShorthand_ResolvesSingleNode(string prefix, string suffix)
+    {
+        // Shorthand: "@path" / "@@path" in a Sources line means "this one Code node".
+        // No need to spell out "path:..." — the compilation service normalises it.
+        var persistence = new InMemoryPersistenceService();
+
+        var sharedTypeName = $"Shared_{suffix}";
+        var consumerTypeName = $"Consumer_{suffix}";
+
+        var sharedDef = new NodeTypeDefinition();
+        await SetupNodeType(persistence, sharedTypeName, sharedDef, new CodeConfiguration
+        {
+            Code = $@"
+public record SharedHelper_{suffix.Replace("-", "_")}
+{{
+    public static string Greet() => ""hi"";
+}}"
+        });
+
+        var consumerDef = new NodeTypeDefinition
+        {
+            Sources = [$"{prefix}type/{sharedTypeName}/_Source/code"]
+        };
+        await SetupNodeType(persistence, consumerTypeName, consumerDef);
+
+        var service = CreateService(persistence);
+        var node = MeshNode.FromPath($"org/consumers/{suffix}") with
+        {
+            Name = "One",
+            NodeType = $"type/{consumerTypeName}",
+            LastModified = DateTimeOffset.UtcNow
+        };
+
+        var assemblyPath = await service.GetAssemblyLocationAsync(node, TestContext.Current.CancellationToken);
+
+        assemblyPath.Should().NotBeNull($"'{prefix}path' shorthand should resolve to the Shared Code node");
+        var expectedTypeName = $"SharedHelper_{suffix.Replace("-", "_")}";
+        Assembly.LoadFrom(assemblyPath!).GetType(expectedTypeName).Should().NotBeNull();
+    }
 }
diff --git a/test/MeshWeaver.Hosting.Blazor.Test/NavigationServiceTest.cs b/test/MeshWeaver.Hosting.Blazor.Test/NavigationServiceTest.cs
index 229e00b22..565f8b266 100644
--- a/test/MeshWeaver.Hosting.Blazor.Test/NavigationServiceTest.cs
+++ b/test/MeshWeaver.Hosting.Blazor.Test/NavigationServiceTest.cs
@@ -479,6 +479,97 @@ public async Task Dispose_UnsubscribesFromLocationChanged()
 
     #endregion
 
+    #region Satellite Node Tests
+
+    [Fact]
+    public async Task OnLocationChanged_SatelliteNode_CurrentNamespacePointsAtMainNode()
+    {
+        // User browses to a thread under PartnerRe/AIConsulting. The thread node's MainNode
+        // points back at the parent that owns it, so CurrentNamespace — which downstream
+        // chat/autocomplete/attachment code uses to resolve relative paths — must surface
+        // the main node, not the satellite path.
+        var service = CreateService();
+        const string SatellitePath = "PartnerRe/AIConsulting/_Thread/abc-123";
+        const string MainNode = "PartnerRe/AIConsulting";
+
+        _pathResolver.ResolvePathAsync(Arg.Any<string>())
+            .Returns(new AddressResolution(SatellitePath, null));
+
+        var threadNode = new MeshNode("abc-123", "PartnerRe/AIConsulting/_Thread")
+        {
+            NodeType = "Thread",
+            MainNode = MainNode
+        };
+        _meshQuery.QueryAsync(Arg.Any<MeshQueryRequest>(), Arg.Any<CancellationToken>())
+            .Returns(ToAsyncObjects(threadNode));
+
+        await service.InitializeAsync();
+
+        service.CurrentNamespace.Should().Be(MainNode);
+        service.Context!.Namespace.Should().Be(SatellitePath);
+        service.Context.PrimaryPath.Should().Be(MainNode);
+        service.Context.IsSatellite.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task OnLocationChanged_RegularNode_CurrentNamespaceMatchesNamespace()
+    {
+        // For a non-satellite node, CurrentNamespace and Namespace are the same.
+        // PrimaryPath falls back to Namespace when Node is null, so this also covers
+        // the no-node-found path (existing tests rely on this fallback).
+        var service = CreateService();
+        _pathResolver.ResolvePathAsync(Arg.Any<string>())
+            .Returns(new AddressResolution("PartnerRe/AIConsulting", null));
+
+        var mainNode = new MeshNode("AIConsulting", "PartnerRe")
+        {
+            NodeType = "Group"
+            // MainNode defaults to Path → "PartnerRe/AIConsulting"
+        };
+        _meshQuery.QueryAsync(Arg.Any<MeshQueryRequest>(), Arg.Any<CancellationToken>())
+            .Returns(ToAsyncObjects(mainNode));
+
+        await service.InitializeAsync();
+
+        service.CurrentNamespace.Should().Be("PartnerRe/AIConsulting");
+        service.Context!.PrimaryPath.Should().Be("PartnerRe/AIConsulting");
+        service.Context.IsSatellite.Should().BeFalse();
+    }
+
+    [Fact]
+    public async Task OnLocationChanged_SatelliteNode_LoadsCreatableTypesForMainNode()
+    {
+        // The creatable-types background load also keys off PrimaryPath so menus on
+        // satellite pages reflect what can be created on the parent node.
+        var service = CreateService();
+        _pathResolver.ResolvePathAsync(Arg.Any<string>())
+            .Returns(new AddressResolution("PartnerRe/AIConsulting/_Thread/abc-123", null));
+
+        var threadNode = new MeshNode("abc-123", "PartnerRe/AIConsulting/_Thread")
+        {
+            NodeType = "Thread",
+            MainNode = "PartnerRe/AIConsulting"
+        };
+        _meshQuery.QueryAsync(Arg.Any<MeshQueryRequest>(), Arg.Any<CancellationToken>())
+            .Returns(ToAsyncObjects(threadNode));
+
+        _nodeTypeService
+            .GetCreatableTypesAsync("PartnerRe/AIConsulting", Arg.Any<CancellationToken>())
+            .Returns(ToAsyncEnumerable(new CreatableTypeInfo("PartnerRe/AIConsulting/Story")));
+
+        CreatableTypesSnapshot? lastSnapshot = null;
+        service.CreatableTypes.Subscribe(s => lastSnapshot = s);
+
+        await service.InitializeAsync();
+        await Task.Delay(150, TestContext.Current.CancellationToken);
+
+        _nodeTypeService.Received().GetCreatableTypesAsync(
+            "PartnerRe/AIConsulting", Arg.Any<CancellationToken>());
+        lastSnapshot!.Items.Should().Contain(t => t.NodeTypePath == "PartnerRe/AIConsulting/Story");
+    }
+
+    #endregion
+
     #region Helper Methods
 
     private static async IAsyncEnumerable<CreatableTypeInfo> ToAsyncEnumerable(params CreatableTypeInfo[] items)
@@ -490,6 +581,15 @@ private static async IAsyncEnumerable<CreatableTypeInfo> ToAsyncEnumerable(param
         await Task.CompletedTask;
     }
 
+    private static async IAsyncEnumerable<object> ToAsyncObjects(params object[] items)
+    {
+        foreach (var item in items)
+        {
+            yield return item;
+        }
+        await Task.CompletedTask;
+    }
+
     private static async IAsyncEnumerable<CreatableTypeInfo> ToAsyncEnumerableWithDelay(
         params CreatableTypeInfo[] items)
     {
diff --git a/test/MeshWeaver.Hosting.Monolith.Test/DeleteLayoutAreaIntegrationTest.cs b/test/MeshWeaver.Hosting.Monolith.Test/DeleteLayoutAreaIntegrationTest.cs
index 31821f849..e4af538b1 100644
--- a/test/MeshWeaver.Hosting.Monolith.Test/DeleteLayoutAreaIntegrationTest.cs
+++ b/test/MeshWeaver.Hosting.Monolith.Test/DeleteLayoutAreaIntegrationTest.cs
@@ -1,4 +1,6 @@
+using System;
 using System.Linq;
+using System.Reactive.Linq;
 using System.Threading.Tasks;
 using FluentAssertions;
 using FluentAssertions.Extensions;
@@ -93,4 +95,85 @@ await NodeFactory.CreateNodeAsync(
             .ToListAsync(TestContext.Current.CancellationToken);
         children.Should().BeEmpty("all children should be deleted");
     }
+
+    /// <summary>
+    /// Replicates the exact production pattern the Delete click handler must use:
+    /// <c>hub.Post(new DeleteNodeRequest(...)) + hub.RegisterCallback(...)</c>.
+    /// No <c>await</c> on the delete path — the callback drives a <see cref="TaskCompletionSource{T}"/>
+    /// which the test awaits at the xunit boundary only. A blocked hub cannot produce a callback,
+    /// so the 10 s WaitAsync guard fails the test instead of hanging forever.
+    /// </summary>
+    [Fact(Timeout = 20000)]
+    public async Task DeleteNode_PostRegisterCallback_DoesNotDeadlock()
+    {
+        var nodePath = $"{TestPartition}/del-reactive";
+        await NodeFactory.CreateNodeAsync(
+            new MeshNode("del-reactive", TestPartition) { Name = "Reactive Delete", NodeType = "Markdown" });
+
+        var client = GetClient();
+        var nodeAddress = new Address(nodePath);
+        await client.AwaitResponse(
+            new PingRequest(),
+            o => o.WithTarget(nodeAddress),
+            TestContext.Current.CancellationToken);
+
+        var nodeHub = Mesh.GetHostedHub(nodeAddress, HostedHubCreation.Never)!;
+
+        // Production pattern: Post + RegisterCallback. No await on the hub-bound path.
+        var tcs = new TaskCompletionSource<DeleteNodeResponse>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var delivery = nodeHub.Post(new DeleteNodeRequest(nodePath) { Recursive = true })!;
+        _ = nodeHub.RegisterCallback(delivery, (d, _) =>
+        {
+            tcs.TrySetResult(((IMessageDelivery<DeleteNodeResponse>)d).Message);
+            return Task.FromResult<IMessageDelivery>(d);
+        });
+
+        var response = await tcs.Task.WaitAsync(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken);
+        response.Success.Should().BeTrue($"delete should succeed (error: {response.Error})");
+
+        var lookup = await MeshQuery.QueryAsync<MeshNode>($"path:{nodePath}")
+            .FirstOrDefaultAsync(TestContext.Current.CancellationToken);
+        lookup.Should().BeNull("node should be gone after Post+RegisterCallback delete");
+    }
+
+    /// <summary>
+    /// Recursive delete via Post + RegisterCallback. Verifies DeleteSelfFromStorage
+    /// posts the success response BEFORE issuing the storage write, so a hub that
+    /// gets torn down by the storage delete still delivers its reply to the caller.
+    /// </summary>
+    [Fact(Timeout = 20000)]
+    public async Task DeleteNode_PostRegisterCallback_Recursive_DoesNotDeadlock()
+    {
+        await NodeFactory.CreateNodeAsync(
+            new MeshNode("del-rec-parent", TestPartition) { Name = "Parent", NodeType = "Group" });
+        await NodeFactory.CreateNodeAsync(
+            new MeshNode("c1", $"{TestPartition}/del-rec-parent") { Name = "C1", NodeType = "Markdown" });
+        await NodeFactory.CreateNodeAsync(
+            new MeshNode("c2", $"{TestPartition}/del-rec-parent") { Name = "C2", NodeType = "Markdown" });
+
+        var parentPath = $"{TestPartition}/del-rec-parent";
+        var client = GetClient();
+        await client.AwaitResponse(new PingRequest(), o => o.WithTarget(new Address(parentPath)),
+            TestContext.Current.CancellationToken);
+
+        var parentHub = Mesh.GetHostedHub(new Address(parentPath), HostedHubCreation.Never)!;
+
+        var tcs = new TaskCompletionSource<DeleteNodeResponse>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var delivery = parentHub.Post(new DeleteNodeRequest(parentPath) { Recursive = true })!;
+        _ = parentHub.RegisterCallback(delivery, (d, _) =>
+        {
+            tcs.TrySetResult(((IMessageDelivery<DeleteNodeResponse>)d).Message);
+            return Task.FromResult<IMessageDelivery>(d);
+        });
+
+        var response = await tcs.Task.WaitAsync(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken);
+        response.Success.Should().BeTrue($"recursive delete should succeed (error: {response.Error})");
+
+        var parent = await MeshQuery.QueryAsync<MeshNode>($"path:{parentPath}")
+            .FirstOrDefaultAsync(TestContext.Current.CancellationToken);
+        parent.Should().BeNull();
+        var children = await MeshQuery.QueryAsync<MeshNode>($"namespace:{parentPath}")
+            .ToListAsync(TestContext.Current.CancellationToken);
+        children.Should().BeEmpty();
+    }
 }
diff --git a/test/MeshWeaver.Layout.Test/ChatSubmissionHandlerTest.cs b/test/MeshWeaver.Layout.Test/ChatSubmissionHandlerTest.cs
index c788c2708..3d8dfe416 100644
--- a/test/MeshWeaver.Layout.Test/ChatSubmissionHandlerTest.cs
+++ b/test/MeshWeaver.Layout.Test/ChatSubmissionHandlerTest.cs
@@ -260,6 +260,48 @@ public void StateTracking_IsAccurate()
         Assert.Equal(2, handler.SubmissionCount);
     }
 
+    /// <summary>
+    /// Reproduces the prod "twice generating response" symptom: ThreadChatView.SubmitMessageCore
+    /// calls ForceRelease immediately after Submit so the input stays enabled for queueing.
+    /// A double-click (or Enter+button race) then re-enters TryBeginSubmit with the SAME text
+    /// — the state is already Idle, so the second call wrongly succeeds, the second user cell
+    /// is created, and the server watcher dispatches a second round.
+    /// </summary>
+    [Fact]
+    public void DoubleClick_SameTextWithinDebounce_RejectsSecondSubmission()
+    {
+        var (handler, _) = CreateWithControllableTimeout();
+
+        // 1st click: accepted
+        Assert.True(handler.TryBeginSubmit("Hello"));
+        Assert.Equal(1, handler.SubmissionCount);
+
+        // SubmitMessageCore force-releases immediately so the user can keep typing.
+        handler.ForceRelease();
+
+        // 2nd click of the same text within the dedup window — must be rejected.
+        Assert.False(handler.TryBeginSubmit("Hello"),
+            "duplicate Send within the debounce window should be ignored");
+        Assert.Equal(1, handler.SubmissionCount);
+    }
+
+    /// <summary>
+    /// Genuinely different text after force-release must still go through — that's the
+    /// queueing UX (user types another message while the previous is processing).
+    /// </summary>
+    [Fact]
+    public void ForceRelease_ThenDifferentText_SecondSubmissionAccepted()
+    {
+        var (handler, _) = CreateWithControllableTimeout();
+
+        Assert.True(handler.TryBeginSubmit("Hello"));
+        handler.ForceRelease();
+
+        Assert.True(handler.TryBeginSubmit("How are you"),
+            "different text after force-release is a real second submission, must go through");
+        Assert.Equal(2, handler.SubmissionCount);
+    }
+
     [Fact]
     public void ConcurrentSubmitAttempts_OnlyOneSucceeds()
     {
diff --git a/test/MeshWeaver.Markdown.Test/PathUtilsTest.cs b/test/MeshWeaver.Markdown.Test/PathUtilsTest.cs
new file mode 100644
index 000000000..ffbe6863c
--- /dev/null
+++ b/test/MeshWeaver.Markdown.Test/PathUtilsTest.cs
@@ -0,0 +1,185 @@
+using FluentAssertions;
+using Markdig;
+using Xunit;
+
+namespace MeshWeaver.Markdown.Test;
+
+/// <summary>
+/// Tests for <see cref="PathUtils"/>: relative path resolution and satellite partition stripping.
+/// Satellite partitions (segments starting with '_', e.g., _Thread, _Comment) are stripped
+/// so that links in satellite content resolve relative to the main entity.
+/// </summary>
+public class PathUtilsTest
+{
+    // ---------- Satellite partition stripping (tested via ResolveRelativePath) ----------
+
+    [Theory]
+    [InlineData("X", "A/B/_Thread/slug/msg", "A/B/X")]
+    [InlineData("X", "A/B/_Comment/abc123", "A/B/X")]
+    [InlineData("X", "A/B/_Tracking/change1", "A/B/X")]
+    [InlineData("X", "A/_Thread/slug", "A/X")]
+    [InlineData("X", "_Thread/slug/msg", "X")]
+    [InlineData("X", "A/B/C", "A/B/C/X")]  // no satellite — unchanged
+    public void ResolveRelativePath_StripsSatellitePartitions(string path, string basePath, string expected)
+        => PathUtils.ResolveRelativePath(path, basePath).Should().Be(expected);
+
+    // ---------- ResolveRelativePath with satellite partitions ----------
+
+    [Fact]
+    public void ResolveRelativePath_ThreadContext_ResolvesRelativeToMainEntity()
+    {
+        // A relative link "FinalReport" in a thread message should resolve
+        // to the main entity's namespace, not the thread path.
+        var result = PathUtils.ResolveRelativePath(
+            "FinalReport",
+            "PartnerRe/AIConsulting/_Thread/we-will-now-work-on-97af/d75effc1");
+
+        result.Should().Be("PartnerRe/AIConsulting/FinalReport");
+    }
+
+    [Fact]
+    public void ResolveRelativePath_CommentContext_ResolvesRelativeToMainEntity()
+    {
+        var result = PathUtils.ResolveRelativePath(
+            "Appendix",
+            "Doc/Architecture/_Comment/abc123");
+
+        result.Should().Be("Doc/Architecture/Appendix");
+    }
+
+    [Fact]
+    public void ResolveRelativePath_ParentTraversal_InThreadContext()
+    {
+        // "../OtherProject" from PartnerRe/AIConsulting/_Thread/... should go up from AIConsulting
+        var result = PathUtils.ResolveRelativePath(
+            "../OtherProject",
+            "PartnerRe/AIConsulting/_Thread/slug/msgId");
+
+        result.Should().Be("PartnerRe/OtherProject");
+    }
+
+    [Fact]
+    public void ResolveRelativePath_DotSlash_InThreadContext()
+    {
+        var result = PathUtils.ResolveRelativePath(
+            "./FinalReport",
+            "PartnerRe/AIConsulting/_Thread/slug/msgId");
+
+        result.Should().Be("PartnerRe/AIConsulting/FinalReport");
+    }
+
+    // ---------- ResolveRelativePath (non-satellite, existing behavior) ----------
+
+    [Fact]
+    public void ResolveRelativePath_NormalContext_ResolvesRelatively()
+    {
+        var result = PathUtils.ResolveRelativePath(
+            "DataModeling",
+            "Doc/Architecture");
+
+        result.Should().Be("Doc/Architecture/DataModeling");
+    }
+
+    [Fact]
+    public void ResolveRelativePath_ParentTraversal_NormalContext()
+    {
+        var result = PathUtils.ResolveRelativePath(
+            "../DataMesh/NodeTypes",
+            "Doc/Architecture/BusinessRules");
+
+        result.Should().Be("Doc/Architecture/DataMesh/NodeTypes");
+    }
+
+    [Theory]
+    [InlineData("/absolute/path")]
+    [InlineData("https://example.com")]
+    [InlineData("#anchor")]
+    [InlineData("mailto:test@example.com")]
+    public void ResolveRelativePath_SkipsNonRelativePaths(string path)
+        => PathUtils.ResolveRelativePath(path, "Doc/Architecture").Should().Be(path);
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    public void ResolveRelativePath_NullOrEmptyBase_ReturnsPathUnchanged(string? basePath)
+        => PathUtils.ResolveRelativePath("FinalReport", basePath).Should().Be("FinalReport");
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    public void ResolveRelativePath_NullOrEmptyPath_ReturnsAsIs(string? path)
+        => PathUtils.ResolveRelativePath(path!, "Doc/Architecture").Should().Be(path!);
+
+    // ---------- End-to-end: LinkUrlCleanupExtension in thread context ----------
+
+    [Fact]
+    public void LinkCleanup_ThreadContext_RelativeLinkResolvesToMainEntity()
+    {
+        // Simulate rendering markdown in a thread message bubble.
+        // The currentNodePath is the thread message's full path.
+        var threadMsgPath = "PartnerRe/AIConsulting/_Thread/thread-slug/msgId";
+        var pipeline = new MarkdownPipelineBuilder()
+            .Use(new LinkUrlCleanupExtension(threadMsgPath))
+            .Build();
+
+        var html = Markdig.Markdown.ToHtml("[Final Report](FinalReport)", pipeline);
+
+        html.Should().Contain("href=\"/PartnerRe/AIConsulting/FinalReport\"",
+            "relative link in thread should resolve to main entity path");
+    }
+
+    [Fact]
+    public void LinkCleanup_ThreadContext_AbsoluteLinkUnchanged()
+    {
+        var threadMsgPath = "PartnerRe/AIConsulting/_Thread/slug/msgId";
+        var pipeline = new MarkdownPipelineBuilder()
+            .Use(new LinkUrlCleanupExtension(threadMsgPath))
+            .Build();
+
+        var html = Markdig.Markdown.ToHtml("[Report](/PartnerRe/AIConsulting/FinalReport)", pipeline);
+
+        html.Should().Contain("href=\"/PartnerRe/AIConsulting/FinalReport\"",
+            "absolute links should remain unchanged");
+    }
+
+    [Fact]
+    public void LinkCleanup_ThreadContext_AtPrefixedLinkResolvesToMainEntity()
+    {
+        var threadMsgPath = "PartnerRe/AIConsulting/_Thread/slug/msgId";
+        var pipeline = new MarkdownPipelineBuilder()
+            .Use(new LinkUrlCleanupExtension(threadMsgPath))
+            .Build();
+
+        // @SiblingDoc — after stripping '@', should resolve relative to main entity
+        var html = Markdig.Markdown.ToHtml("[doc](@SiblingDoc)", pipeline);
+
+        html.Should().Contain("href=\"/PartnerRe/AIConsulting/SiblingDoc\"",
+            "@-prefixed relative link in thread should resolve to main entity path");
+    }
+
+    [Fact]
+    public void LinkCleanup_ThreadContext_ExternalLinkUnchanged()
+    {
+        var threadMsgPath = "Org/Project/_Thread/slug/msgId";
+        var pipeline = new MarkdownPipelineBuilder()
+            .Use(new LinkUrlCleanupExtension(threadMsgPath))
+            .Build();
+
+        var html = Markdig.Markdown.ToHtml("[Google](https://google.com)", pipeline);
+
+        html.Should().Contain("href=\"https://google.com\"");
+    }
+
+    [Fact]
+    public void LinkCleanup_NonThreadContext_RelativeLinkResolvesNormally()
+    {
+        // Normal (non-satellite) context should still work as before.
+        var pipeline = new MarkdownPipelineBuilder()
+            .Use(new LinkUrlCleanupExtension("Doc/Architecture"))
+            .Build();
+
+        var html = Markdig.Markdown.ToHtml("[Data](DataModeling)", pipeline);
+
+        html.Should().Contain("href=\"/Doc/Architecture/DataModeling\"");
+    }
+}
diff --git a/test/MeshWeaver.Security.Test/McpAccessControlTests.cs b/test/MeshWeaver.Security.Test/McpAccessControlTests.cs
index 18cb0fdc3..e453140d1 100644
--- a/test/MeshWeaver.Security.Test/McpAccessControlTests.cs
+++ b/test/MeshWeaver.Security.Test/McpAccessControlTests.cs
@@ -83,7 +83,7 @@ private async Task LoginWithToken(string rawToken)
         var accessService = Mesh.ServiceProvider.GetRequiredService<AccessService>();
         accessService.SetCircuitContext(new AccessContext
         {
-            ObjectId = response.UserEmail!,
+            ObjectId = response.UserId ?? response.UserEmail!,
             Name = response.UserName ?? "",
             Email = response.UserEmail!,
         });
diff --git a/test/MeshWeaver.Security.Test/MenuAccessControlTest.cs b/test/MeshWeaver.Security.Test/MenuAccessControlTest.cs
index a051b424f..776b33df9 100644
--- a/test/MeshWeaver.Security.Test/MenuAccessControlTest.cs
+++ b/test/MeshWeaver.Security.Test/MenuAccessControlTest.cs
@@ -153,8 +153,8 @@ await client.AwaitResponse(
             Output.WriteLine($"  {item.Label} (Area={item.Area})");
 
         items.Select(i => i.Label).Should().BeEquivalentTo(
-            ["Files", "Threads", "Versions"],
-            "Viewer has only Read — no Create, Update, Delete, or Export items (Settings is a dedicated header button)");
+            ["Files", "Threads", "Versions", "Pin"],
+            "Viewer has only Read — no Create, Update, Delete, or Export items (Pin requires no permission; Settings is a dedicated header button)");
     }
 
     [Fact(Timeout = 30000)]
@@ -181,10 +181,10 @@ await client.AwaitResponse(
         foreach (var item in items)
             Output.WriteLine($"  {item.Label} (Area={item.Area})");
 
-        // Editor gets Edit, Create, Copy, Import, Export, plus always-visible items
+        // Editor gets Edit, Create, Copy, Import, Export, Recycle (Update), Pin (None), plus always-visible items
         items.Select(i => i.Label).Should().BeEquivalentTo(
-            ["Edit", "Create", "Copy", "Import", "Files", "Export", "Threads", "Versions"],
-            "Editor has Read|Create|Update|Comment|Export — Edit/Create/Copy/Import/Export plus always-visible items (Settings is a dedicated header button)");
+            ["Edit", "Create", "Copy", "Import", "Files", "Export", "Threads", "Versions", "Pin", "Recycle"],
+            "Editor has Read|Create|Update|Comment|Export — Edit/Create/Copy/Import/Export/Recycle plus always-visible items and Pin (Settings is a dedicated header button)");
     }
 
     [Fact(Timeout = 30000)]
@@ -211,9 +211,9 @@ await client.AwaitResponse(
         foreach (var item in items)
             Output.WriteLine($"  {item.Label} (Area={item.Area})");
 
-        items.Should().HaveCount(10, "Admin should see all default menu items across Node and Mesh contexts (Settings is a dedicated header button)");
+        items.Should().HaveCount(12, "Admin should see all default menu items across Node and Mesh contexts (Settings is a dedicated header button)");
         items.Select(i => i.Label).Should().BeEquivalentTo(
-            ["Edit", "Create", "Copy", "Move", "Import", "Files", "Export", "Threads", "Versions", "Delete"]);
+            ["Edit", "Create", "Copy", "Move", "Import", "Files", "Export", "Threads", "Versions", "Delete", "Pin", "Recycle"]);
     }
 
     [Fact(Timeout = 30000)]
diff --git a/test/MeshWeaver.Threading.Test/ToolStatusFormatterTest.cs b/test/MeshWeaver.Threading.Test/ToolStatusFormatterTest.cs
index 1ff6b1055..2e7c7c603 100644
--- a/test/MeshWeaver.Threading.Test/ToolStatusFormatterTest.cs
+++ b/test/MeshWeaver.Threading.Test/ToolStatusFormatterTest.cs
@@ -135,8 +135,8 @@ public void ConvertReferences_InlinePathBecomesLink()
         method.Should().NotBeNull();
 
         var result = (string)method!.Invoke(null, ["Check out @User/rbuergi/agents-comparison for details"])!;
-        // Should produce markdown link with @prefix in href for LinkUrlCleanupExtension to resolve
-        result.Should().Contain("[`@User/rbuergi/agents-comparison`](@User/rbuergi/agents-comparison)");
+        // Should produce markdown link with absolute href (leading /)
+        result.Should().Contain("[`@User/rbuergi/agents-comparison`](/User/rbuergi/agents-comparison)");
     }
 
     [Fact]
diff --git a/test/xunit.runner.json b/test/xunit.runner.json
index c46ded3d8..534f03a1d 100644
--- a/test/xunit.runner.json
+++ b/test/xunit.runner.json
@@ -2,5 +2,5 @@
   "parallelizeAssembly": false,
   "parallelizeTestCollections": false,
   "maxParallelThreads": 1,
-  "methodTimeout": 30000
+  "methodTimeout": 60000
 }