From dde6d2ce2a1b83c1579e265bac255149251e539e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20B=C3=BCrgi?= <rbuergi@systemorph.com>
Date: Mon, 6 Jul 2026 10:52:09 +0200
Subject: [PATCH] fix(portal): delete redirects to parent via pure path; status
 bar single-row
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Delete: on a distributed portal the ancestor-existence walk (a Query per ancestor)
can hang cross-partition, stalling the redirect behind the 10s timeout while the
just-deleted node's area re-renders and errors (the 'reload then error'). When the
immediate parent is a SATELLITE grouping (_Thread, _Activity, …) — the common case,
e.g. deleting a thread — resolve the target by PURE PATH (skip satellite segments),
immediately, no query. Only a non-satellite virtual parent (…/Script) still needs the
existence walk; its fallback is the pure-path ancestor, never the maybe-virtual parent.

Status bar: .thread-chat-status-row was flex-wrap:wrap → stays one row (nowrap +
overflow:hidden); chips shrink (min-width:0) so long values ellipsis inline; model
chip title carries the full path for hover.

Tests: DeleteRedirectToExistingParentTest +NearestNonSatelliteAncestor (4/4).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../Chat/ThreadChatView.razor                 |  2 +-
 .../Chat/ThreadChatView.razor.css             |  9 ++-
 src/MeshWeaver.Graph/DeleteLayoutArea.cs      | 67 ++++++++++++++-----
 .../DeleteRedirectToExistingParentTest.cs     | 20 ++++++
 4 files changed, 80 insertions(+), 18 deletions(-)

diff --git a/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor b/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor
index 0b3ad071a..7469f8991 100644
--- a/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor
+++ b/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor
@@ -684,7 +684,7 @@ else
                     @if (!string.IsNullOrEmpty(boundModelPath))
                     {
                         <button type="button" class="thread-chat-status-item is-clickable"
-                                title="Model — click to change" @onclick='() => OnStatusChipClick("model", false)'>
+                                title="Model: @boundModelPath — click to change" @onclick='() => OnStatusChipClick("model", false)'>
                             @ChipSvg("model") @LastSegment(boundModelPath)
                         </button>
                     }
diff --git a/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor.css b/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor.css
index 82f484d06..e4c9da20e 100644
--- a/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor.css
+++ b/src/MeshWeaver.Blazor.Portal/Chat/ThreadChatView.razor.css
@@ -410,7 +410,10 @@
 .thread-chat-status-row {
     display: flex;
     align-items: center;
-    flex-wrap: wrap;
+    /* Single row — never wrap. Overflowing chips are clipped (each chip ellipsis-truncates its own
+       text via .thread-chat-status-item), and the full value is on the chip's title (hover). */
+    flex-wrap: nowrap;
+    overflow: hidden;
     gap: 10px;
     padding: 0 2px 6px 2px;
     font-size: 11px;
@@ -427,6 +430,10 @@
     overflow: hidden;
     text-overflow: ellipsis;
     max-width: 180px;
+    /* Allow the chip to shrink below its content width so its text ellipsis-truncates when the
+       single-row status bar runs out of horizontal room (min-width:auto would block the ellipsis). */
+    min-width: 0;
+    flex: 0 1 auto;
 }
 
 /* The chips are <button> now (clickable → picker/combobox). Strip native button chrome; keep the chip look. */
diff --git a/src/MeshWeaver.Graph/DeleteLayoutArea.cs b/src/MeshWeaver.Graph/DeleteLayoutArea.cs
index 946f3a2ed..812de2a3a 100644
--- a/src/MeshWeaver.Graph/DeleteLayoutArea.cs
+++ b/src/MeshWeaver.Graph/DeleteLayoutArea.cs
@@ -204,22 +204,32 @@ private static Task StartDelete(
                             if (response.Message is DeleteNodeResponse { Success: true })
                             {
                                 ctx.Host.UpdateData(progressId, DeleteStatus.Done);
-                                // Redirect to the nearest ancestor that is an ACTUAL mesh node.
-                                // The node we were looking at no longer exists, and its immediate
-                                // parent PATH is frequently a virtual grouping (e.g. ".../Script")
-                                // with no node of its own — redirecting straight there would just
-                                // land the user on another "No node found" page. Resolve the closest
-                                // existing ancestor instead; a top-level node (none) goes home. The
-                                // bare node URL renders that node's default area (Mesh URL shape).
-                                ResolveNearestExistingAncestor(meshQuery, nodePath)
-                                    .Take(1)
-                                    .Timeout(TimeSpan.FromSeconds(10))
-                                    .Catch<string?, Exception>(_ => Observable.Return(GetParentPath(nodePath)))
-                                    .Subscribe(ancestor =>
-                                    {
-                                        var target = ancestor is null ? "/" : $"/{ancestor}";
-                                        ctx.Host.UpdateArea(ctx.Area, new RedirectControl(target));
-                                    });
+                                // Redirect to the parent page. The node we were looking at no longer
+                                // exists, so we must leave its page FAST — otherwise the just-deleted
+                                // node's area re-renders against a gone node and errors (the "reload
+                                // then error"). Two paths:
+                                //  • The immediate parent is a SATELLITE grouping (_Thread, _Activity,
+                                //    …) — it has no node of its own, so resolve the target by PURE PATH
+                                //    (walk up past satellite segments) IMMEDIATELY, no query. This is
+                                //    the common case (a thread → the user's home) and, crucially, a
+                                //    distributed portal's cross-partition existence probe can't stall
+                                //    the redirect behind a timeout (which is what left the dead page up
+                                //    long enough to reload + error).
+                                //  • A NON-satellite parent (a virtual grouping like ".../Script") can
+                                //    only be told apart from a real node by asking — keep the existence
+                                //    walk there, but bounded, and fall back to the pure-path ancestor
+                                //    (never the maybe-virtual immediate parent) so the fallback can't
+                                //    land on another "No node found" page.
+                                var immediateParent = GetParentPath(nodePath);
+                                var target = IsSatelliteSegment(immediateParent)
+                                    ? Observable.Return(NearestNonSatelliteAncestor(nodePath))
+                                    : ResolveNearestExistingAncestor(meshQuery, nodePath)
+                                        .Take(1)
+                                        .Timeout(TimeSpan.FromSeconds(5))
+                                        .Catch<string?, Exception>(_ => Observable.Return(NearestNonSatelliteAncestor(nodePath)));
+                                target.Subscribe(ancestor =>
+                                    ctx.Host.UpdateArea(ctx.Area,
+                                        new RedirectControl(ancestor is null ? "/" : $"/{ancestor}")));
                             }
                             else
                             {
@@ -282,6 +292,31 @@ private static void ShowDialog(UiActionContext ctx, string title, string message
         return lastSlash > 0 ? path[..lastSlash] : null;
     }
 
+    /// <summary>Last segment of the path (the bit after the final '/'), or the whole path.</summary>
+    private static string LastSegment(string path)
+        => path[(path.LastIndexOf('/') + 1)..];
+
+    /// <summary>
+    /// True when the path's last segment is a SATELLITE grouping (<c>_Thread</c>, <c>_Activity</c>,
+    /// <c>_Comment</c>, …) — a '_'-prefixed segment that anchors satellites but is never a node of its
+    /// own. Redirecting there after a delete always lands on "No node found".
+    /// </summary>
+    private static bool IsSatelliteSegment(string? path)
+        => path is not null && LastSegment(path).StartsWith('_');
+
+    /// <summary>
+    /// Nearest ancestor whose last segment is NOT a satellite grouping — resolved by PURE PATH, no
+    /// query (so it can never stall on a distributed portal). A thread <c>{user}/_Thread/{id}</c>
+    /// resolves to <c>{user}</c>; a top-level node resolves to <c>null</c> (redirect home).
+    /// </summary>
+    internal static string? NearestNonSatelliteAncestor(string nodePath)
+    {
+        for (var p = GetParentPath(nodePath); p is not null; p = GetParentPath(p))
+            if (!LastSegment(p).StartsWith('_'))
+                return p;
+        return null;
+    }
+
     /// <summary>
     /// Resolves the nearest ANCESTOR of <paramref name="nodePath"/> that is an actual mesh node,
     /// walking up the path nearest-first. The immediate parent PATH segment is frequently a virtual
diff --git a/test/MeshWeaver.Hosting.Monolith.Test/DeleteRedirectToExistingParentTest.cs b/test/MeshWeaver.Hosting.Monolith.Test/DeleteRedirectToExistingParentTest.cs
index 26163a47b..bf67221d5 100644
--- a/test/MeshWeaver.Hosting.Monolith.Test/DeleteRedirectToExistingParentTest.cs
+++ b/test/MeshWeaver.Hosting.Monolith.Test/DeleteRedirectToExistingParentTest.cs
@@ -122,4 +122,24 @@ public async Task Redirect_goes_home_for_top_level_node()
         var target = await DeleteLayoutArea.ResolveNearestExistingAncestor(MeshSvc, "SomeTopLevelNode").Take(1).ToTask();
         target.Should().BeNull("a top-level node has no ancestor; the flow redirects home");
     }
+
+    /// <summary>
+    /// The satellite-parent fast path: deleting a node whose immediate parent is a satellite grouping
+    /// (a thread under <c>_Thread</c>, a comment under <c>_Comment</c>) resolves the redirect target by
+    /// PURE PATH — no query — so on a distributed portal a cross-partition existence probe can't stall
+    /// the redirect and leave the just-deleted page up long enough to reload + error. This is the case
+    /// the user hit deleting a thread.
+    /// </summary>
+    [Fact]
+    public void NearestNonSatelliteAncestor_skips_satellite_grouping()
+    {
+        // Thread {user}/_Thread/{id} → skip the _Thread satellite → the user's home.
+        Assert.Equal("rbuergi", DeleteLayoutArea.NearestNonSatelliteAncestor("rbuergi/_Thread/hello-6b4c"));
+        // Comment {thread}/_Comment/{id} → skip _Comment → the owning thread (a real node).
+        Assert.Equal("rbuergi/_Thread/hello", DeleteLayoutArea.NearestNonSatelliteAncestor("rbuergi/_Thread/hello/_Comment/c1"));
+        // A real immediate parent is kept as-is.
+        Assert.Equal("Acme/Sales", DeleteLayoutArea.NearestNonSatelliteAncestor("Acme/Sales/Q3"));
+        // Top-level node → null (redirect home).
+        Assert.Null(DeleteLayoutArea.NearestNonSatelliteAncestor("SomeTopLevelNode"));
+    }
 }