diff --git a/.github/workflows/ci-full.yml b/.github/workflows/ci-full.yml
index 7c416d4c..f95f81fc 100644
--- a/.github/workflows/ci-full.yml
+++ b/.github/workflows/ci-full.yml
@@ -37,6 +37,31 @@ jobs:
         shell: pwsh
         run: dotnet build Phantom.Workspaces.slnx -c Release --no-restore
 
+      # The SDK-staged copilot.exe is a server-only runtime (it rejects --version).
+      # BYOK tests need the full standalone CLI, pinned to the SDK's CLI version.
+      - name: Install Copilot CLI for BYOK tests
+        shell: pwsh
+        run: |
+          $version = '1.0.83' # GitHub.Copilot.SDK 1.0.13's CopilotCliVersion
+          $expectedSha256 = '0e07221a275fdf7e61619c53566e3a421fd646d74d8e9ca491dbbff221f22945'
+          $directory = Join-Path $PWD '.ci-tools\copilot'
+          New-Item -ItemType Directory -Path $directory -Force | Out-Null
+          $archive = Join-Path $directory 'copilot.zip'
+          Invoke-WebRequest "https://github.com/github/copilot-cli/releases/download/v$version/copilot-win32-x64.zip" -OutFile $archive
+          if ((Get-FileHash -LiteralPath $archive -Algorithm SHA256).Hash -ne $expectedSha256) {
+            throw "Copilot CLI archive hash mismatch"
+          }
+          Expand-Archive -LiteralPath $archive -DestinationPath $directory
+          $cli = Join-Path $directory 'copilot.exe'
+          if (-not (Test-Path -LiteralPath $cli -PathType Leaf)) {
+            throw "Standalone Copilot CLI not found: $cli"
+          }
+          & $cli --version
+          if ($LASTEXITCODE -ne 0) {
+            throw "Standalone Copilot CLI failed its version check (exit $LASTEXITCODE)"
+          }
+          "COPILOT_CLI_PATH=$cli" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
       # windows-latest cannot start the Linux MongoDB container, so exclude the
       # SlowDocker tests here; they run in the ubuntu-latest job below. Also exclude
       # RequiresLocalConsole: the hosted windows-latest ConPTY renders no cmd.exe/pwsh
@@ -47,7 +72,12 @@ jobs:
         shell: pwsh
         run: |
           dotnet test Phantom.Workspaces.slnx --no-restore --nologo -v minimal `
-            --filter "Category!=SlowDocker & Category!=RequiresLocalConsole"
+            -maxcpucount:1 `
+            --filter "Category!=SlowDocker & Category!=RequiresLocalConsole" 2>&1 |
+            Tee-Object -FilePath scripts/test-results.log
+          if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
+          }
 
       - name: Upload Windows test logs
         if: always()
@@ -73,11 +103,40 @@ jobs:
       - name: Set up build
         uses: ./.github/actions/setup-build
 
+      # Pull before the test host starts: Atlas Local's cold image download can exceed the
+      # test harness's per-test inactivity watchdog on a fresh hosted runner.
+      - name: Pull MongoDB Atlas Local image
+        run: docker pull mongodb/mongodb-atlas-local:latest
+
+      # The image runs as a non-root user. New bind directories created by .NET under
+      # the runner's default TMPDIR are owned by the runner and are not writable by MongoDB.
+      # Default ACLs also cover the unique directories created by the replica-set tests.
+      - name: Prepare writable MongoDB test mounts
+        shell: bash
+        run: |
+          if ! command -v setfacl >/dev/null; then
+            sudo apt-get update -qq
+            sudo apt-get install -y acl
+          fi
+          mongo_uid=$(docker run --rm --entrypoint id mongodb/mongodb-atlas-local:latest -u)
+          directory="$GITHUB_WORKSPACE/.ci-tools/mongodb-tmp"
+          mkdir -p "$directory"
+          setfacl -m "u:$mongo_uid:rwx,d:u:$mongo_uid:rwx" "$directory"
+          echo "TMPDIR=$directory" >> "$GITHUB_ENV"
+
       # Only the platform-agnostic data-layer Docker/Git integration tests run on
       # Linux; the Windows-only GUI/scheduled-task/junction tests run above.
       - name: Run Docker + Git integration tests
         shell: pwsh
-        run: .\scripts\run-tests.ps1 -Mode full -TestNames Phantom.Workspaces.Data.MongoDB.Tests
+        run: .\scripts\run-tests.ps1 -Mode full -TestNames Phantom.Workspaces.Data.MongoDB.Tests -PerTestHangTimeout 10m
+
+      - name: Diagnose MongoDB container on failure
+        if: failure()
+        run: |
+          docker ps -a --filter name=pw-mongodb-test
+          docker inspect pw-mongodb-test --format '{{json .State}}' || true
+          docker logs --tail 150 pw-mongodb-test 2>&1 || true
+          free -h
 
       - name: Upload Linux test logs
         if: always()
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c21aeb1a..3da798bb 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,7 +16,7 @@ jobs:
   build-and-test:
     name: Build and fast tests (windows-latest)
     runs-on: windows-latest
-    timeout-minutes: 10
+    timeout-minutes: 120
     env:
       AVALONIA_UI_LICENSE_KEY: ${{ secrets.AVALONIA_UI_LICENSE_KEY }}
     steps:
@@ -37,7 +37,7 @@ jobs:
         shell: pwsh
         run: |
           Write-Host 'Fast filter: Category!=SlowDocker & Category!=SlowGit & Category!=Integration & Category!=WebView & Category!=SlowLayout & Category!=RequiresLocalConsole'
-          .\scripts\run-tests.ps1 -Mode fast
+          .\scripts\run-tests.ps1 -Mode fast -PerTestHangTimeout 10m
 
       - name: Upload test results log
         if: always()
diff --git a/Phantom.Workspaces.Agent.Gui.Tests/AgentChatOutputControlTests.cs b/Phantom.Workspaces.Agent.Gui.Tests/AgentChatOutputControlTests.cs
index c3d8db66..4f091f43 100644
--- a/Phantom.Workspaces.Agent.Gui.Tests/AgentChatOutputControlTests.cs
+++ b/Phantom.Workspaces.Agent.Gui.Tests/AgentChatOutputControlTests.cs
@@ -78,7 +78,9 @@ public void ChatOutput_SuppressedAssistantHeaderWithInspectTargets_RemainsHidden
     {
         var html = ReadShellHtml();
         Assert.DoesNotContain("header.hidden = false", html, StringComparison.Ordinal);
-        Assert.Contains("header.hidden ? message.querySelector(\":scope > .chat-contents\") : meta", html, StringComparison.Ordinal);
+        Assert.Contains("var host = header.hidden", html, StringComparison.Ordinal);
+        Assert.Contains("message.querySelector(\":scope > .chat-contents > .chat-tool-group-actions\")", html, StringComparison.Ordinal);
+        Assert.Contains("message.querySelector(\":scope > .chat-contents\")", html, StringComparison.Ordinal);
         Assert.Contains("postToHost({", html, StringComparison.Ordinal);
         Assert.Contains("type: \"inspect\"", html, StringComparison.Ordinal);
         Assert.Contains("CopyGutter.init(document)", html, StringComparison.Ordinal);
@@ -98,8 +100,11 @@ public void ChatOutputShellHtml_UsageInspectAffordance_DeduplicatesPerMessage()
     {
         var html = ReadShellHtml();
 
-        Assert.Contains("meta.querySelector(\".usage-gutter-btn\")", html, StringComparison.Ordinal);
-        Assert.DoesNotContain("previousElementSibling", html, StringComparison.Ordinal);
+        Assert.Contains("var leader = runId && Array.from(document.querySelectorAll(\"details.chat-tool-group[data-assistant-run-id]\"))", html, StringComparison.Ordinal);
+        Assert.Contains("var host = leader && leader.previousElementSibling;", html, StringComparison.Ordinal);
+        Assert.Contains("var ids = new Set(targets.map(function (target) { return target.id; }));", html, StringComparison.Ordinal);
+        Assert.Contains("if (!ids.has(button.getAttribute(\"data-segment-target-id\"))) { button.remove(); }", html, StringComparison.Ordinal);
+        Assert.Contains("if (button.parentElement !== host) { button.remove(); }", html, StringComparison.Ordinal);
     }
 
     [Fact]
diff --git a/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlModelTests.cs b/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlModelTests.cs
index 380a957c..13c15fee 100644
--- a/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlModelTests.cs
+++ b/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlModelTests.cs
@@ -1617,7 +1617,7 @@ public void GenerateHistoryChunk_DoesNotInvokeOnInsertOrEmitSinkCommands()
     }
 
     [Fact]
-    public void BuildHistoryRenderPlan_ResultInNewerChunkCallInOlderChunk_InjectedIntoCall()
+    public void BuildHistoryRenderPlan_ResultInNewerChunkAfterNarration_RemainsInNewerChunk()
     {
         // The call sits at index 10 (older chunk) while its result sits at index 300 (newer chunk).
         var snapshot = Enumerable.Range(0, 10)
@@ -1636,20 +1636,17 @@ public void BuildHistoryRenderPlan_ResultInNewerChunkCallInOlderChunk_InjectedIn
 
         var plan = BuildPlan(snapshot, sink);
 
-        // The result-only message renders no element of its own.
-        Assert.False(plan.Slots[300].HasDomElement);
+        Assert.True(plan.Slots[300].HasDomElement);
 
-        // The older chunk containing the call renders the injected result nested under it.
         Assert.True(plan.Chunks.Count >= 2);
         var olderChunk = plan.Chunks.First(chunk => chunk.Start <= 10 && chunk.End > 10);
         var html = ChatOutputHtmlModel.GenerateHistoryChunk(plan, olderChunk.Start, olderChunk.End);
-        Assert.Contains("cross-chunk result data", html);
-        Assert.Contains("chat-tool-result", html);
+        Assert.DoesNotContain("cross-chunk result data", html);
 
-        // The newer chunk contains no standalone rendering of the result message.
         var newerChunk = plan.Chunks.First(chunk => chunk.Start <= 300 && chunk.End > 300);
         var newerHtml = ChatOutputHtmlModel.GenerateHistoryChunk(plan, newerChunk.Start, newerChunk.End);
-        Assert.DoesNotContain($"id=\"{ChatOutputHtmlRenderer.MessageId(300)}\"", newerHtml);
+        Assert.Contains($"id=\"{ChatOutputHtmlRenderer.MessageId(300)}\"", newerHtml);
+        Assert.Contains("cross-chunk result data", newerHtml);
     }
 
     [Fact]
@@ -2706,7 +2703,7 @@ public async Task Regression_BugD_OnInsert_UsesContainerPath_NotLoadAfterHardcod
     }
 
     [AvaloniaFact(Timeout = 15_000)]
-    public async Task Regression_BugE_CrossChunkToolResult_MatchesCall()
+    public async Task Regression_BugE_CrossChunkToolResult_AfterNarrationRendersAtEncounterPosition()
     {
         // The call lands in the older chunk while its result lands in the newer chunk.
         var history = new ObservableCollection<AgentChatHistoryItem>(
@@ -2733,14 +2730,11 @@ public async Task Regression_BugE_CrossChunkToolResult_MatchesCall()
 
         var allContent = string.Concat(sink.ContentOperations.Select(op => op.Content));
 
-        // The result is injected (nested under its call), never rendered standalone.
         Assert.Contains("cross-chunk result data", allContent);
-        Assert.DoesNotContain($"id=\"{ChatOutputHtmlRenderer.MessageId(300)}\"", allContent);
+        Assert.Contains($"id=\"{ChatOutputHtmlRenderer.MessageId(300)}\"", allContent);
 
-        // The chunk containing the call renders it with the injected result.
         var chunkWithCall = sink.ContentOperations.First(op => op.Content.Contains("my_tool"));
-        Assert.Contains("cross-chunk result data", chunkWithCall.Content);
-        Assert.Contains("chat-tool-result", chunkWithCall.Content);
+        Assert.DoesNotContain("cross-chunk result data", chunkWithCall.Content);
     }
 
     // ── Live insertion anchor regression tests (issue #900) ────────────────────
@@ -2909,8 +2903,7 @@ public async Task ChatOutput_CompletedTurnWithInterleavedAssistantContent_Coales
         using var model = new ChatOutputHtmlModel(history, new ObservableCollection<AgentChatRunningItem>(), () => true, sink);
         await model.HistoryLoaded;
         var html = string.Concat(sink.ContentOperations.Select(op => op.Content));
-        Assert.Single(System.Text.RegularExpressions.Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Cast<object>());
-        Assert.Contains("2 calls", html);
+        Assert.Equal(2, System.Text.RegularExpressions.Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Count);
         Assert.Contains("id=\"tool-group-0-header\" hidden", html);
         var read = html.IndexOf("read_file(…)", StringComparison.Ordinal);
         var between = html.IndexOf("between calls", StringComparison.Ordinal);
@@ -2918,7 +2911,9 @@ public async Task ChatOutput_CompletedTurnWithInterleavedAssistantContent_Coales
         var finished = html.IndexOf("finished", StringComparison.Ordinal);
         Assert.True(read < between && between < write && write < finished,
             "Every call and assistant text must remain in encounter order.");
-        Assert.Contains("class=\"chat-content chat-tool-group\" open", html);
+        Assert.DoesNotContain("between calls", html.Substring(html.IndexOf("id=\"tool-group-0-details\"", StringComparison.Ordinal),
+            html.IndexOf("</details>", html.IndexOf("id=\"tool-group-0-details\"", StringComparison.Ordinal), StringComparison.Ordinal)
+            - html.IndexOf("id=\"tool-group-0-details\"", StringComparison.Ordinal)));
     }
 
     [AvaloniaFact(Timeout = 15_000)]
@@ -2939,13 +2934,121 @@ public async Task ChatOutput_SameRunMixedContent_GroupsAllCallsWithoutLosingText
         using var model = new ChatOutputHtmlModel(history, new ObservableCollection<AgentChatRunningItem>(), () => true, sink);
         await model.HistoryLoaded;
         var html = string.Concat(sink.ContentOperations.Select(op => op.Content));
-        Assert.Single(System.Text.RegularExpressions.Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Cast<object>());
-        Assert.Contains("2 calls", html);
+        Assert.Equal(2, System.Text.RegularExpressions.Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Count);
         Assert.True(html.IndexOf("before call", StringComparison.Ordinal) < html.IndexOf("read_file(…)", StringComparison.Ordinal));
         Assert.True(html.IndexOf("read_file(…)", StringComparison.Ordinal) < html.IndexOf("between calls", StringComparison.Ordinal));
         Assert.True(html.IndexOf("between calls", StringComparison.Ordinal) < html.IndexOf("write_file(…)", StringComparison.Ordinal));
         Assert.Contains("result-one", html);
         Assert.Contains("result-two", html);
+        Assert.True(html.IndexOf("before call", StringComparison.Ordinal) <
+            html.IndexOf("read_file(…)", StringComparison.Ordinal));
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task ChatOutput_SameRunMixedContent_SplitsTextAndCallsWithoutLosingOrder()
+    {
+        var history = new ObservableCollection<AgentChatHistoryItem>
+        {
+            new()
+            {
+                Role = ChatRole.Assistant, AssistantRunId = "run",
+                Contents =
+                [
+                    new TextContent("before segment"),
+                    new FunctionCallContent("c1", "first_tool"),
+                    new TextContent("between segments"),
+                    new FunctionCallContent("c2", "second_tool"),
+                    new TextContent("after segment"),
+                ],
+            },
+        };
+        var sink = new RecordingSink();
+        using var model = new ChatOutputHtmlModel(history, new ObservableCollection<AgentChatRunningItem>(), () => true, sink);
+        await model.HistoryLoaded;
+        var html = string.Concat(sink.ContentOperations.Select(op => op.Content));
+        Assert.Equal(2, System.Text.RegularExpressions.Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Count);
+        var markers = new[] { "before segment", "first_tool(…)", "between segments", "second_tool(…)", "after segment" };
+        var positions = markers.Select(text => html.IndexOf(text, StringComparison.Ordinal)).ToArray();
+        Assert.All(positions, position => Assert.True(position >= 0));
+        Assert.True(positions.SequenceEqual(positions.OrderBy(position => position)));
+        Assert.DoesNotContain("between segments", html.Substring(
+            html.IndexOf("id=\"history-0-1-details\"", StringComparison.Ordinal),
+            html.IndexOf("</details>", html.IndexOf("id=\"history-0-1-details\"", StringComparison.Ordinal), StringComparison.Ordinal)
+                - html.IndexOf("id=\"history-0-1-details\"", StringComparison.Ordinal)));
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task ChatOutput_MixedCallNarrationResult_PreservesBindingOrderInLiveAndReload()
+    {
+        var item = new AgentChatHistoryItem
+        {
+            Role = ChatRole.Assistant, AssistantRunId = "run",
+            Contents =
+            [
+                new FunctionCallContent("c1", "first_tool"),
+                new TextContent("between call and result"),
+                new FunctionResultContent("c1", "result-after-text"),
+            ],
+        };
+        var liveHistory = new ObservableCollection<AgentChatHistoryItem>();
+        var liveSink = new RecordingSink();
+        using var live = new ChatOutputHtmlModel(liveHistory, new ObservableCollection<AgentChatRunningItem>(),
+            () => true, liveSink);
+        await live.HistoryLoaded;
+        liveHistory.Add(item);
+        var reloadSink = new RecordingSink();
+        using var reload = new ChatOutputHtmlModel(new ObservableCollection<AgentChatHistoryItem> { item },
+            new ObservableCollection<AgentChatRunningItem>(), () => true, reloadSink);
+        await reload.HistoryLoaded;
+        foreach (var sink in new[] { liveSink, reloadSink })
+        {
+            var html = string.Concat(sink.ContentOperations.Select(op => op.Content));
+            var call = html.IndexOf("first_tool(…)", StringComparison.Ordinal);
+            var narration = html.IndexOf("between call and result", StringComparison.Ordinal);
+            var result = html.IndexOf("tool result: c1", StringComparison.Ordinal);
+            Assert.True(call >= 0 && call < narration && narration < result);
+            Assert.Contains("result-after-text", html);
+        }
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task ChatOutput_ResultAfterSeparateNarration_DoesNotInjectBeforeProse()
+    {
+        var items = new[]
+        {
+            ToolCallMessage("first_tool", "c1") with { AssistantRunId = "run" },
+            TextMessage(ChatRole.Assistant, "between call and result") with { AssistantRunId = "run" },
+            new AgentChatHistoryItem { Role = ChatRole.Tool, AssistantRunId = "run",
+                Contents = [new FunctionResultContent("c1", "after-narration")] },
+        };
+        var sink = new RecordingSink();
+        using var model = new ChatOutputHtmlModel(new ObservableCollection<AgentChatHistoryItem>(items),
+            new ObservableCollection<AgentChatRunningItem>(), () => true, sink);
+        await model.HistoryLoaded;
+        var html = string.Concat(sink.ContentOperations.Select(op => op.Content));
+        Assert.True(html.IndexOf("between call and result", StringComparison.Ordinal) <
+            html.IndexOf("tool result: c1", StringComparison.Ordinal));
+        Assert.Contains("after-narration", html);
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task ChatOutput_RunAcrossHistoryChunkBoundary_PreservesOneSummaryAndProseOrder()
+    {
+        var items = Enumerable.Range(0, 199).Select(i => TextMessage(ChatRole.User, $"user-{i}")).ToList();
+        items.Add(ToolCallMessage("first_tool", "c1") with { AssistantRunId = "chunk-run" });
+        items.Add(TextMessage(ChatRole.Assistant, "between calls") with { AssistantRunId = "chunk-run" });
+        items.Add(ToolCallMessage("second_tool", "c2") with { AssistantRunId = "chunk-run" });
+        var sink = new RecordingSink();
+        using var model = new ChatOutputHtmlModel(new ObservableCollection<AgentChatHistoryItem>(items),
+            new ObservableCollection<AgentChatRunningItem>(), () => true, sink);
+        await model.HistoryLoaded;
+        var html = string.Concat(sink.ContentOperations.Select(op => op.Content));
+        Assert.True(html.IndexOf("first_tool(…)", StringComparison.Ordinal) <
+            html.IndexOf("between calls", StringComparison.Ordinal));
+        Assert.True(html.IndexOf("between calls", StringComparison.Ordinal) <
+            html.IndexOf("second_tool(…)", StringComparison.Ordinal));
+        Assert.Equal(2, System.Text.RegularExpressions.Regex.Matches(html, "data-assistant-run-id=\"chunk-run\"").Count);
+        Assert.Equal(2, System.Text.RegularExpressions.Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Count);
     }
 
     [AvaloniaFact(Timeout = 30_000)]
@@ -3011,8 +3114,7 @@ void CheckCompletion()
         var reloadedHtml = string.Concat(reloadSink.ContentOperations.Select(op => op.Content));
         foreach (var html in new[] { liveHtml, reloadedHtml })
         {
-            Assert.Single(System.Text.RegularExpressions.Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Cast<object>());
-            Assert.Contains("2 calls", html);
+            Assert.True(System.Text.RegularExpressions.Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Count >= 1);
             Assert.Contains("read-result", html);
             Assert.Contains("write-result", html);
             Assert.True(html.IndexOf("read(…)", StringComparison.Ordinal) <
diff --git a/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlRendererTests.cs b/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlRendererTests.cs
index 73fd5c81..3c11b2cf 100644
--- a/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlRendererTests.cs
+++ b/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlRendererTests.cs
@@ -25,6 +25,31 @@ public void RenderToolCallGroup_ActiveAndCompletedStates_EmitsAccessibleStatusWi
         Assert.DoesNotContain("tool-active-indicator", completed);
         Assert.Contains("2 calls", completed);
     }
+
+    [Fact]
+    public void ChatOutput_GroupWithSuppressedRoleHeader_PlacesActionsBesideVisibleSummary()
+    {
+        var html = ChatOutputHtmlRenderer.RenderToolCallGroup("group", ["read"], 1,
+            "<div id=\"call\" data-inspect-target></div>", suppressRoleHeader: true);
+        var actions = html.IndexOf("class=\"chat-tool-group-actions\"", StringComparison.Ordinal);
+        var details = html.IndexOf("id=\"group-details\"", StringComparison.Ordinal);
+        var summary = html.IndexOf("id=\"group-summary\"", StringComparison.Ordinal);
+        Assert.True(actions > 0 && actions < details && details < summary);
+        Assert.Contains("aria-label=\"Tool group actions\"", html, StringComparison.Ordinal);
+        Assert.DoesNotContain("<summary class=\"chat-collapsible-summary\"><button", html, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void RenderInlineToolSegment_LeavesToolInOneStableAddressableBinding()
+    {
+        var html = ChatOutputHtmlRenderer.RenderInlineToolSegment("history-0-1", "run",
+            [new FunctionCallContent("c1", "read")], "<div>call payload</div>");
+        Assert.Contains("id=\"history-0-1\"", html);
+        Assert.Contains("id=\"history-0-1-details\"", html);
+        Assert.Contains("data-assistant-run-id=\"run\"", html);
+        Assert.Contains("data-segment-call-count=\"1\"", html);
+        Assert.Contains("call payload", html);
+    }
     [Fact]
     public void RenderCollapsible_EmitsDataStickyLevelOnSummary()
     {
@@ -530,9 +555,8 @@ public void RenderToolCallGroupSummary_DuplicateToolNames_DedupedOnce()
         // The model dedupes; the renderer lists whatever it is given. Verify a single entry renders once.
         var html = ChatOutputHtmlRenderer.RenderToolCallGroupSummary("grp-0", new[] { "powershell" }, 3);
 
-        var first = html.IndexOf("powershell", StringComparison.Ordinal);
-        var last = html.LastIndexOf("powershell", StringComparison.Ordinal);
-        Assert.Equal(first, last);
+        Assert.Single(System.Text.RegularExpressions.Regex.Matches(
+            html, "<span class=\"tool-name\">powershell</span>").Cast<System.Text.RegularExpressions.Match>());
     }
 
     [Fact]
diff --git a/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlStructuralInvariantsTests.cs b/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlStructuralInvariantsTests.cs
index 0f308671..1f8a835c 100644
--- a/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlStructuralInvariantsTests.cs
+++ b/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlStructuralInvariantsTests.cs
@@ -79,8 +79,11 @@ public async Task ChatOutput_SameRunPromotedAcrossHistoryAndRunning_UsesOneStabl
         running.Remove(runningItem);
 
         var groupId = ChatOutputHtmlRenderer.ToolGroupId(0);
-        Assert.Contains(sink.Operations, op => op.Path == ChatOutputHtmlRenderer.ToolGroupSummaryId(groupId)
-            && op.Content.Contains("2 calls", StringComparison.Ordinal));
+        Assert.Contains(sink.Operations, op => op.Content.Contains($"id=\"{groupId}-details\"", StringComparison.Ordinal));
+        Assert.Contains(sink.Operations, op => op.Content.Contains("working", StringComparison.Ordinal)
+            && op.Path == groupId && op.Location == ChatOutputUpdateLocation.After);
+        Assert.Contains(sink.Operations, op => op.Content.Contains("write", StringComparison.Ordinal)
+            && op.Content.Contains("-group-2-details", StringComparison.Ordinal));
         Assert.DoesNotContain(sink.Operations, op => op.Path == ChatOutputHtmlRenderer.HistoryContainerId
             && op.Content.Contains("id=\"tool-group-1\"", StringComparison.Ordinal));
     }
@@ -107,14 +110,114 @@ public async Task ChatOutput_HistoryReloadAfterCompletedRun_MatchesLiveGroupedSh
             new ObservableCollection<AgentChatRunningItem>(), () => true, reloadSink);
         await reload.HistoryLoaded;
         var html = string.Concat(reloadSink.Operations.Select(op => op.Content));
-        Assert.Single(Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Cast<object>());
-        Assert.Contains("2 calls", html);
+        Assert.Equal(2, Regex.Matches(html, "class=\"chat-content chat-tool-group\"").Count);
         Assert.Contains("working", html);
         Assert.Contains("read", html);
         Assert.Contains("write", html);
         Assert.Contains("result", html);
-        Assert.Contains(liveSink.Operations, op => op.Path == ChatOutputHtmlRenderer.ToolGroupSummaryId(ChatOutputHtmlRenderer.ToolGroupId(0))
-            && op.Content.Contains("2 calls", StringComparison.Ordinal));
+        Assert.True(html.IndexOf("read", StringComparison.Ordinal) <
+            html.IndexOf("working", StringComparison.Ordinal));
+        Assert.True(html.IndexOf("working", StringComparison.Ordinal) <
+            html.IndexOf("write", StringComparison.Ordinal));
+        Assert.Contains(liveSink.Operations, op => op.Content.Contains("id=\"tool-group-0-details\"", StringComparison.Ordinal));
+        Assert.Contains(liveSink.Operations, op => op.Content.Contains("id=\"tool-group-3-details\"", StringComparison.Ordinal));
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task ChatOutput_HistoryReloadWithInterleavedSystemNotification_MatchesLiveDomOrder()
+    {
+        var items = new[]
+        {
+            ToolCallMessage("first_tool", "c1") with { AssistantRunId = "run" },
+            TextMessage(ChatRole.System, "agent idle") with { AssistantRunId = "run" },
+            ToolCallMessage("second_tool", "c2") with { AssistantRunId = "run" },
+            TextMessage(ChatRole.Assistant, "after tools") with { AssistantRunId = "run" },
+        };
+        var history = new ObservableCollection<AgentChatHistoryItem>();
+        var liveSink = new RecordingSink();
+        using var live = new ChatOutputHtmlModel(history, new ObservableCollection<AgentChatRunningItem>(), () => true, liveSink);
+        await live.HistoryLoaded;
+        foreach (var item in items) history.Add(item);
+
+        var reloadSink = new RecordingSink();
+        using var reload = new ChatOutputHtmlModel(new ObservableCollection<AgentChatHistoryItem>(items),
+            new ObservableCollection<AgentChatRunningItem>(), () => true, reloadSink);
+        await reload.HistoryLoaded;
+        var html = string.Concat(reloadSink.Operations.Select(op => op.Content));
+        Assert.True(html.IndexOf("first_tool(…)", StringComparison.Ordinal) <
+            html.IndexOf("agent idle", StringComparison.Ordinal));
+        Assert.True(html.IndexOf("agent idle", StringComparison.Ordinal) <
+            html.IndexOf("second_tool(…)", StringComparison.Ordinal));
+        Assert.Contains("chat-sender\">system", html);
+        Assert.Contains(liveSink.Operations, op => op.Content.Contains("agent idle", StringComparison.Ordinal)
+            && op.Path == "tool-group-0" && op.Location == ChatOutputUpdateLocation.After);
+        Assert.Contains(liveSink.Operations, op => op.Content.Contains("second_tool(…)", StringComparison.Ordinal)
+            && op.Path == "history-1" && op.Location == ChatOutputUpdateLocation.After);
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task ChatOutput_NotificationBeforeParentToolCall_ShowsSystemBeforeCallWithoutFalseReordering()
+    {
+        var items = new[]
+        {
+            TextMessage(ChatRole.System, "already idle") with { AssistantRunId = "run" },
+            ToolCallMessage("parent_task", "c1") with { AssistantRunId = "run" },
+        };
+        var sink = new RecordingSink();
+        using var model = new ChatOutputHtmlModel(new ObservableCollection<AgentChatHistoryItem>(items),
+            new ObservableCollection<AgentChatRunningItem>(), () => true, sink);
+        await model.HistoryLoaded;
+        var html = string.Concat(sink.Operations.Select(op => op.Content));
+        Assert.True(html.IndexOf("already idle", StringComparison.Ordinal) <
+            html.IndexOf("parent_task(…)", StringComparison.Ordinal));
+        Assert.Contains("chat-sender\">system", html);
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task ChatOutput_NotificationBetweenCallAndResult_KeepsResultAfterSystemInLiveAndReload()
+    {
+        var items = new[]
+        {
+            ToolCallMessage("parent_task", "c1") with { AssistantRunId = "run" },
+            TextMessage(ChatRole.System, "agent idle") with { AssistantRunId = "run" },
+            ToolResultMessage("c1") with { AssistantRunId = "run" },
+        };
+        var liveHistory = new ObservableCollection<AgentChatHistoryItem>();
+        var liveSink = new RecordingSink();
+        using var live = new ChatOutputHtmlModel(liveHistory, new ObservableCollection<AgentChatRunningItem>(), () => true, liveSink);
+        await live.HistoryLoaded;
+        foreach (var item in items) liveHistory.Add(item);
+        var reloadSink = new RecordingSink();
+        using var reload = new ChatOutputHtmlModel(new ObservableCollection<AgentChatHistoryItem>(items),
+            new ObservableCollection<AgentChatRunningItem>(), () => true, reloadSink);
+        await reload.HistoryLoaded;
+        foreach (var sink in new[] { liveSink, reloadSink })
+        {
+            var html = string.Concat(sink.Operations.Select(op => op.Content));
+            Assert.True(html.IndexOf("parent_task(…)", StringComparison.Ordinal) <
+                html.IndexOf("agent idle", StringComparison.Ordinal));
+            Assert.True(html.IndexOf("agent idle", StringComparison.Ordinal) <
+                html.IndexOf("tool result: c1", StringComparison.Ordinal));
+            Assert.Contains("result", html);
+        }
+        Assert.Contains(liveSink.Operations, op => op.Content.Contains("tool result: c1", StringComparison.Ordinal)
+            && op.Path == "history-1" && op.Location == ChatOutputUpdateLocation.After);
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task ChatOutput_ConsecutiveSystemNotifications_KeepVisibleRoleHeaders()
+    {
+        var history = new ObservableCollection<AgentChatHistoryItem>
+        {
+            TextMessage(ChatRole.System, "first idle"),
+            TextMessage(ChatRole.System, "second idle"),
+        };
+        var sink = new RecordingSink();
+        using var model = new ChatOutputHtmlModel(history, new ObservableCollection<AgentChatRunningItem>(), () => true, sink);
+        await model.HistoryLoaded;
+        var html = string.Concat(sink.Operations.Select(op => op.Content));
+        Assert.Equal(2, Regex.Matches(html, "class=\"chat-sender\">system").Count);
+        Assert.Equal(2, Regex.Matches(html, "chat-system-message").Count);
     }
 
     /// <summary>
diff --git a/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlTransformerLookupTests.cs b/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlTransformerLookupTests.cs
index 1de089ee..dced1fe3 100644
--- a/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlTransformerLookupTests.cs
+++ b/Phantom.Workspaces.Agent.Gui.Tests/ChatOutputHtmlTransformerLookupTests.cs
@@ -264,6 +264,23 @@ public void FindGroupablePredecessor_SkipsToolResultOnlyMessages_FindsToolCall()
         Assert.Same(target[0], predecessor);
     }
 
+    [Fact]
+    public void FindGroupablePredecessor_VisibleUnmatchedResult_StopsGrouping()
+    {
+        var source = new ObservableCollection<AgentChatHistoryItem>
+        {
+            ToolCallMessage("tool_a", "call-1") with { AssistantRunId = "run" },
+            ToolResultMessage("unknown", "unmatched") with { AssistantRunId = "run" },
+            ToolCallMessage("tool_b", "call-2") with { AssistantRunId = "run" },
+        };
+        var target = new List<RenderSlot>();
+        using var transformer = MakeTransformer(source, target, new RecordingSink());
+
+        Assert.True(target[1].HasDomElement);
+        Assert.Null(transformer.FindGroupablePredecessor(2));
+        Assert.NotSame(target[0].Group, target[2].Group);
+    }
+
     [Fact]
     public void FindGroupablePredecessor_TextMessageBetween_ReturnsNull()
     {
diff --git a/Phantom.Workspaces.Agent.Gui.WebViewTests/ChatOutputBrowserIntegrationTests.cs b/Phantom.Workspaces.Agent.Gui.WebViewTests/ChatOutputBrowserIntegrationTests.cs
index a68763a2..c913329e 100644
--- a/Phantom.Workspaces.Agent.Gui.WebViewTests/ChatOutputBrowserIntegrationTests.cs
+++ b/Phantom.Workspaces.Agent.Gui.WebViewTests/ChatOutputBrowserIntegrationTests.cs
@@ -1,16 +1,24 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.IO;
+using System.Text.Json;
+using System.Threading.Channels;
 using System.Threading.Tasks;
+using AgentSchema;
 using Avalonia;
 using Avalonia.Controls;
+using GitHub.Copilot;
+using Microsoft.Agents.AI;
 using Microsoft.Extensions.AI;
 using Phantom.Workspaces.Agent.Gui.Controls;
 using Phantom.Workspaces.Agent.Gui.ViewModels;
 using Phantom.Workspaces.Agent.Gui.ViewModels.DocumentModels;
 using Phantom.Workspaces.Gui.Shared.Controls;
 using Phantom.Workspaces.Llm;
+using Phantom.Workspaces.Llm.Remote;
+using Phantom.Workspaces.Transport;
 using Xunit;
 
 namespace Phantom.Workspaces.Agent.Gui.WebViewTests;
@@ -700,6 +708,11 @@ public Task ChatOutput_SuppressedAssistantHeaderWithInspectTargets_RemainsHidden
         => this.fixture.InvokeAsync(async () =>
         {
             var (web, window) = await ShowReadyBrowserAsync();
+            var messages = new List<string>();
+            web.JavaScriptMessageReceived += (_, body) =>
+            {
+                if (body.Contains("\"type\":\"inspect\"", StringComparison.Ordinal)) messages.Add(body);
+            };
             try
             {
                 var content = ChatOutputHtmlRenderer.RenderContent(
@@ -711,7 +724,7 @@ public Task ChatOutput_SuppressedAssistantHeaderWithInspectTargets_RemainsHidden
                     "suppressed",
                     "assistant",
                     [("suppressed-c0", content),
-                     ("suppressed-usage", "<div class=\"chat-content chat-usage\" data-usage-inspect-target id=\"suppressed-usage\"></div>")],
+                     ("suppressed-usage", "<div class=\"chat-content chat-usage\" data-usage-inspect-target data-details-target=\"usage payload\" id=\"suppressed-usage\"></div>")],
                     suppressRoleHeader: true);
                 web.PostMessageToJavaScript(ChatOutputBrowserCommands.Update(
                     "chat-history-container",
@@ -727,6 +740,17 @@ public Task ChatOutput_SuppressedAssistantHeaderWithInspectTargets_RemainsHidden
                     + "&&!!c.querySelector(':scope > .usage-gutter-btn')"
                     + "&&!!c.querySelector('[data-copy-target]');})()");
                 Assert.Contains("true", result, StringComparison.Ordinal);
+                var activated = await EvalAsync(web,
+                    "(function(){var m=document.getElementById('suppressed');"
+                    + "var c=m.querySelector(':scope > .chat-contents');"
+                    + "c.querySelector(':scope > .inspect-gutter-btn').click();"
+                    + "c.querySelector(':scope > .usage-gutter-btn').click();"
+                    + "return m.querySelector(':scope > .chat-header').hidden;})()");
+                Assert.Contains("true", activated, StringComparison.Ordinal);
+                await WaitForFrameSyncAsync(web);
+                Assert.Contains(messages, body => body.Contains("\"contentId\":\"suppressed-c0\"", StringComparison.Ordinal));
+                Assert.Contains(messages, body => body.Contains("\"contentId\":\"suppressed-usage\"", StringComparison.Ordinal)
+                    && body.Contains("usage payload", StringComparison.Ordinal));
             }
             finally
             {
@@ -763,6 +787,750 @@ await EvalAsync(web,
             }
         });
 
+    [Fact]
+    public Task ToolGroup_HiddenHeader_InspectAndUsageStayOnVisibleChromeAndTargetOwnGroup()
+        => this.fixture.InvokeAsync(async () =>
+        {
+            var (web, window) = await ShowReadyBrowserAsync();
+            var messages = new List<string>();
+            web.JavaScriptMessageReceived += (_, body) =>
+            {
+                if (body.Contains("\"type\":\"inspect\"", StringComparison.Ordinal)) messages.Add(body);
+            };
+            try
+            {
+                foreach (var id in new[] { "group-a", "group-b" })
+                {
+                    var body = $"<div id=\"{id}-call\" data-inspect-target data-details-target=\"{id}-inspect\"></div>";
+                    web.PostMessageToJavaScript(ChatOutputBrowserCommands.Update("chat-history-container", "append",
+                        ChatOutputHtmlRenderer.RenderToolCallGroup(id, ["read"], 1, body +
+                            $"<div id=\"{id}-usage\" data-usage-inspect-target data-details-target=\"{id}-tokens\"></div>")));
+                }
+                var structure = await EvalAsync(web,
+                    "(function(){return ['group-a','group-b'].every(function(id){var m=document.getElementById(id);"
+                    + "var a=m.querySelector('.chat-tool-group-actions');"
+                    + "return a && a.querySelectorAll('button').length===2"
+                    + " && !m.querySelector(':scope > .chat-contents > .inspect-gutter-btn')"
+                    + " && !m.querySelector(':scope > .chat-contents > .usage-gutter-btn')"
+                    + " && m.querySelector('details').previousElementSibling===a;});})()");
+                Assert.Contains("true", structure, StringComparison.Ordinal);
+                var state = await EvalAsync(web,
+                    "(function(){var d=document.getElementById('group-b-details');"
+                    + "d.open=false;document.querySelector('#group-b .inspect-gutter-btn').click();"
+                    + "document.querySelector('#group-b .usage-gutter-btn').click();return !d.open;})()");
+                Assert.Contains("true", state, StringComparison.Ordinal);
+                await WaitForFrameSyncAsync(web);
+                Assert.Contains(messages, m => m.Contains("\"contentId\":\"group-b-call\"", StringComparison.Ordinal));
+                Assert.Contains(messages, m => m.Contains("\"contentId\":\"group-b-usage\"", StringComparison.Ordinal));
+                Assert.DoesNotContain(messages, m => m.Contains("\"contentId\":\"group-a-call\"", StringComparison.Ordinal));
+            }
+            finally { window.Close(); }
+        });
+
+    [Fact]
+    public Task ToolRun_DistinctMessageGroups_RouteActionsToVisibleSummaryAcrossCollapseMutationAndReload()
+        => this.fixture.InvokeAsync(async () =>
+        {
+            var (web, window) = await ShowReadyBrowserAsync();
+            var messages = new List<string>();
+            web.JavaScriptMessageReceived += (_, body) =>
+            {
+                if (body.Contains("\"type\":\"inspect\"", StringComparison.Ordinal)) messages.Add(body);
+            };
+            try
+            {
+                static AgentChatHistoryItem Call(string id) => new()
+                {
+                    Role = ChatRole.Assistant, AssistantRunId = "message-run",
+                    Contents =
+                    [
+                        new FunctionCallContent(id, "read", new Dictionary<string, object?>()),
+                        new UsageContent(new UsageDetails { InputTokenCount = id == "c1" ? 11 : 22 }),
+                    ],
+                };
+                var items = new[] { Call("c1"), TextItem("between message groups") with
+                    { AssistantRunId = "message-run" }, Call("c2") };
+                var history = new ObservableCollection<AgentChatHistoryItem>();
+                using var live = CreateModel(web, history);
+                await live.HistoryLoaded;
+                foreach (var item in items) history.Add(item);
+
+                async Task AssertActionsAsync(string secondCall, bool expanded)
+                {
+                    var state = await EvalAsync(web, """
+                        (() => {
+                          const groups = Array.from(document.querySelectorAll('details.chat-tool-group[data-assistant-run-id="message-run"]'));
+                          if (groups.length !== 2 || groups[0].closest('.chat-message') === groups[1].closest('.chat-message')) return false;
+                          const host = groups[0].previousElementSibling;
+                          const secondHost = groups[1].previousElementSibling;
+                          const buttons = Array.from(host?.querySelectorAll(':scope > button') || []);
+                          const targets = buttons.map(b => document.getElementById(b.getAttribute('data-segment-target-id')));
+                          const ids = Array.from(document.querySelectorAll('[id]')).map(e => e.id);
+                          const summary = groups[0].querySelector(':scope > summary');
+                          return host?.matches('.chat-tool-group-actions') && secondHost?.matches('.chat-tool-group-actions') &&
+                            buttons.length === 4 && secondHost.querySelectorAll('button').length === 0 &&
+                            targets.every(t => t && t.hasAttribute('data-details-target')) &&
+                            buttons.filter(b => b.classList.contains('inspect-gutter-btn')).length === 2 &&
+                            buttons.filter(b => b.classList.contains('usage-gutter-btn')).length === 2 &&
+                            buttons.some(b => b.getAttribute('data-segment-target-id')?.includes('history-2')) &&
+                            targets.some(t => t.getAttribute('data-details-target')?.includes('SECOND')) &&
+                            buttons.every(b => b.getClientRects().length > 0 && b.tabIndex >= 0 && !b.disabled &&
+                              b.getAttribute('aria-label') && b.parentElement === host) &&
+                            host.getBoundingClientRect().bottom <= summary.getBoundingClientRect().top + 2 &&
+                            !summary.hidden && groups[1].querySelector(':scope > summary').hidden &&
+                            groups.every(g => g.open === EXPANDED) && ids.length === new Set(ids).size;
+                        })()
+                        """.Replace("SECOND", secondCall, StringComparison.Ordinal)
+                            .Replace("EXPANDED", expanded ? "true" : "false", StringComparison.Ordinal));
+                    Assert.Contains("true", state, StringComparison.Ordinal);
+                }
+
+                await AssertActionsAsync("c2", true);
+                await EvalAsync(web, "document.querySelector('details.chat-tool-group[data-assistant-run-id=\"message-run\"] > summary').click();'collapsed'");
+                await AssertActionsAsync("c2", false);
+                var activated = await EvalAsync(web, """
+                    (() => {
+                      const groups = Array.from(document.querySelectorAll('details.chat-tool-group[data-assistant-run-id="message-run"]'));
+                      const buttons = groups[0].previousElementSibling.querySelectorAll('button');
+                      buttons.forEach(b => { b.focus(); b.click(); });
+                      return document.activeElement === buttons[buttons.length - 1] && groups.every(g => !g.open);
+                    })()
+                    """);
+                Assert.Contains("true", activated, StringComparison.Ordinal);
+                await WaitForFrameSyncAsync(web);
+                Assert.Equal(4, messages.Count);
+                Assert.Equal(4, messages.Select(m => JsonDocument.Parse(m).RootElement.GetProperty("contentId").GetString())
+                    .Distinct().Count());
+                Assert.Contains(messages, m => m.Contains("c1", StringComparison.Ordinal));
+                Assert.Contains(messages, m => m.Contains("c2", StringComparison.Ordinal));
+
+                history[2] = Call("c3");
+                await AssertActionsAsync("c3", false);
+                messages.Clear();
+                await EvalAsync(web, """
+                    (() => {
+                      const host = document.querySelector('details.chat-tool-group[data-assistant-run-id="message-run"]')
+                        .previousElementSibling;
+                      host.querySelectorAll('button').forEach(b => b.click());
+                      return 'clicked';
+                    })()
+                    """);
+                await WaitForFrameSyncAsync(web);
+                Assert.Equal(4, messages.Count);
+                Assert.Contains(messages, m => m.Contains("c3", StringComparison.Ordinal));
+                Assert.DoesNotContain(messages, m => m.Contains("c2", StringComparison.Ordinal));
+
+                live.Dispose();
+                web.PostMessageToJavaScript(ChatOutputBrowserCommands.Update(
+                    "chat-history-container", "replace", "<div id=\"chat-history-container\"></div>"));
+                using var reload = CreateModel(web, new ObservableCollection<AgentChatHistoryItem>
+                    { items[0], items[1], Call("c3") });
+                await reload.HistoryLoaded;
+                await AssertActionsAsync("c3", false);
+            }
+            finally { window.Close(); }
+        });
+
+    [Fact]
+    public Task MixedMessage_TwoToolSegments_InspectResultAndUsageActionsSurviveMutationAndReload()
+        => this.fixture.InvokeAsync(async () =>
+        {
+            var (web, window) = await ShowReadyBrowserAsync();
+            var messages = new List<string>();
+            web.JavaScriptMessageReceived += (_, body) =>
+            {
+                if (body.Contains("\"type\":\"inspect\"", StringComparison.Ordinal)) messages.Add(body);
+            };
+            try
+            {
+                static AgentChatHistoryItem Item(string secondCallId) => new()
+                {
+                    Role = ChatRole.Assistant, AssistantRunId = "mixed-run",
+                    Contents =
+                    [
+                        new FunctionCallContent("c1", "read"),
+                        new UsageContent(new UsageDetails { InputTokenCount = 10 }),
+                        new TextContent("between calls"),
+                        new FunctionCallContent(secondCallId, "write"),
+                        new FunctionResultContent(secondCallId, "done"),
+                        new UsageContent(new UsageDetails { OutputTokenCount = 20 }),
+                    ],
+                };
+                var history = new ObservableCollection<AgentChatHistoryItem> { Item("c2") };
+                using var model = CreateModel(web, history);
+                await model.HistoryLoaded;
+                var initial = await EvalAsync(web, """
+                    (() => {
+                      const segments = document.querySelectorAll('#history-0 .chat-tool-segment');
+                      const host = segments[0]?.querySelector(':scope > .chat-tool-group-actions');
+                      return segments.length === 2 && host &&
+                        host.querySelectorAll(':scope > .inspect-gutter-btn').length === 3 &&
+                        host.querySelectorAll(':scope > .usage-gutter-btn').length === 2 &&
+                        segments[1].querySelectorAll(':scope > .chat-tool-group-actions > button').length === 0 &&
+                        new Set(Array.from(host.querySelectorAll('button'),
+                          button => button.getAttribute('aria-label'))).size === 5;
+                    })()
+                    """);
+                Assert.Contains("true", initial, StringComparison.Ordinal);
+
+                var targetIds = await EvalAsync(web, """
+                    (() => {
+                      const segments = document.querySelectorAll('#history-0 .chat-tool-segment');
+                      const buttons = segments[0].querySelectorAll(':scope > .chat-tool-group-actions > button');
+                      buttons.forEach(b => b.click());
+                      return Array.from(segments).map(s => s.querySelector('details').open).join(',');
+                    })()
+                    """);
+                Assert.Contains("true,true", targetIds, StringComparison.Ordinal);
+                await WaitForFrameSyncAsync(web);
+                Assert.Equal(5, messages.Count(m => m.Contains("\"type\":\"inspect\"", StringComparison.Ordinal)));
+                Assert.Equal(5, messages.Select(m => System.Text.Json.JsonDocument.Parse(m))
+                    .Select(json => json.RootElement.GetProperty("contentId").GetString()).Distinct().Count());
+
+                history[0] = Item("c3");
+                var rebound = await EvalAsync(web, """
+                    (() => {
+                      const segments = document.querySelectorAll('#history-0 .chat-tool-segment');
+                      const host = segments[0].querySelector(':scope > .chat-tool-group-actions');
+                      const second = Array.from(host.querySelectorAll('button'))
+                        .filter(b => b.getAttribute('data-segment-origin-id') === segments[1].id);
+                      second[0]?.click();
+                      return second.length === 3 &&
+                        segments[1].querySelectorAll(':scope > .chat-tool-group-actions > button').length === 0;
+                    })()
+                    """);
+                Assert.Contains("true", rebound, StringComparison.Ordinal);
+                await WaitForFrameSyncAsync(web);
+                Assert.Contains(messages, m => m.Contains("\"CallId\": \"c3\"", StringComparison.Ordinal)
+                    || m.Contains("\\\"CallId\\\": \\\"c3\\\"", StringComparison.Ordinal));
+
+                web.PostMessageToJavaScript(ChatOutputBrowserCommands.Update(
+                    "chat-history-container", "replace", "<div id=\"chat-history-container\"></div>"));
+                using var reload = CreateModel(web, new ObservableCollection<AgentChatHistoryItem> { Item("c3") });
+                await reload.HistoryLoaded;
+                var restored = await EvalAsync(web, """
+                    (() => {
+                      const segments = document.querySelectorAll('#history-0 .chat-tool-segment');
+                      return segments.length === 2 &&
+                        segments[0].querySelectorAll(':scope > .chat-tool-group-actions > button').length === 5 &&
+                        segments[1].querySelectorAll(':scope > .chat-tool-group-actions > button').length === 0 &&
+                        Array.from(document.querySelectorAll('[id]')).every(e => document.querySelectorAll(
+                          '[id="' + CSS.escape(e.id) + '"]').length === 1);
+                    })()
+                    """);
+                Assert.Contains("true", restored, StringComparison.Ordinal);
+            }
+            finally { window.Close(); }
+        });
+
+    [Fact]
+    public Task MixedMessage_SecondaryActions_StayAdjacentToVisibleSummaryAndKeyboardReachableWhenCollapsed()
+        => this.fixture.InvokeAsync(async () =>
+        {
+            var (web, window) = await ShowReadyBrowserAsync();
+            var messages = new List<string>();
+            web.JavaScriptMessageReceived += (_, body) =>
+            {
+                if (body.Contains("\"type\":\"inspect\"", StringComparison.Ordinal)) messages.Add(body);
+            };
+            try
+            {
+                var history = new ObservableCollection<AgentChatHistoryItem>
+                {
+                    new()
+                    {
+                        Role = ChatRole.Assistant, AssistantRunId = "run",
+                        Contents =
+                        [
+                            new FunctionCallContent("c1", "read"),
+                            new UsageContent(new UsageDetails { InputTokenCount = 10 }),
+                            new TextContent("narration"),
+                            new FunctionCallContent("c2", "write"),
+                            new FunctionResultContent("c2", "done"),
+                            new UsageContent(new UsageDetails { OutputTokenCount = 20 }),
+                        ],
+                    },
+                };
+                using var model = CreateModel(web, history);
+                await model.HistoryLoaded;
+                async Task AssertChromeAsync(bool expanded)
+                {
+                    var visible = await EvalAsync(web, """
+                        (() => {
+                          const segments = document.querySelectorAll('#history-0 .chat-tool-segment');
+                          const leader = segments[0].querySelector(':scope > .chat-tool-group-actions');
+                          const summary = segments[0].querySelector(':scope > details > summary');
+                          const actions = Array.from(document.querySelectorAll('#history-0 .chat-tool-group-actions > button'));
+                          const second = Array.from(actions).filter(b =>
+                            b.getAttribute('data-segment-origin-id') === segments[1].id);
+                          return segments.length === 2 && !summary.hidden &&
+                            actions.length === 5 && second.length === 3 &&
+                            second.every(b => b.parentElement === leader &&
+                              b.getClientRects().length > 0 && b.tabIndex >= 0 &&
+                              b.getAttribute('aria-label') && !b.disabled) &&
+                            leader.getBoundingClientRect().bottom <= summary.getBoundingClientRect().top + 2 &&
+                            leader.getBoundingClientRect().width <= segments[0].getBoundingClientRect().width &&
+                            segments[1].querySelector(':scope > details > summary').hidden &&
+                            segments[0].querySelector(':scope > details').open === EXPANDED;
+                        })()
+                        """.Replace("EXPANDED", expanded ? "true" : "false", StringComparison.Ordinal));
+                    Assert.Contains("true", visible, StringComparison.Ordinal);
+                }
+                await AssertChromeAsync(true);
+                await EvalAsync(web, "document.querySelector('#history-0 .chat-tool-segment summary').click();'collapsed'");
+                await AssertChromeAsync(false);
+                var focused = await EvalAsync(web, """
+                    (() => {
+                      const b = Array.from(document.querySelectorAll('#history-0 .chat-tool-group-actions > button'))
+                        .find(x => x.getAttribute('data-segment-target-id').endsWith('-result'));
+                      b.focus(); b.click(); return document.activeElement === b;
+                    })()
+                    """);
+                Assert.Contains("true", focused, StringComparison.Ordinal);
+                await WaitForFrameSyncAsync(web);
+                Assert.Contains(messages, m => m.Contains("-result\"", StringComparison.Ordinal));
+            }
+            finally { window.Close(); }
+        });
+
+    [Fact]
+    public Task ToolRun_UnmatchedResultBetweenCalls_LiveAndReloadKeepResultInDomOrder()
+        => this.fixture.InvokeAsync(async () =>
+        {
+            var (web, window) = await ShowReadyBrowserAsync();
+            try
+            {
+                var items = new[]
+                {
+                    ToolCallItem("first_tool", "c1") with { AssistantRunId = "run" },
+                    new AgentChatHistoryItem { Role = ChatRole.Tool, AssistantRunId = "run",
+                        Contents = [new FunctionResultContent("unmatched", "unmatched-result")] },
+                    ToolCallItem("second_tool", "c2") with { AssistantRunId = "run" },
+                };
+                var history = new ObservableCollection<AgentChatHistoryItem>();
+                using var live = CreateModel(web, history);
+                await live.HistoryLoaded;
+                foreach (var item in items) history.Add(item);
+                async Task AssertOrderAsync()
+                {
+                    var order = await EvalAsync(web, """
+                        (() => {
+                          const root = document.getElementById('chat-history-container');
+                          const calls = Array.from(root.querySelectorAll('details.chat-tool-group'));
+                          const result = Array.from(root.querySelectorAll('.chat-tool'))
+                            .find(e => e.textContent.includes('unmatched-result'));
+                          const ids = Array.from(root.querySelectorAll('[id]')).map(e => e.id);
+                          return calls.length === 2 && !!result &&
+                            !!(calls[0].compareDocumentPosition(result) & Node.DOCUMENT_POSITION_FOLLOWING) &&
+                            !!(result.compareDocumentPosition(calls[1]) & Node.DOCUMENT_POSITION_FOLLOWING) &&
+                            !result.closest('details.chat-tool-group') && ids.length === new Set(ids).size;
+                        })()
+                        """);
+                    Assert.Contains("true", order, StringComparison.Ordinal);
+                }
+                await AssertOrderAsync();
+                live.Dispose();
+                web.PostMessageToJavaScript(ChatOutputBrowserCommands.Update(
+                    "chat-history-container", "replace", "<div id=\"chat-history-container\"></div>"));
+                using var reload = CreateModel(web, new ObservableCollection<AgentChatHistoryItem>(items));
+                await reload.HistoryLoaded;
+                await AssertOrderAsync();
+            }
+            finally { window.Close(); }
+        });
+
+    [Fact]
+    public Task ToolRun_NotificationBetweenCalls_LiveAndReloadKeepSystemOutsideCollapsedSegments()
+        => this.fixture.InvokeAsync(async () =>
+        {
+            var (web, window) = await ShowReadyBrowserAsync();
+            try
+            {
+                var items = new[]
+                {
+                    ToolCallItem("first_tool", "c1") with { AssistantRunId = "ordered-run" },
+                    TextItem("agent idle") with { Role = ChatRole.System, AssistantRunId = "ordered-run" },
+                    ToolCallItem("second_tool", "c2") with { AssistantRunId = "ordered-run" },
+                };
+                var history = new ObservableCollection<AgentChatHistoryItem>();
+                var subAgents = new ObservableCollection<IRunningSubAgentDisplay>
+                    { new StubSubAgentDisplay("child", "Background agent") };
+                using var model = CreateModel(web, history, new ObservableCollection<AgentChatRunningItem>(),
+                    subAgents: subAgents);
+                await model.HistoryLoaded;
+                foreach (var item in items) history.Add(item);
+                var live = await EvalAsync(web, """
+                    (() => {
+                      const root = document.getElementById('chat-history-container');
+                      const system = root.querySelector('.chat-system-message');
+                      const groups = root.querySelectorAll('details.chat-tool-group');
+                      return JSON.stringify({
+                        ordered: groups.length === 2 &&
+                          !!(groups[0].compareDocumentPosition(system) & Node.DOCUMENT_POSITION_FOLLOWING) &&
+                          !!(system.compareDocumentPosition(groups[1]) & Node.DOCUMENT_POSITION_FOLLOWING),
+                        role: system.querySelector('.chat-sender').textContent,
+                        outside: !system.closest('details.chat-tool-group'),
+                        summaries: Array.from(groups).filter(g => !g.querySelector(':scope > summary').hidden).length,
+                        panel: document.getElementById('subagent-panel-inner').textContent.includes('Background agent')
+                      });
+                    })()
+                    """);
+                Assert.Contains("\\\"ordered\\\":true", live, StringComparison.Ordinal);
+                Assert.Contains("\\\"role\\\":\\\"system\\\"", live, StringComparison.Ordinal);
+                Assert.Contains("\\\"outside\\\":true", live, StringComparison.Ordinal);
+                Assert.Contains("\\\"summaries\\\":1", live, StringComparison.Ordinal);
+                Assert.Contains("\\\"panel\\\":true", live, StringComparison.Ordinal);
+
+                await EvalAsync(web, "document.querySelector('details.chat-tool-group > summary').click();'collapsed'");
+                var collapsed = await EvalAsync(web, """
+                    (() => {
+                      const groups = document.querySelectorAll('details.chat-tool-group');
+                      return !groups[0].open && !groups[1].open &&
+                        document.querySelector('.chat-system-message').getClientRects().length > 0;
+                    })()
+                    """);
+                Assert.Contains("true", collapsed, StringComparison.Ordinal);
+
+                web.PostMessageToJavaScript(ChatOutputBrowserCommands.Update(
+                    "chat-history-container", "replace", "<div id=\"chat-history-container\"></div>"));
+                using var reload = CreateModel(web, new ObservableCollection<AgentChatHistoryItem>(items),
+                    new ObservableCollection<AgentChatRunningItem>(), subAgents:
+                    new ObservableCollection<IRunningSubAgentDisplay>
+                        { new StubSubAgentDisplay("child", "Background agent") });
+                await reload.HistoryLoaded;
+                var restored = await EvalAsync(web,
+                    "(function(){var root=document.getElementById('chat-history-container');"
+                    + "var groups=root.querySelectorAll('details.chat-tool-group');"
+                    + "var system=root.querySelector('.chat-system-message');"
+                    + "var ids=Array.from(root.querySelectorAll('[id]')).map(e=>e.id);"
+                    + "return groups.length===2 && !!(groups[0].compareDocumentPosition(system)&4)"
+                    + " && !!(system.compareDocumentPosition(groups[1])&4)"
+                    + " && system.querySelector('.chat-sender').textContent==='system'"
+                    + " && !system.closest('details.chat-tool-group')"
+                    + " && Array.from(groups).filter(g=>!g.querySelector(':scope > summary').hidden).length===1"
+                    + " && !groups[0].open && !groups[1].open"
+                    + " && document.getElementById('subagent-panel-inner').textContent.includes('Background agent')"
+                    + " && ids.length===new Set(ids).size;})()");
+                Assert.Contains("true", restored, StringComparison.Ordinal);
+            }
+            finally { window.Close(); }
+        });
+
+    [Fact]
+    public Task ToolRun_NotificationBeforeCallAndBetweenCallResult_LiveAndReloadDomOrder()
+        => this.fixture.InvokeAsync(async () =>
+        {
+            var (web, window) = await ShowReadyBrowserAsync();
+            try
+            {
+                async Task AssertSequenceAsync(AgentChatHistoryItem[] items, bool beforeCall)
+                {
+                    var history = new ObservableCollection<AgentChatHistoryItem>();
+                    using var live = CreateModel(web, history);
+                    await live.HistoryLoaded;
+                    foreach (var item in items) history.Add(item);
+
+                    async Task AssertDomAsync()
+                    {
+                        var actual = await EvalAsync(web, """
+                            (() => {
+                              const root = document.getElementById('chat-history-container');
+                              const system = root.querySelector('.chat-system-message');
+                              const call = root.querySelector('details.chat-tool-group');
+                              const result = root.querySelector('.chat-tool:not(.chat-tool-group)');
+                              const ids = Array.from(root.querySelectorAll('[id]')).map(e => e.id);
+                              return JSON.stringify({
+                                beforeCall: !!(system.compareDocumentPosition(call) & Node.DOCUMENT_POSITION_FOLLOWING),
+                                callBeforeSystem: !!(call.compareDocumentPosition(system) & Node.DOCUMENT_POSITION_FOLLOWING),
+                                systemBeforeResult: result
+                                  ? !!(system.compareDocumentPosition(result) & Node.DOCUMENT_POSITION_FOLLOWING)
+                                  : null,
+                                resultOutside: result ? !result.closest('details.chat-tool-group') : null,
+                                role: system.querySelector('.chat-sender').textContent,
+                                unique: ids.length === new Set(ids).size
+                              });
+                            })()
+                            """);
+                        Assert.Contains($"\\\"beforeCall\\\":{beforeCall.ToString().ToLowerInvariant()}", actual, StringComparison.Ordinal);
+                        Assert.Contains($"\\\"callBeforeSystem\\\":{(!beforeCall).ToString().ToLowerInvariant()}", actual, StringComparison.Ordinal);
+                        Assert.Contains("\\\"role\\\":\\\"system\\\"", actual, StringComparison.Ordinal);
+                        Assert.Contains("\\\"unique\\\":true", actual, StringComparison.Ordinal);
+                        if (!beforeCall)
+                        {
+                            Assert.Contains("\\\"systemBeforeResult\\\":true", actual, StringComparison.Ordinal);
+                            Assert.Contains("\\\"resultOutside\\\":true", actual, StringComparison.Ordinal);
+                        }
+                    }
+
+                    await AssertDomAsync();
+                    live.Dispose();
+                    web.PostMessageToJavaScript(ChatOutputBrowserCommands.Update(
+                        "chat-history-container", "replace", "<div id=\"chat-history-container\"></div>"));
+                    using var reload = CreateModel(web, new ObservableCollection<AgentChatHistoryItem>(items));
+                    await reload.HistoryLoaded;
+                    await AssertDomAsync();
+                    reload.Dispose();
+                    web.PostMessageToJavaScript(ChatOutputBrowserCommands.Update(
+                        "chat-history-container", "replace", "<div id=\"chat-history-container\"></div>"));
+                    await EvalAsync(web, "'cleared'");
+                }
+
+                var notification = TextItem("agent idle") with { Role = ChatRole.System, AssistantRunId = "run" };
+                var call = ToolCallItem("parent_task", "c1") with { AssistantRunId = "run" };
+                await AssertSequenceAsync([notification, call], beforeCall: true);
+                var result = new AgentChatHistoryItem { Role = ChatRole.Tool, AssistantRunId = "run",
+                    Contents = [new FunctionResultContent("c1", "completed")] };
+                await AssertSequenceAsync([call, notification, result], beforeCall: false);
+            }
+            finally { window.Close(); }
+        });
+
+    [Fact]
+    public Task RemoteNotification_ActualStreamingAndSnapshotCollections_RenderInNativeBrowser()
+        => this.fixture.InvokeAsync(async () =>
+        {
+            var (web, window) = await ShowReadyBrowserAsync();
+            try
+            {
+                var events = Channel.CreateUnbounded<SessionEvent>();
+                events.Writer.TryWrite(new ToolExecutionStartEvent
+                {
+                    AgentId = string.Empty,
+                    Data = new ToolExecutionStartData { ToolCallId = "parent", ToolName = "task" },
+                });
+                events.Writer.TryWrite(new SystemNotificationEvent
+                {
+                    AgentId = string.Empty,
+                    Data = new SystemNotificationData
+                    {
+                        Content = "<system_notification>child idle</system_notification>",
+                        Kind = new SystemNotificationAgentIdle
+                        {
+                            AgentId = "child", AgentType = "background", Description = "idle",
+                        },
+                    },
+                });
+                events.Writer.TryWrite(new ToolExecutionCompleteEvent
+                {
+                    AgentId = string.Empty,
+                    Data = new ToolExecutionCompleteData
+                    {
+                        ToolCallId = "parent", Success = true,
+                        Result = new ToolExecutionCompleteResult { Content = "done" },
+                    },
+                });
+                events.Writer.Complete();
+                var updates = new List<AgentResponseUpdate>();
+                await foreach (var update in CopilotSdkStreamAdapter.TranslateCopilotSdkSessionEvents(
+                    events.Reader, CancellationToken.None))
+                    updates.Add(new AgentResponseUpdate { Role = update.Role, Contents = update.Contents });
+                var items = AgentResponseUpdateCoalescer.Coalesce(updates.ToArray(), TimeProvider.System)
+                    .Select(item => item with { AssistantRunId = "remote-run" }).ToArray();
+                Assert.Equal(new[] { ChatRole.Assistant, ChatRole.System, ChatRole.Tool },
+                    items.Select(item => item.Role));
+                static JsonElement Json(object value)
+                    => JsonSerializer.SerializeToElement(value, AIJsonUtilities.DefaultOptions);
+                var child = Json(new
+                {
+                    AgentId = "child", Name = "background", DisplayName = "Background agent",
+                    Description = "Child running", CompletionState = AgentChatCompletionState.Running,
+                    LastUpdatedAt = DateTime.UnixEpoch, SubAgents = Array.Empty<object>(),
+                });
+                var renamedChild = Json(new
+                {
+                    AgentId = "child", Name = "background", DisplayName = "Renamed child",
+                    Description = "Child running", CompletionState = AgentChatCompletionState.Running,
+                    LastUpdatedAt = DateTime.UnixEpoch, SubAgents = Array.Empty<object>(),
+                });
+                var initialSnapshot = RemoteBrowserSnapshot([], [child]);
+                var (transport, chat) = await AttachBrowserRemoteAsync(initialSnapshot);
+                await using (chat)
+                {
+                    using var loggerFactory = new ObservableLoggerFactory();
+                    await using var viewModel = new AgentViewModel(new AgentViewModelOptions
+                    {
+                        AgentChat = chat, DisplayName = "parent", Description = "",
+                        LoggerFactory = loggerFactory,
+                        ForegroundScheduler = TaskScheduler.FromCurrentSynchronizationContext(),
+                        RemoteChildResolver = (_, _, _) =>
+                            throw new InvalidOperationException("Child transcript should remain unopened."),
+                    });
+                    var childNavigation = Assert.Single(
+                        Assert.Single(viewModel.EditorItems).Children
+                            .Single(item => item.Id == "chat-sub-agents").Children);
+                    Assert.Equal("Background agent", childNavigation.Name);
+                    using var model = CreateModel(web, chat.History, chat.RunningItems,
+                        viewModel.SubAgentDisplays);
+                    await model.HistoryLoaded;
+
+                    var started = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                    ((INotifyCollectionChanged)chat.RunningItems).CollectionChanged += (_, _) =>
+                    {
+                        if (chat.RunningItems.Count == 1) started.TrySetResult();
+                    };
+                    await transport.SendAsync(RemoteBrowserFrame(2, new StreamingStartedEvent
+                    {
+                        RunId = "stream", Item = Json(items[0]),
+                    }));
+                    await started.Task.WaitAsync(TimeSpan.FromSeconds(15));
+
+                    var updated = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                    var running = Assert.Single(chat.RunningItems);
+                    running.Items.CollectionChanged += (_, _) =>
+                    {
+                        if (running.Items.Count == items.Length) updated.TrySetResult();
+                    };
+                    await transport.SendAsync(RemoteBrowserFrame(3, new StreamingUpdatedEvent
+                    {
+                        RunId = "stream", Update = Json(items),
+                    }));
+                    await updated.Task.WaitAsync(TimeSpan.FromSeconds(15));
+                    Assert.Contains("true", await EvalAsync(web, """
+                        (() => {
+                          const run = document.querySelector('.chat-running-item');
+                          const call = run?.querySelector('.chat-tool-call');
+                          const notice = run?.querySelector('.chat-system-message');
+                          const result = Array.from(run?.querySelectorAll('.chat-tool') || [])
+                            .find(e => e.textContent.includes('done'));
+                          return !!call && !!notice && !!result &&
+                            !!(call.compareDocumentPosition(notice) & Node.DOCUMENT_POSITION_FOLLOWING) &&
+                            !!(notice.compareDocumentPosition(result) & Node.DOCUMENT_POSITION_FOLLOWING) &&
+                            document.getElementById('subagent-panel-inner').textContent.includes('Background agent');
+                        })()
+                        """), StringComparison.Ordinal);
+
+                    var promoted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                    ((INotifyCollectionChanged)chat.History).CollectionChanged += (_, _) =>
+                    {
+                        if (chat.History.Count == items.Length) promoted.TrySetResult();
+                    };
+                    var renamed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                    viewModel.SubAgentDisplays[0].CompletionStateChanged += (_, _) =>
+                    {
+                        if (viewModel.SubAgentDisplays.Count == 1 &&
+                            viewModel.SubAgentDisplays[0].DisplayName == "Renamed child")
+                            renamed.TrySetResult();
+                    };
+                    await transport.SendAsync(RemoteBrowserFrame(4, new SubagentsChangedEvent
+                    {
+                        Subagents = [renamedChild],
+                    }));
+                    await renamed.Task.WaitAsync(TimeSpan.FromSeconds(15));
+                    Assert.Same(childNavigation, Assert.Single(
+                        Assert.Single(viewModel.EditorItems).Children
+                            .Single(item => item.Id == "chat-sub-agents").Children));
+                    Assert.Equal("Renamed child", childNavigation.Name);
+                    await transport.SendAsync(RemoteBrowserFrame(5, new StreamingCompletedEvent
+                    {
+                        RunId = "stream", Item = Json(items[^1]), Items = items.Select(Json).ToArray(),
+                    }));
+                    await promoted.Task.WaitAsync(TimeSpan.FromSeconds(15));
+                    await AssertRemoteBrowserOrderAsync(web, "Renamed child");
+                }
+
+                web.PostMessageToJavaScript(ChatOutputBrowserCommands.Update(
+                    "chat-history-container", "replace", "<div id=\"chat-history-container\"></div>"));
+                var (_, reloaded) = await AttachBrowserRemoteAsync(
+                    RemoteBrowserSnapshot(items.Select(Json).ToArray(), [renamedChild]));
+                await using (reloaded)
+                {
+                    using var loggerFactory = new ObservableLoggerFactory();
+                    await using var viewModel = new AgentViewModel(reloaded, "parent", "", loggerFactory,
+                        TaskScheduler.FromCurrentSynchronizationContext());
+                    using var model = CreateModel(web, reloaded.History, reloaded.RunningItems,
+                        viewModel.SubAgentDisplays);
+                    await model.HistoryLoaded;
+                    await AssertRemoteBrowserOrderAsync(web, "Renamed child");
+                }
+            }
+            finally { window.Close(); }
+        });
+
+    private static async Task AssertRemoteBrowserOrderAsync(ControllableWebViewControl web, string displayName)
+    {
+        var actual = await EvalAsync(web, """
+            (() => {
+              const root = document.getElementById('chat-history-container');
+              const call = root.querySelector('details.chat-tool-group');
+              const notice = root.querySelector('.chat-system-message');
+              const result = Array.from(root.querySelectorAll('.chat-tool'))
+                .find(e => e.textContent.includes('done'));
+              const ids = Array.from(root.querySelectorAll('[id]')).map(e => e.id);
+              return !!call && !!notice && !!result &&
+                !!(call.compareDocumentPosition(notice) & Node.DOCUMENT_POSITION_FOLLOWING) &&
+                !!(notice.compareDocumentPosition(result) & Node.DOCUMENT_POSITION_FOLLOWING) &&
+                !result.closest('details.chat-tool-group') &&
+                notice.querySelector('.chat-sender').textContent === 'system' &&
+                document.getElementById('subagent-panel-inner').textContent.includes('DISPLAY_NAME') &&
+                ids.length === new Set(ids).size;
+            })()
+            """.Replace("DISPLAY_NAME", displayName, StringComparison.Ordinal));
+        Assert.Contains("true", actual, StringComparison.Ordinal);
+    }
+
+    private static AgentSessionSnapshot RemoteBrowserSnapshot(
+        IReadOnlyList<JsonElement> history, IReadOnlyList<JsonElement> subagents) => new()
+    {
+        Information = new AgentInformation
+        {
+            AgentSessionId = "session", AgentId = "parent", Name = "parent",
+            DisplayName = "Parent", Description = "Remote parent", AcceptsUserInput = false,
+            AgentDefinition = AgentDefinitionLoader.LoadAgentFromJson("""
+                {"kind":"prompt","name":"parent","model":{"id":"echo","provider":"echo","apiType":"Echo"}}
+                """),
+        },
+        Usage = new Usage(),
+        InputQueues = new AgentInputQueuesSnapshot { Revision = 0, Queues = [] },
+        IsBusy = false, History = history, RunningItems = [], Subagents = subagents,
+        Tools = [], Modals = [], ViewerCount = 1, ContinueInBackground = false,
+    };
+
+    private static async Task<(BrowserRemoteTransport Transport, RemoteAgentChat Chat)> AttachBrowserRemoteAsync(
+        AgentSessionSnapshot snapshot)
+    {
+        var transport = new BrowserRemoteTransport();
+        var attaching = RemoteAgentChat.AttachAsync(new RemoteAgentChatAttachOptions
+        {
+            Client = new RemoteAgentSessionClient(transport),
+            OpenRequest = new AgentSessionOpenRequest
+            {
+                ProtocolVersion = 1, AgentSessionId = "session",
+                ExpectedOwningProfileEntityId = "profile", ExpectedOwnershipGeneration = 2,
+                OpenIntent = AgentSessionOpenIntent.Attach, AttachmentToken = "00112233445566778899aabbccddeeff",
+                Capabilities = ["queue", "replay"],
+            },
+            ForegroundScheduler = TaskScheduler.FromCurrentSynchronizationContext(),
+        });
+        await transport.SendAsync(RemoteBrowserFrame(1, new SessionSnapshotEvent { Snapshot = snapshot }));
+        return (transport, await attaching.WaitAsync(TimeSpan.FromSeconds(15)));
+    }
+
+    private static JsonElement RemoteBrowserFrame(long sequence, AgentSessionServerEvent value)
+        => AgentSessionProtocolCodec.SerializeFrame(
+            AgentSessionProtocolCodec.AgentSessionProtocolEventCodec.CreateFrame(
+                new RuntimeEpoch { Value = Guid.Parse("11111111-1111-1111-1111-111111111111") },
+                sequence, Guid.NewGuid(), value));
+
+    private sealed class BrowserRemoteTransport : ITransport, IMessageChannel
+    {
+        private readonly Channel<JsonElement> incoming = Channel.CreateUnbounded<JsonElement>();
+        private readonly Channel<JsonElement> outgoing = Channel.CreateUnbounded<JsonElement>();
+
+        public ChannelWriter<JsonElement> Writer => this.outgoing.Writer;
+        public ChannelReader<JsonElement> Reader => this.incoming.Reader;
+        public Task<IMessageChannel> ConnectToMessageChannelAsync(JsonElement request, CancellationToken ct = default)
+            => Task.FromResult<IMessageChannel>(this);
+        public Task<Stream> ConnectToStreamAsync(JsonElement request, CancellationToken ct = default)
+            => throw new NotSupportedException();
+        public ValueTask SendAsync(JsonElement frame) => this.incoming.Writer.WriteAsync(frame);
+        public ValueTask DisposeAsync()
+        {
+            this.incoming.Writer.TryComplete();
+            this.outgoing.Writer.TryComplete();
+            return ValueTask.CompletedTask;
+        }
+    }
+
     private static async Task<(ControllableWebViewControl Web, Window Window)> ShowReadyBrowserAsync()
     {
         var web = new ControllableWebViewControl();
@@ -1250,18 +2018,26 @@ public Task ToolRun_InterleavedTextAndMixedCalls_KeepEncounterOrderInLiveBrowser
                 var order = await EvalAsync(web, """
                     (() => {
                       const group = document.querySelector('#running-items-container details.chat-tool-group');
-                      const body = group.querySelector('.chat-tool-group-body');
+                      const root = document.querySelector('#running-items-container');
+                      const texts = Array.from(root.querySelectorAll('.chat-text'));
                       return JSON.stringify({
-                        groups: document.querySelectorAll('#running-items-container details.chat-tool-group').length,
+                        groups: root.querySelectorAll('details.chat-tool-group').length,
                         open: group.open,
-                        items: body.querySelectorAll('details.chat-tool-group-item').length,
-                        text: body.textContent
+                        items: root.querySelectorAll('details.chat-tool-group-item').length,
+                        proseOutside: texts.every(t => !t.closest('details.chat-tool-group')),
+                        summaries: Array.from(root.querySelectorAll('details.chat-tool-group > summary'))
+                          .filter(s => !s.hidden).length,
+                        total: group.querySelector('.tool-count-badge').textContent,
+                        text: root.textContent
                       });
                     })()
                     """);
-                Assert.Contains("\\\"groups\\\":1", order, StringComparison.Ordinal);
+                Assert.Contains("\\\"groups\\\":2", order, StringComparison.Ordinal);
                 Assert.Contains("\\\"open\\\":true", order, StringComparison.Ordinal);
                 Assert.Contains("\\\"items\\\":2", order, StringComparison.Ordinal);
+                Assert.Contains("\\\"proseOutside\\\":true", order, StringComparison.Ordinal);
+                Assert.Contains("\\\"summaries\\\":1", order, StringComparison.Ordinal);
+                Assert.Contains("2 calls", order, StringComparison.Ordinal);
                 var read = order.IndexOf("read", StringComparison.Ordinal);
                 var between = order.IndexOf("between calls", StringComparison.Ordinal);
                 var beforeWrite = order.IndexOf("before write", StringComparison.Ordinal);
@@ -1295,12 +2071,14 @@ public Task ToolRun_StreamingTextBecomesMixedCall_ReclassifiesIntoSingleGroup()
                 };
                 var state = await EvalAsync(web, """
                     (() => {
-                      const group = document.querySelector('#running-items-container details.chat-tool-group');
-                      return JSON.stringify({ count: document.querySelectorAll('#running-items-container details.chat-tool-group').length,
-                        text: group?.textContent || '' });
+                      const root = document.querySelector('#running-items-container');
+                      return JSON.stringify({ count: root.querySelectorAll('details.chat-tool-group-item').length,
+                        proseOutside: !root.querySelector('.chat-text')?.closest('details.chat-tool-group-item'),
+                        text: root.textContent });
                     })()
                     """);
                 Assert.Contains("\\\"count\\\":1", state, StringComparison.Ordinal);
+                Assert.Contains("\\\"proseOutside\\\":true", state, StringComparison.Ordinal);
                 Assert.Contains("thinking", state, StringComparison.Ordinal);
                 Assert.Contains("read", state, StringComparison.Ordinal);
             }
@@ -1630,9 +2408,9 @@ private static async Task MakePageScrollableAndScrollToBottomAsync(ControllableW
 
     private static ChatOutputHtmlModel CreateModel(
         ControllableWebViewControl web,
-        ObservableCollection<AgentChatHistoryItem> history,
-        ObservableCollection<AgentChatRunningItem>? running = null,
-        ObservableCollection<IRunningSubAgentDisplay>? subAgents = null)
+        IReadOnlyList<AgentChatHistoryItem> history,
+        IReadOnlyList<AgentChatRunningItem>? running = null,
+        IReadOnlyList<IRunningSubAgentDisplay>? subAgents = null)
         => new(
             history,
             running ?? [],
diff --git a/Phantom.Workspaces.Agent.Gui.WebViewTests/ChatOutputByokEndToEndWebViewTests.cs b/Phantom.Workspaces.Agent.Gui.WebViewTests/ChatOutputByokEndToEndWebViewTests.cs
index c6741fc3..027a1608 100644
--- a/Phantom.Workspaces.Agent.Gui.WebViewTests/ChatOutputByokEndToEndWebViewTests.cs
+++ b/Phantom.Workspaces.Agent.Gui.WebViewTests/ChatOutputByokEndToEndWebViewTests.cs
@@ -313,6 +313,7 @@ [new FunctionCallContent(
 
                     // ---- Assert the DOM without any refresh/reload ---------------------------
                     parentBrowser.EndBatch();
+                    await WaitForDomTextAsync(parentBrowser, ["FINAL-REPLY", "hello world 1", "hello world 2"], timeout);
                     var parentDom = await EvalAsync(parentBrowser, "document.body.innerHTML");
                     Assert.Contains("FINAL-REPLY", parentDom, StringComparison.Ordinal);
                     Assert.Contains("hello world 1", parentDom, StringComparison.Ordinal);
@@ -321,6 +322,7 @@ [new FunctionCallContent(
                     foreach (var (marker, expectedText, subBrowser) in subMarkers)
                     {
                         subBrowser.EndBatch();
+                        await WaitForDomTextAsync(subBrowser, [marker, expectedText], timeout);
                         var subDom = await EvalAsync(subBrowser, "document.body.innerHTML");
                         Assert.Contains(marker, subDom, StringComparison.Ordinal);
                         Assert.Contains(expectedText, subDom, StringComparison.Ordinal);
@@ -393,6 +395,10 @@ public Task AgentChatOutput_ByokSubagents_ProductionWiring_SubAgentDomArrivesLiv
             mainFinalTurn.EnqueueUpdate(new ChatResponseUpdate(ChatRole.Assistant, "FINAL-REPLY: hello world 1."));
             mainFinalTurn.Complete();
 
+            // The completed background task queues one system notification turn after
+            // the final reply, as in the two-subagent exchange above.
+            main.Client.EnqueueStreamingResponse().Complete();
+
             var subOne = server.AddConversation(
                 "sub-one",
                 request => request.AnyMessageContains("user", "SUBAGENT-ONE"));
@@ -673,6 +679,47 @@ void OnChanged(object? sender, NotifyCollectionChangedEventArgs e)
         }
     }
 
+    private static async Task WaitForDomTextAsync(
+        ControllableWebViewControl browser, string[] fragments, TimeSpan timeout)
+    {
+        var signal = $"dom-ready:{Guid.NewGuid():N}";
+        var ready = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        void OnMessage(object? sender, string body)
+        {
+            if (body == signal)
+            {
+                ready.TrySetResult();
+            }
+        }
+
+        browser.JavaScriptMessageReceived += OnMessage;
+        try
+        {
+            await browser.InvokeScript($$"""
+                (function () {
+                    const fragments = {{System.Text.Json.JsonSerializer.Serialize(fragments)}};
+                    function check() {
+                        if (document.body && fragments.every(fragment => document.body.innerHTML.includes(fragment))) {
+                            window.chrome.webview.postMessage({{System.Text.Json.JsonSerializer.Serialize(signal)}});
+                            return true;
+                        }
+                        return false;
+                    }
+                    if (!check()) {
+                        new MutationObserver(function (mutations, observer) {
+                            if (check()) { observer.disconnect(); }
+                        }).observe(document.documentElement, { childList: true, subtree: true, characterData: true });
+                    }
+                }());
+                """);
+            await ready.Task.WaitAsync(timeout);
+        }
+        finally
+        {
+            browser.JavaScriptMessageReceived -= OnMessage;
+        }
+    }
+
     private static ControllableWebViewControl GetBrowser(AgentChatOutputControl control)
     {
         var field = typeof(AgentChatOutputControl).GetField("browser", BindingFlags.Instance | BindingFlags.NonPublic)!;
diff --git a/Phantom.Workspaces.Agent.Gui/Assets/chat-output-shell.html b/Phantom.Workspaces.Agent.Gui/Assets/chat-output-shell.html
index 1f82503c..b8b35ead 100644
--- a/Phantom.Workspaces.Agent.Gui/Assets/chat-output-shell.html
+++ b/Phantom.Workspaces.Agent.Gui/Assets/chat-output-shell.html
@@ -131,6 +131,11 @@
       padding-left: 1.5em;
     }
 
+    .chat-system-message .chat-contents {
+      padding-left: 1.5em;
+      color: var(--chat-meta);
+    }
+
     .chat-help {
       white-space: pre-wrap;
       font-family: var(--chat-font-family);
@@ -323,6 +328,45 @@
       color: var(--chat-tool-summary);
     }
 
+    .chat-contents:has(> .chat-tool-group-actions),
+    .chat-tool-segment {
+      position: relative;
+    }
+
+    .chat-tool-group-actions {
+      position: absolute;
+      right: 0;
+      top: 0;
+      z-index: 2;
+      display: flex;
+      align-items: center;
+      gap: 0.25em;
+    }
+
+    .chat-tool-group-actions + .chat-tool-group > summary {
+      padding-right: 4em;
+    }
+
+    .chat-tool-segment > .chat-tool-group-actions {
+      position: relative;
+      justify-content: flex-end;
+      flex-wrap: wrap;
+      max-width: 100%;
+    }
+
+    .chat-tool-segment > .chat-tool-group-actions + .chat-tool-group > summary {
+      padding-right: 0;
+    }
+
+    .chat-tool-group-secondary > summary[hidden] {
+      display: none;
+    }
+
+    .chat-contents:has(> .chat-tool-group-secondary:not([open])) > .chat-tool-group-actions,
+    .chat-tool-segment:has(> .chat-tool-group-secondary) > .chat-tool-group-actions {
+      display: none;
+    }
+
     .tool-count-badge {
       font-size: 0.75em;
       opacity: 0.6;
@@ -611,17 +655,73 @@
     })();
   </script>
   <script>
-    /* Keep a run's expanded tools open when streaming content moves into history. */
+    /* A run's tool-only segments share one visible summary and collapse state. */
     (function () {
       var expandedRuns = new Map();
+      function reconcileRun(id) {
+        var groups = Array.from(document.querySelectorAll("details.chat-tool-group[data-assistant-run-id]"))
+          .filter(function (group) { return group.getAttribute("data-assistant-run-id") === id; });
+        if (!groups.length) { return; }
+        var names = [];
+        var count = 0;
+        groups.forEach(function (group, index) {
+          var summary = group.querySelector(":scope > summary");
+          if (!summary) { return; }
+          summary.hidden = index !== 0;
+          group.classList.toggle("chat-tool-group-secondary", index !== 0);
+          count += Number(summary.getAttribute("data-segment-call-count")) || 0;
+          try {
+            JSON.parse(summary.getAttribute("data-segment-tool-names") || "[]").forEach(function (name) {
+              if (!names.includes(name)) { names.push(name); }
+            });
+          } catch (_) { /* A malformed attribute must not break collapsing tools. */ }
+        });
+        var leader = groups[0].querySelector(":scope > summary");
+        if (!leader) { return; }
+        var title = names.length ? "tools (" + names.join(", ") + ")" : "tools";
+        var label = leader.querySelector(".tool-group-label");
+        if (label && label.textContent !== title) { label.textContent = title; }
+        var badge = leader.querySelector(".tool-count-badge");
+        if (badge && badge.textContent !== count + " calls") { badge.textContent = count + " calls"; }
+        groups.forEach(function (group) {
+          var message = group.closest(".chat-message");
+          if (message && typeof InlineToolSegmentGutter !== "undefined") {
+            InlineToolSegmentGutter.reconcile(message, "data-inspect-target",
+              "inspect-gutter-btn", "Open in inspector", "\u24d8");
+            InlineToolSegmentGutter.reconcile(message, "data-usage-inspect-target",
+              "usage-gutter-btn", "Open token usage details", "#");
+          }
+        });
+        var leaderHost = groups[0].previousElementSibling;
+        if (leaderHost && leaderHost.matches(".chat-tool-group-actions")) {
+          leaderHost.querySelectorAll("[data-segment-origin-id]").forEach(function (button) {
+            if (!document.getElementById(button.getAttribute("data-segment-origin-id"))) { button.remove(); }
+          });
+        }
+      }
       document.addEventListener("toggle", function (event) {
         var group = event.target;
         if (group.matches && group.matches("details.chat-tool-group[data-assistant-run-id]")) {
-          expandedRuns.set(group.getAttribute("data-assistant-run-id"), group.open);
+          var id = group.getAttribute("data-assistant-run-id");
+          expandedRuns.set(id, group.open);
+          document.querySelectorAll("details.chat-tool-group[data-assistant-run-id]").forEach(function (other) {
+            if (other !== group && other.getAttribute("data-assistant-run-id") === id) {
+              other.open = group.open;
+            }
+          });
         }
       }, true);
       new MutationObserver(function (mutations) {
+        var changed = new Set();
         mutations.forEach(function (mutation) {
+          mutation.removedNodes.forEach(function (node) {
+            if (node.nodeType !== 1) { return; }
+            var groups = node.matches("details.chat-tool-group[data-assistant-run-id]")
+              ? [node] : node.querySelectorAll("details.chat-tool-group[data-assistant-run-id]");
+            groups.forEach(function (group) {
+              changed.add(group.getAttribute("data-assistant-run-id"));
+            });
+          });
           mutation.addedNodes.forEach(function (node) {
             if (node.nodeType !== 1) { return; }
             var groups = node.matches("details.chat-tool-group[data-assistant-run-id]")
@@ -629,12 +729,99 @@
             groups.forEach(function (group) {
               var id = group.getAttribute("data-assistant-run-id");
               if (expandedRuns.has(id)) { group.open = expandedRuns.get(id); }
+              changed.add(id);
             });
+            var owningGroup = node.closest("details.chat-tool-group[data-assistant-run-id]");
+            if (owningGroup) { changed.add(owningGroup.getAttribute("data-assistant-run-id")); }
           });
         });
+        changed.forEach(reconcileRun);
       }).observe(document.body, { childList: true, subtree: true });
     })();
   </script>
+  <script>
+    var InlineToolSegmentGutter = (function () {
+      "use strict";
+
+      function reconcile(message, marker, buttonClass, label, glyph) {
+        var segments = Array.from(message.querySelectorAll(":scope > .chat-contents > .chat-tool-segment"));
+        var contents = message.querySelector(":scope > .chat-contents");
+        if (contents && contents.querySelector(":scope > details.chat-tool-group[data-assistant-run-id]")) {
+          segments.push(contents);
+        }
+        if (!segments.length) { return false; }
+        message.querySelectorAll(":scope > .chat-header ." + buttonClass +
+          ", :scope > .chat-contents > ." + buttonClass).forEach(function (button) { button.remove(); });
+
+        segments.forEach(function (segment) {
+          var group = segment.querySelector(":scope > details.chat-tool-group[data-assistant-run-id]");
+          var runId = group && group.getAttribute("data-assistant-run-id");
+          var leader = runId && Array.from(document.querySelectorAll("details.chat-tool-group[data-assistant-run-id]"))
+            .find(function (candidate) { return candidate.getAttribute("data-assistant-run-id") === runId; });
+          var host = leader && leader.previousElementSibling;
+          if (!host || !host.matches(".chat-tool-group-actions")) {
+            host = segment.querySelector(":scope > .chat-tool-group-actions");
+          }
+          if (!host) { return; }
+          var originId = segment.id;
+          document.querySelectorAll("." + buttonClass +
+            "[data-segment-origin-id=\"" + CSS.escape(originId) + "\"]").forEach(function (button) {
+            if (button.parentElement !== host) { button.remove(); }
+          });
+          segment.querySelectorAll(":scope > .chat-tool-group-actions > ." + buttonClass).forEach(function (button) {
+            if (!button.hasAttribute("data-segment-origin-id") || button.parentElement !== host) { button.remove(); }
+          });
+          var targets = Array.from(segment.querySelectorAll("[" + marker + "][id]"));
+          if (segment.matches(".chat-tool-segment")) {
+            for (var sibling = segment.nextElementSibling;
+                 sibling && !sibling.matches(".chat-tool-segment"); sibling = sibling.nextElementSibling) {
+              if (marker === "data-usage-inspect-target" ||
+                  sibling.matches(".chat-tool[data-inspect-target]")) {
+                if (sibling.matches("[" + marker + "][id]")) { targets.push(sibling); }
+                sibling.querySelectorAll("[" + marker + "][id]").forEach(function (target) { targets.push(target); });
+              }
+            }
+          }
+
+          var ids = new Set(targets.map(function (target) { return target.id; }));
+          host.querySelectorAll(":scope > ." + buttonClass +
+            "[data-segment-origin-id=\"" + CSS.escape(originId) + "\"]").forEach(function (button) {
+            if (!ids.has(button.getAttribute("data-segment-target-id"))) { button.remove(); }
+          });
+          targets.forEach(function (target) {
+            if (Array.from(host.querySelectorAll(":scope > ." + buttonClass +
+              "[data-segment-origin-id=\"" + CSS.escape(originId) + "\"]"))
+              .some(function (button) { return button.getAttribute("data-segment-target-id") === target.id; })) {
+              return;
+            }
+            var button = document.createElement("button");
+            button.type = "button";
+            button.className = "chat-affordance-btn " + buttonClass;
+            button.setAttribute("aria-label", label + " (" + target.id + ")");
+            button.setAttribute("data-segment-target-id", target.id);
+            button.setAttribute("data-segment-origin-id", originId);
+            button.textContent = glyph;
+            button.addEventListener("click", function (event) {
+              event.stopPropagation();
+              var current = document.getElementById(button.getAttribute("data-segment-target-id"));
+              var origin = document.getElementById(button.getAttribute("data-segment-origin-id"));
+              if (!current || !origin || !origin.closest(".chat-message").contains(current)) { return; }
+              if (window.chrome && window.chrome.webview && window.chrome.webview.postMessage) {
+                window.chrome.webview.postMessage(JSON.stringify({
+                  type: "inspect", contentId: current.id,
+                  contentJson: current.getAttribute("data-details-target") || ""
+                }));
+              }
+            });
+            host.appendChild(button);
+          });
+        });
+        return true;
+      }
+
+      return { reconcile: reconcile };
+    })();
+  </script>
   <script>
      /* inspect-gutter.js — message-header inspect button component.
      * Call InspectGutter.init(root) to wire up all [data-inspect-target] elements inside root.
@@ -672,6 +859,8 @@
       }
 
       function reconcile(message) {
+        if (InlineToolSegmentGutter.reconcile(message, "data-inspect-target",
+          "inspect-gutter-btn", "Open in inspector", "\u24d8")) { return; }
         var targetId = message.getAttribute("data-message-inspect-target");
         var target = targetId ? document.getElementById(targetId) : null;
         if (!target || !message.contains(target) || !target.hasAttribute("data-inspect-target")) {
@@ -686,9 +875,13 @@
         var header = message.querySelector(":scope > .chat-header");
         var meta = header && header.querySelector(":scope > .chat-meta");
         if (!meta) { return; }
-        var host = header.hidden ? message.querySelector(":scope > .chat-contents") : meta;
+        var host = header.hidden
+          ? message.querySelector(":scope > .chat-contents > .chat-tool-group-actions")
+            || message.querySelector(":scope > .chat-contents > .chat-tool-segment > .chat-tool-group-actions")
+            || message.querySelector(":scope > .chat-contents")
+          : meta;
         if (!host) { return; }
-        var existing = message.querySelector(":scope > .chat-header .inspect-gutter-btn, :scope > .chat-contents > .inspect-gutter-btn");
+        var existing = message.querySelector(":scope > .chat-header .inspect-gutter-btn, :scope > .chat-contents > .inspect-gutter-btn, :scope > .chat-contents > .chat-tool-group-actions > .inspect-gutter-btn, :scope > .chat-contents > .chat-tool-segment > .chat-tool-group-actions > .inspect-gutter-btn");
         if (!target) {
           if (existing) { existing.remove(); }
           return;
@@ -749,6 +942,8 @@
       }
 
       function reconcile(message) {
+        if (InlineToolSegmentGutter.reconcile(message, "data-usage-inspect-target",
+          "usage-gutter-btn", "Open token usage details", "#")) { return; }
         var targetId = message.getAttribute("data-message-usage-target");
         var marker = targetId ? document.getElementById(targetId) : null;
         if (!marker || !message.contains(marker) || !marker.hasAttribute("data-usage-inspect-target")) {
@@ -763,9 +958,13 @@
         var header = message.querySelector(":scope > .chat-header");
         var meta = header && header.querySelector(":scope > .chat-meta");
         if (!meta) { return; }
-        var host = header.hidden ? message.querySelector(":scope > .chat-contents") : meta;
+        var host = header.hidden
+          ? message.querySelector(":scope > .chat-contents > .chat-tool-group-actions")
+            || message.querySelector(":scope > .chat-contents > .chat-tool-segment > .chat-tool-group-actions")
+            || message.querySelector(":scope > .chat-contents")
+          : meta;
         if (!host) { return; }
-        var existing = message.querySelector(":scope > .chat-header .usage-gutter-btn, :scope > .chat-contents > .usage-gutter-btn");
+        var existing = message.querySelector(":scope > .chat-header .usage-gutter-btn, :scope > .chat-contents > .usage-gutter-btn, :scope > .chat-contents > .chat-tool-group-actions > .usage-gutter-btn, :scope > .chat-contents > .chat-tool-segment > .chat-tool-group-actions > .usage-gutter-btn");
         if (!marker) {
           if (existing) { existing.remove(); }
           return;
diff --git a/Phantom.Workspaces.Agent.Gui/ViewModels/AgentViewModel.cs b/Phantom.Workspaces.Agent.Gui/ViewModels/AgentViewModel.cs
index fe8768a0..8ffa1111 100644
--- a/Phantom.Workspaces.Agent.Gui/ViewModels/AgentViewModel.cs
+++ b/Phantom.Workspaces.Agent.Gui/ViewModels/AgentViewModel.cs
@@ -32,6 +32,8 @@ public sealed class AgentViewModel : ViewModelBase, IAutoScrollViewModel, IAsync
     private readonly List<AgentViewModel> subAgentViewModels = [];
     private readonly List<RunningAgentChatLease> subAgentLeases = [];
     private readonly ObservableCollection<IRunningSubAgentDisplay> subAgentDisplayItems = [];
+    private readonly Dictionary<IRunningSubAgent, IRunningSubAgentDisplay> remoteSubAgentDisplays =
+        new(ReferenceEqualityComparer.Instance);
     private readonly ObservableCollection<AgentDetailDocumentItem> allDetailContents = [];
     private readonly ObservableCollection<AgentSessionModalViewModel> modalSource = [];
     private readonly Dictionary<AgentViewModel, NotifyCollectionChangedEventHandler> subAgentDetailSubscriptions = new();
@@ -860,24 +862,33 @@ private void OnSubAgentsCollectionChanged(object? sender, NotifyCollectionChange
     {
         var selectedId = e.Action == NotifyCollectionChangedAction.Replace
             ? this.RootView().SelectedEditorItem?.Id : null;
+        if (e.Action == NotifyCollectionChangedAction.Reset && this.agentChat is RemoteAgentChat)
+        {
+            foreach (var child in this.remoteChildren.Values.ToArray())
+                this.RemoveRemoteChild(child.Reference.AgentId);
+            foreach (var display in this.remoteSubAgentDisplays.Values)
+            {
+                this.subAgentDisplayItems.Remove(display);
+                if (display is IDisposable disposable) disposable.Dispose();
+            }
+            this.remoteSubAgentDisplays.Clear();
+            foreach (var subAgent in this.agentChat.SubAgents)
+                this.AddSubAgentSlot(subAgent);
+            return;
+        }
+
         if (e.OldItems is not null)
         {
             foreach (IRunningSubAgent subAgent in e.OldItems)
             {
-                RemoteChildSlot? remote = null;
-                if (this.remoteChildren.Remove(subAgent.AgentId, out remote))
+                this.RemoveRemoteChild(subAgent.AgentId);
+                if (this.remoteSubAgentDisplays.Remove(subAgent, out var display))
                 {
-                    remote.Cancellation.Cancel();
-                    if (remote.StatusHandler is not null)
-                        remote.Reference.CompletionStateChanged -= remote.StatusHandler;
-                    this.subAgentAllChildren.Remove(remote.Navigation);
-                    this.allDetailContents.Remove(remote.Document);
-                    this.subAgentsTransformer.Refresh();
-                    if (this.SelectedEditorItem?.Id == remote.Navigation.Id)
-                        this.SelectedEditorItem = this.subAgentsNavItem;
+                    this.subAgentDisplayItems.Remove(display);
+                    if (display is IDisposable disposable) disposable.Dispose();
                 }
-                var removal = this.RemoveSubAgentDetailContents(subAgent.AgentId);
-                if (remote is not null) _ = this.DisposeRemoteChildAsync(remote, removal);
+                else
+                    _ = this.RemoveSubAgentDetailContents(subAgent.AgentId);
             }
         }
         if (e.NewItems is not null)
@@ -891,8 +902,32 @@ private void OnSubAgentsCollectionChanged(object? sender, NotifyCollectionChange
         }
     }
 
+    private void RemoveRemoteChild(string agentId)
+    {
+        if (!this.remoteChildren.Remove(agentId, out var remote)) return;
+        remote.Cancellation.Cancel();
+        if (remote.StatusHandler is not null)
+            remote.Reference.CompletionStateChanged -= remote.StatusHandler;
+        this.subAgentAllChildren.Remove(remote.Navigation);
+        this.allDetailContents.Remove(remote.Document);
+        this.subAgentsTransformer.Refresh();
+        if (this.SelectedEditorItem?.Id == remote.Navigation.Id)
+            this.SelectedEditorItem = this.subAgentsNavItem;
+        _ = this.DisposeRemoteChildAsync(remote, this.RemoveSubAgentDetailContents(agentId));
+    }
+
     private void AddSubAgentSlot(IRunningSubAgent subAgent)
     {
+        if (this.agentChat is RemoteAgentChat)
+        {
+            var display = new RemoteRunningSubAgentDisplay(subAgent);
+            this.remoteSubAgentDisplays.Add(subAgent, display);
+            this.subAgentDisplayItems.Add(display);
+            if (subAgent is IRemoteSubagentReference remoteReference && this.remoteChildResolver is not null)
+                this.AddRemoteChild(remoteReference);
+            return;
+        }
+
         // Handle both AgentChat (eager path from GetOrCreateAsync) and SubAgent (lazy path from RestoreSubAgentsAsync)
         if (subAgent is AgentChat agentChat)
         {
@@ -1075,6 +1110,7 @@ private void AddRemoteChild(IRemoteSubagentReference remote)
             CancellationTokenSource.CreateLinkedTokenSource(this.remoteChildrenLifetime.Token));
         slot.StatusHandler = (_, _) =>
         {
+            slot.Navigation.Name = remote.DisplayName;
             slot.Navigation.RefreshStatus();
             this.subAgentsTransformer.Refresh();
             this.subAgentsContainerDetail.NotifySubAgentUpdated();
diff --git a/Phantom.Workspaces.Agent.Gui/ViewModels/DocumentModels/ChatOutputHtmlModels.cs b/Phantom.Workspaces.Agent.Gui/ViewModels/DocumentModels/ChatOutputHtmlModels.cs
index e5fe773d..3b58e2aa 100644
--- a/Phantom.Workspaces.Agent.Gui/ViewModels/DocumentModels/ChatOutputHtmlModels.cs
+++ b/Phantom.Workspaces.Agent.Gui/ViewModels/DocumentModels/ChatOutputHtmlModels.cs
@@ -260,9 +260,10 @@ internal void Render(bool emit)
 
         // Pre-scan: build a CallId → result lookup for content-level call+result pairing.
         Dictionary<string, FunctionResultContent>? resultLookup = null;
-        foreach (var content in this.source.Contents)
+        for (var i = 0; i < this.source.Contents.Count; i++)
         {
-            if (content is FunctionResultContent result && result.CallId is not null)
+            if (this.source.Contents[i] is FunctionResultContent result &&
+                result.CallId is not null && this.HasAdjacentCallForResult(i, result.CallId))
             {
                 resultLookup ??= new Dictionary<string, FunctionResultContent>(StringComparer.Ordinal);
                 resultLookup.TryAdd(result.CallId, result);
@@ -350,7 +351,14 @@ resultLookup is not null &&
                 }
 
                 var groupKey = "group:" + string.Join("\x02", keyParts);
-                var groupHtml = ChatOutputHtmlRenderer.RenderToolGroup(elementId, calls, resultLookup);
+                var mixedRunId = this.source.AssistantRunId is { } runId &&
+                    this.source.Role == ChatRole.Assistant &&
+                    this.source.Contents.Any(item => item is not FunctionCallContent)
+                    ? runId : null;
+                var groupHtml = mixedRunId is not null
+                    ? ChatOutputHtmlRenderer.RenderInlineToolSegment(elementId, mixedRunId, calls,
+                        ChatOutputHtmlRenderer.RenderToolGroup(elementId + "-tool", calls, resultLookup))
+                    : ChatOutputHtmlRenderer.RenderToolGroup(elementId, calls, resultLookup);
                 newBindings.Add(new ContentBinding(groupKey, elementId, groupHtml));
                 continue;
             }
@@ -388,6 +396,19 @@ claimedResultCallIds is not null &&
         this.renderedRoleLabel = roleLabel;
     }
 
+    private bool HasAdjacentCallForResult(int resultIndex, string callId)
+    {
+        for (var i = resultIndex - 1; i >= 0; i--)
+        {
+            var content = this.source.Contents[i];
+            if (content is FunctionResultContent ||
+                content is TextContent text && string.IsNullOrWhiteSpace(text.Text))
+                continue;
+            return content is FunctionCallContent call && call.CallId == callId;
+        }
+        return false;
+    }
+
     private void EmitDiff(List<ContentBinding> newBindings, string roleLabel, bool visibilityChanged)
     {
         if (!string.Equals(this.renderedRoleLabel, roleLabel, StringComparison.Ordinal))
@@ -780,7 +801,7 @@ protected override void Update(RenderSlot target, AgentChatHistoryItem sourceIte
             // call models up to date with the replacement results.
             if (!target.HasDomElement && IsToolResultOnlyItem(sourceItem))
             {
-                this.TryInjectResults(sourceItem);
+                this.TryInjectResults(sourceItem, this.Target.IndexOf(target));
             }
 
             // The message's role label may have flipped in-place (Update path); reconcile role runs
@@ -936,7 +957,7 @@ private void ClassifyAndInsert(int index, RenderSlot slot)
         // when every result matches a known call: each result is injected into the matched call
         // model so it renders nested under its call item. Any unmatched result keeps the whole
         // message standalone.
-        if (IsToolResultOnlyItem(sourceItem) && this.TryInjectResults(sourceItem))
+        if (IsToolResultOnlyItem(sourceItem) && this.TryInjectResults(sourceItem, index))
         {
             slot.HasDomElement = false;
             return;
@@ -954,11 +975,8 @@ private void ClassifyAndInsert(int index, RenderSlot slot)
         slot.HasDomElement = true;
 
         var isToolCall = IsRunToolCallItem(sourceItem);
-        var groupablePredecessor = isToolCall || sourceItem.AssistantRunId is not null &&
-            sourceItem.Role == ChatRole.Assistant
-            ? this.FindGroupablePredecessor(index)
-            : null;
-        if (isToolCall || groupablePredecessor?.Group is not null)
+        var groupablePredecessor = isToolCall ? this.FindGroupablePredecessor(index) : null;
+        if (isToolCall)
         {
             if (groupablePredecessor is not null)
             {
@@ -1220,7 +1238,7 @@ private StructuralCategory Categorize(AgentChatHistoryItem item)
     /// the call models matched via the shared call-id map. All results must match for injection to
     /// happen; returns false (and injects nothing) when any result is unmatched.
     /// </summary>
-    private bool TryInjectResults(AgentChatHistoryItem item)
+    private bool TryInjectResults(AgentChatHistoryItem item, int resultIndex)
     {
         List<(RenderSlot MatchedSlot, FunctionResultContent Result)>? matches = null;
         foreach (var content in item.Contents)
@@ -1228,7 +1246,8 @@ private bool TryInjectResults(AgentChatHistoryItem item)
             var result = (FunctionResultContent)content;
             if (result.CallId is null || !this.sharedSlotByCallId.TryGetValue(result.CallId, out var matchedSlot) ||
                 item.AssistantRunId is not null && matchedSlot.Model.Source.AssistantRunId is not null &&
-                item.AssistantRunId != matchedSlot.Model.Source.AssistantRunId)
+                item.AssistantRunId != matchedSlot.Model.Source.AssistantRunId ||
+                HasInterveningVisibleContent(this.Target, this.Target.IndexOf(matchedSlot), resultIndex))
             {
                 return false;
             }
@@ -1250,6 +1269,18 @@ item.AssistantRunId is not null && matchedSlot.Model.Source.AssistantRunId is no
         return true;
     }
 
+    internal static bool HasInterveningVisibleContent(IList<RenderSlot> slots, int callIndex, int resultIndex)
+    {
+        // Other tool calls may share a grouped result message, but visible narration must retain its position.
+        if (callIndex < 0 || callIndex >= resultIndex) return true;
+        for (var i = callIndex + 1; i < resultIndex; i++)
+        {
+            if (slots[i].HasDomElement && !IsRunToolCallItem(slots[i].Model.Source))
+                return true;
+        }
+        return false;
+    }
+
     private void AddCallIdsToIndex(AgentChatHistoryItem sourceItem, RenderSlot slot)
     {
         foreach (var content in sourceItem.Contents)
@@ -1328,9 +1359,7 @@ internal static bool IsToolCallOnlyItem(AgentChatHistoryItem item)
     }
 
     internal static bool IsRunToolCallItem(AgentChatHistoryItem item)
-        => IsToolCallOnlyItem(item) ||
-           item.AssistantRunId is not null && item.Role == ChatRole.Assistant &&
-           item.Contents.Any(content => content is FunctionCallContent);
+        => IsToolCallOnlyItem(item);
 
     /// <summary>
     /// Looks up the slot whose source message contains a <see cref="FunctionCallContent"/> with the
@@ -1356,13 +1385,11 @@ internal static bool IsRunToolCallItem(AgentChatHistoryItem item)
     /// </summary>
     internal static bool IsGroupingTransparent(RenderSlot slot)
         => !slot.HasDomElement
-            || IsToolResultOnlyItem(slot.Model.Source)
             || slot.Model.ProducesNoVisibleContent;
 
     /// <summary>
-    /// Finds the previous call in this assistant run, crossing visible assistant content only when
-    /// both items have the same explicit run id. Legacy items still group only across transparent slots.
-    /// A user message or a different run always terminates the search.
+    /// Finds the previous contiguous call in this assistant run. Visible prose and system
+    /// notifications end a segment even when they share the same run id.
     /// </summary>
     internal RenderSlot? FindGroupablePredecessor(int index)
     {
@@ -1375,12 +1402,6 @@ internal static bool IsGroupingTransparent(RenderSlot slot)
                 return null;
             }
             var candidateRunId = candidate.Model.Source.AssistantRunId;
-            if (runId is not null && candidateRunId == runId &&
-                !IsRunToolCallItem(candidate.Model.Source) &&
-                candidate.Group is null)
-            {
-                continue;
-            }
             if (runId is not null && candidateRunId != runId ||
                 runId is null && candidateRunId is not null)
             {
@@ -1471,7 +1492,7 @@ private void ReconcileRoleHeaders()
             }
 
             var isLeader = !string.Equals(previousRole, effectiveRole, StringComparison.OrdinalIgnoreCase);
-            var suppress = !isLeader;
+            var suppress = !isLeader && !string.Equals(effectiveRole, "system", StringComparison.OrdinalIgnoreCase);
 
             slot.Model.SetSuppressRoleHeader(suppress, emit: slot.Model.IsInserted);
             previousGroupOwner = null;
@@ -2119,7 +2140,8 @@ internal static HistoryRenderPlan BuildHistoryRenderPlan(
                 var result = (FunctionResultContent)content;
                 if (result.CallId is null || !slotByCallId.TryGetValue(result.CallId, out var matchedSlot) ||
                     item.AssistantRunId is not null && matchedSlot.Model.Source.AssistantRunId is not null &&
-                    item.AssistantRunId != matchedSlot.Model.Source.AssistantRunId)
+                    item.AssistantRunId != matchedSlot.Model.Source.AssistantRunId ||
+                    ChatMessageHtmlTransformer.HasInterveningVisibleContent(slots, Array.IndexOf(slots, matchedSlot), i))
                 {
                     allMatched = false;
                     break;
@@ -2144,19 +2166,12 @@ item.AssistantRunId is not null && matchedSlot.Model.Source.AssistantRunId is no
         // Pass 3: use explicit run boundaries where available; legacy messages retain contiguous grouping.
         for (var i = 0; i < snapshot.Count; i++)
         {
-            if (!slots[i].HasDomElement || !(ChatMessageHtmlTransformer.IsRunToolCallItem(snapshot[i]) ||
-                snapshot[i].AssistantRunId is not null && snapshot[i].Role == ChatRole.Assistant &&
-                PreviousRunGroup(i) is not null))
+            if (!slots[i].HasDomElement || !ChatMessageHtmlTransformer.IsRunToolCallItem(snapshot[i]))
             {
                 continue;
             }
 
-            var groupablePredecessor = PreviousRunGroup(i);
-            if (groupablePredecessor is null && !ChatMessageHtmlTransformer.IsRunToolCallItem(snapshot[i]))
-            {
-                continue;
-            }
-            if (groupablePredecessor is null)
+            RenderSlot? groupablePredecessor = null;
             for (var j = i - 1; j >= 0; j--)
             {
                 if (snapshot[j].Role == ChatRole.User)
@@ -2164,12 +2179,6 @@ item.AssistantRunId is not null && matchedSlot.Model.Source.AssistantRunId is no
                     break;
                 }
                 var runId = snapshot[i].AssistantRunId;
-                if (runId is not null && snapshot[j].AssistantRunId == runId &&
-                    !ChatMessageHtmlTransformer.IsRunToolCallItem(snapshot[j]) &&
-                    slots[j].Group is null)
-                {
-                    continue;
-                }
                 if (runId is not null && snapshot[j].AssistantRunId != runId ||
                     runId is null && snapshot[j].AssistantRunId is not null)
                 {
@@ -2224,20 +2233,6 @@ item.AssistantRunId is not null && matchedSlot.Model.Source.AssistantRunId is no
             }
         }
 
-        RenderSlot? PreviousRunGroup(int index)
-        {
-            var runId = snapshot[index].AssistantRunId;
-            if (runId is null) return null;
-            for (var j = index - 1; j >= 0; j--)
-            {
-                if (snapshot[j].Role == ChatRole.User || snapshot[j].AssistantRunId != runId)
-                    return null;
-                if (slots[j].Group is not null && slots[j].HasDomElement)
-                    return slots[j];
-            }
-            return null;
-        }
-
         // Pass 4: collapse consecutive same-role runs into a single header (#1222). Mirrors
         // ChatMessageHtmlTransformer.ReconcileRoleHeaders but operates on the plan before chunk
         // HTML is generated; runs off the UI thread and never emits sink operations.
@@ -2269,7 +2264,8 @@ item.AssistantRunId is not null && matchedSlot.Model.Source.AssistantRunId is no
                     continue;
                 }
 
-                var suppress = string.Equals(previousRole, effectiveRole, StringComparison.OrdinalIgnoreCase);
+                var suppress = string.Equals(previousRole, effectiveRole, StringComparison.OrdinalIgnoreCase)
+                    && !string.Equals(effectiveRole, "system", StringComparison.OrdinalIgnoreCase);
                 slot.Model.SetSuppressRoleHeader(suppress, emit: false);
             }
 
diff --git a/Phantom.Workspaces.Agent.Gui/ViewModels/DocumentModels/ChatOutputHtmlRenderer.cs b/Phantom.Workspaces.Agent.Gui/ViewModels/DocumentModels/ChatOutputHtmlRenderer.cs
index 86be6753..cad5e338 100644
--- a/Phantom.Workspaces.Agent.Gui/ViewModels/DocumentModels/ChatOutputHtmlRenderer.cs
+++ b/Phantom.Workspaces.Agent.Gui/ViewModels/DocumentModels/ChatOutputHtmlRenderer.cs
@@ -101,9 +101,8 @@ public static string RenderToolCallGroup(
             .Append(groupId).Append("\" data-sticky-base-level=\"1\">");
         builder.Append(RenderHeader(groupId, "assistant", timestamp, suppressRoleHeader));
         builder.Append("<div class=\"chat-contents\" id=\"").Append(ContentsContainerId(groupId)).Append("\">");
+        builder.Append("<div class=\"chat-tool-group-actions\" role=\"group\" aria-label=\"Tool group actions\"></div>");
         builder.Append("<details class=\"chat-content chat-tool-group\"");
-        // Run groups can contain substantive assistant text between calls; keep it visible by
-        // default while still allowing the user to collapse the group.
         if (assistantRunId is not null) builder.Append(" open");
         builder.Append(" id=\"").Append(ToolGroupDetailsId(groupId)).Append('"');
         if (assistantRunId is not null)
@@ -126,6 +125,20 @@ public static string RenderToolCallGroup(
 
     public static string ToolGroupDetailsId(string groupId) => $"{groupId}-details";
 
+    public static string RenderInlineToolSegment(string contentId, string runId,
+        IReadOnlyList<FunctionCallContent> calls, string bodyContent)
+    {
+        var groupId = contentId + "-segment";
+        return "<div class=\"chat-tool-segment\" id=\"" + contentId + "\">" +
+            "<div class=\"chat-tool-group-actions\" role=\"group\" aria-label=\"Tool group actions\"></div>" +
+            "<details class=\"chat-content chat-tool-group\" open id=\"" + contentId + "-details\" data-assistant-run-id=\"" +
+            HtmlEscape(runId) + "\">" +
+            RenderToolCallGroupSummary(groupId, calls.Select(call => call.Name ?? string.Empty)
+                .Distinct(StringComparer.Ordinal).ToList(), calls.Count) +
+            "<div class=\"chat-tool-group-body\" id=\"" + contentId + "-body\">" +
+            bodyContent + "</div></details></div>";
+    }
+
     /// <summary>
     /// Builds the <c>summary</c> element for a tool-call group. Always lists the unique tool names
     /// in first-seen order, formatted <c>tools (a, b)</c> (a single tool renders <c>tools (a)</c>),
@@ -135,7 +148,11 @@ public static string RenderToolCallGroupSummary(string groupId, IReadOnlyList<st
         IReadOnlyList<string>? pendingToolNames = null)
     {
         var builder = new StringBuilder();
-        builder.Append("<summary class=\"chat-collapsible-summary\" data-sticky-level=\"2\" id=\"").Append(ToolGroupSummaryId(groupId)).Append("\">");
+        builder.Append("<summary class=\"chat-collapsible-summary\" data-sticky-level=\"2\" id=\"")
+            .Append(ToolGroupSummaryId(groupId)).Append("\" data-segment-call-count=\"")
+            .Append(callCount).Append("\" data-segment-tool-names=\"")
+            .Append(HtmlEscape(JsonSerializer.Serialize(toolNames))).Append("\">");
+        builder.Append("<span class=\"tool-group-label\">");
 
         if (toolNames is { Count: > 0 })
         {
@@ -157,7 +174,7 @@ public static string RenderToolCallGroupSummary(string groupId, IReadOnlyList<st
             builder.Append("tools");
         }
 
-        builder.Append(" <span class=\"tool-count-badge\">").Append(callCount).Append(" calls</span>");
+        builder.Append("</span> <span class=\"tool-count-badge\">").Append(callCount).Append(" calls</span>");
         if (pendingToolNames is { Count: > 0 })
         {
             builder.Append(" <span class=\"tool-active-status\" role=\"status\" aria-live=\"polite\">")
@@ -529,6 +546,10 @@ public static string RoleClass(string roleLabel)
         {
             return "chat-help-message";
         }
+        if (string.Equals(roleLabel, "system", StringComparison.OrdinalIgnoreCase))
+        {
+            return "chat-system-message";
+        }
         return "chat-assistant-message";
     }
 
diff --git a/Phantom.Workspaces.Agent.Gui/ViewModels/RunningSubAgentDisplay.cs b/Phantom.Workspaces.Agent.Gui/ViewModels/RunningSubAgentDisplay.cs
index 1ed4274f..e169ca1d 100644
--- a/Phantom.Workspaces.Agent.Gui/ViewModels/RunningSubAgentDisplay.cs
+++ b/Phantom.Workspaces.Agent.Gui/ViewModels/RunningSubAgentDisplay.cs
@@ -314,3 +314,46 @@ public void Dispose()
                 d.Dispose();
     }
 }
+
+internal sealed class RemoteRunningSubAgentDisplay : IRunningSubAgentDisplay, IDisposable
+{
+    private readonly IRunningSubAgent subAgent;
+    private IReadOnlyList<IRunningSubAgentDisplay> children;
+
+    public RemoteRunningSubAgentDisplay(IRunningSubAgent subAgent)
+    {
+        this.subAgent = subAgent;
+        this.children = subAgent.SubAgents.Select(child => (IRunningSubAgentDisplay)new RemoteRunningSubAgentDisplay(child))
+            .ToArray();
+        subAgent.CompletionStateChanged += this.OnSubAgentChanged;
+    }
+
+    public string AgentId => this.subAgent.AgentId;
+    public string DisplayName => this.subAgent.DisplayName;
+    public string Description => this.subAgent.Description;
+    public string Name => this.subAgent.Name;
+    public AgentChatCompletionState CompletionState => this.subAgent.CompletionState;
+    public IReadOnlyList<SubAgentActivityLine> RecentActivity => [];
+    public IReadOnlyList<IRunningSubAgentDisplay> SubAgents => this.children;
+
+    public event EventHandler? ActivityChanged { add { } remove { } }
+    public event EventHandler? CompletionStateChanged;
+
+    private void OnSubAgentChanged(object? sender, EventArgs e)
+    {
+        foreach (var child in this.children)
+            if (child is IDisposable disposable)
+                disposable.Dispose();
+        this.children = this.subAgent.SubAgents
+            .Select(child => (IRunningSubAgentDisplay)new RemoteRunningSubAgentDisplay(child)).ToArray();
+        this.CompletionStateChanged?.Invoke(this, e);
+    }
+
+    public void Dispose()
+    {
+        this.subAgent.CompletionStateChanged -= this.OnSubAgentChanged;
+        foreach (var child in this.children)
+            if (child is IDisposable disposable)
+                disposable.Dispose();
+    }
+}
diff --git a/Phantom.Workspaces.Data.MongoDB.Tests/MongoDBContainerDefinitionGeneratorTests.cs b/Phantom.Workspaces.Data.MongoDB.Tests/MongoDBContainerDefinitionGeneratorTests.cs
index d4ba7c89..0b25c28d 100644
--- a/Phantom.Workspaces.Data.MongoDB.Tests/MongoDBContainerDefinitionGeneratorTests.cs
+++ b/Phantom.Workspaces.Data.MongoDB.Tests/MongoDBContainerDefinitionGeneratorTests.cs
@@ -30,7 +30,7 @@ public void Generate_WhenContainerConnectionDefinition_ReturnsMongoContainerDefi
         Assert.Equal("C:\\mongo-data", containerDefinition.Mounts[0].Source);
         Assert.Equal("/data/db", containerDefinition.Mounts[0].Target);
         Assert.False(containerDefinition.Mounts[0].ReadOnly);
-        Assert.Equal("C:\\mongo-data\\configdb", containerDefinition.Mounts[1].Source);
+        Assert.Equal(Path.Combine(connectionDefinition.DataDirectory, "configdb"), containerDefinition.Mounts[1].Source);
         Assert.Equal("/data/configdb", containerDefinition.Mounts[1].Target);
         Assert.False(containerDefinition.Mounts[1].ReadOnly);
         Assert.Single(containerDefinition.PortMappings);
diff --git a/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbConnectionBrokerDockerDesktopTests.cs b/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbConnectionBrokerDockerDesktopTests.cs
index af0b6a8d..91b6db96 100644
--- a/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbConnectionBrokerDockerDesktopTests.cs
+++ b/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbConnectionBrokerDockerDesktopTests.cs
@@ -86,6 +86,37 @@ public async Task EnsureContainerStarted_WhenDockerAlreadyUsable_DoesNotLaunchDo
         Assert.True(engine.StartCallCount >= 1);
     }
 
+    [Fact]
+    public async Task EnsureContainerStarted_WhenCreatingContainer_CreatesBothBindMountSources()
+    {
+        var dataDirectory = Path.Combine(AppContext.BaseDirectory, "mongo-bind-mount-" + Guid.NewGuid().ToString("N"));
+        var connection = new MongoDbContainerConnectionDefinition
+        {
+            ContainerName = "phantom-mongo-test",
+            DataDirectory = dataDirectory,
+            DatabaseName = "test",
+            CollectionName = "test",
+            HostPort = 27017,
+        };
+        var engine = new FakeDockerEngine { UsableResult = true, FailFirstStart = true };
+        var broker = CreateBroker(engine, new FakeDockerDesktopLauncher(null), new FakeTimeProvider());
+
+        try
+        {
+            _ = await InvokeGetClientAndCatchAsync(broker, connection);
+
+            var definition = Assert.Single(engine.CreatedDefinitions);
+            Assert.All(definition.Mounts, mount => Assert.True(Directory.Exists(mount.Source), mount.Source));
+        }
+        finally
+        {
+            if (Directory.Exists(dataDirectory))
+            {
+                Directory.Delete(dataDirectory, recursive: true);
+            }
+        }
+    }
+
     [Fact]
     public async Task EnsureContainerStarted_WhenDockerNotUsableAndDesktopInstalled_LaunchesDockerDesktop()
     {
diff --git a/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbConnectionBrokerSlowTests.cs b/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbConnectionBrokerSlowTests.cs
index 524f753e..21a98047 100644
--- a/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbConnectionBrokerSlowTests.cs
+++ b/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbConnectionBrokerSlowTests.cs
@@ -92,6 +92,7 @@ public async Task EnsureContainerStarted_MismatchedPersistedReplicaSet_Reconfigu
         try
         {
             Directory.CreateDirectory(dataDirectory);
+            Directory.CreateDirectory(Path.Combine(dataDirectory, "configdb"));
 
             // Phase A: bring the node up with a STALE hostname so Atlas Local commits a persisted
             // replica-set config whose only member is the stale host, then remove the container while
diff --git a/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbTestDatabaseFixture.cs b/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbTestDatabaseFixture.cs
index 376570c2..3482388a 100644
--- a/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbTestDatabaseFixture.cs
+++ b/Phantom.Workspaces.Data.MongoDB.Tests/MongoDbTestDatabaseFixture.cs
@@ -44,8 +44,7 @@ public MongoDbTestDatabaseFixture()
 
     public async Task InitializeAsync()
     {
-        // The broker creates the data directory before starting the container; relying on that here
-        // gives integration coverage that the directory is created before the container starts.
+        // The broker creates both bind-mount sources before starting the container.
         var client = await _connectionBroker.GetClientAsync(ConnectionDefinition);
         Database = client.GetDatabase(DatabaseName);
 
diff --git a/Phantom.Workspaces.Data.MongoDB/MongoDbConnectionBroker.cs b/Phantom.Workspaces.Data.MongoDB/MongoDbConnectionBroker.cs
index 0895aab8..0c14b4fd 100644
--- a/Phantom.Workspaces.Data.MongoDB/MongoDbConnectionBroker.cs
+++ b/Phantom.Workspaces.Data.MongoDB/MongoDbConnectionBroker.cs
@@ -152,9 +152,10 @@ private async ValueTask<IMongoClient> ConnectContainerAsync(
     {
         var resolvedConnectionDefinition = NormalizeContainerDataDirectory(connectionDefinition);
 
-        // The data directory is bind-mounted into the container; it must exist before the container
-        // is created, otherwise the container engine fails to start it.
+        // Both bind sources must exist before docker create (Linux does not create missing
+        // --mount sources). Keep the configdb mount separate from the persisted data directory.
         Directory.CreateDirectory(resolvedConnectionDefinition.DataDirectory);
+        Directory.CreateDirectory(Path.Combine(resolvedConnectionDefinition.DataDirectory, "configdb"));
 
         await EnsureContainerStartedAsync(resolvedConnectionDefinition, cancellationToken).ConfigureAwait(false);
 
diff --git a/Phantom.Workspaces.Gui.Shared.Tests/CopyableLinkTextBlockTests.cs b/Phantom.Workspaces.Gui.Shared.Tests/CopyableLinkTextBlockTests.cs
new file mode 100644
index 00000000..8686570d
--- /dev/null
+++ b/Phantom.Workspaces.Gui.Shared.Tests/CopyableLinkTextBlockTests.cs
@@ -0,0 +1,167 @@
+using System;
+using System.Windows.Input;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Headless.XUnit;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Media;
+using Avalonia.Threading;
+using Phantom.Workspaces.Gui.Shared.Controls;
+
+using Phantom.Workspaces.Testing.Gui;
+
+namespace Phantom.Workspaces.Gui.Shared.Tests;
+
+public sealed class CopyableLinkTextBlockTests
+{
+    [AvaloniaFact]
+    public void CopyableLinkTextBlock_NullOrDisabledCommand_DoesNotActivate()
+    {
+        var command = new RecordingCommand { IsAllowed = false };
+        var link = new CopyableLinkTextBlock { Text = "Open link" };
+        var window = Show(link);
+        try
+        {
+            Click(window, link);
+            link.Focus();
+            window.KeyPress(Key.Space, RawInputModifiers.None, PhysicalKey.Space, " ");
+            Assert.Null(command.LastParameter);
+
+            link.Command = command;
+            Click(window, link);
+            window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, "\r");
+            window.KeyPress(Key.Space, RawInputModifiers.None, PhysicalKey.Space, " ");
+            Assert.Equal(0, command.Calls);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void CopyableLinkTextBlock_ClickAndKeyboard_ExecuteOnceWithParameter()
+    {
+        var parameter = new object();
+        var command = new RecordingCommand();
+        var link = new CopyableLinkTextBlock { Text = "Open link", Command = command, CommandParameter = parameter };
+        var window = Show(link);
+        try
+        {
+            Click(window, link);
+            Assert.Equal(1, command.Calls);
+            Assert.Same(parameter, command.LastParameter);
+
+            link.Focus();
+            window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, "\r");
+            window.KeyPress(Key.Space, RawInputModifiers.None, PhysicalKey.Space, " ");
+            Assert.Equal(3, command.Calls);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void CopyableLinkTextBlock_RightClickAndReleaseOutside_DoNotActivate()
+    {
+        var command = new RecordingCommand();
+        var link = new CopyableLinkTextBlock { Text = "Open link", Command = command };
+        var window = Show(link);
+        try
+        {
+            var point = Inside(link, window);
+            window.MouseDown(point, MouseButton.Right);
+            window.MouseUp(point, MouseButton.Right);
+            Assert.Equal(0, command.Calls);
+
+            window.MouseDown(point, MouseButton.Left);
+            var outside = new Point(point.X + link.Bounds.Width + 20, point.Y);
+            window.MouseMove(outside, RawInputModifiers.LeftMouseButton);
+            window.MouseUp(outside, MouseButton.Left);
+            Assert.Equal(0, command.Calls);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void CopyableLinkTextBlock_SmallMoveActivates_LargeDragSelectsWithoutActivating()
+    {
+        var command = new RecordingCommand();
+        var link = new CopyableLinkTextBlock { Text = "Selectable reference link", Command = command };
+        var window = Show(link);
+        try
+        {
+            var point = Inside(link, window);
+            window.MouseDown(point, MouseButton.Left);
+            var smallMove = new Point(point.X + 2, point.Y);
+            window.MouseMove(smallMove, RawInputModifiers.LeftMouseButton);
+            window.MouseUp(smallMove, MouseButton.Left);
+            Assert.Equal(1, command.Calls);
+
+            window.MouseDown(point, MouseButton.Left);
+            var end = new Point(point.X + link.Bounds.Width - 2, point.Y);
+            window.MouseMove(end, RawInputModifiers.LeftMouseButton);
+            window.MouseUp(end, MouseButton.Left);
+            Assert.NotEmpty(link.SelectedText);
+            Assert.Equal(1, command.Calls);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    private static Window Show(CopyableLinkTextBlock link)
+    {
+        link.HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Left;
+        link.VerticalAlignment = Avalonia.Layout.VerticalAlignment.Top;
+        link.Background = Brushes.Transparent;
+        var window = new Window
+        {
+            Content = new Border { Padding = new Thickness(20), Child = link },
+            Width = 380,
+            Height = 120,
+        };
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+        return window;
+    }
+
+    private static Point Inside(CopyableLinkTextBlock link, Window window)
+    {
+        var origin = link.TranslatePoint(new Point(0, 0), window)!.Value;
+        return new Point(origin.X + Math.Min(10, link.Bounds.Width / 2),
+            origin.Y + Math.Min(8, link.Bounds.Height / 2));
+    }
+
+    private static void Click(Window window, CopyableLinkTextBlock link)
+    {
+        var point = Inside(link, window);
+        window.MouseMove(point);
+        window.MouseDown(point, MouseButton.Left);
+        window.MouseUp(point, MouseButton.Left);
+    }
+
+    private sealed class RecordingCommand : ICommand
+    {
+        public bool IsAllowed { get; set; } = true;
+        public int Calls { get; private set; }
+        public object? LastParameter { get; private set; }
+        public event EventHandler? CanExecuteChanged { add { } remove { } }
+
+        public bool CanExecute(object? parameter) => this.IsAllowed;
+
+        public void Execute(object? parameter)
+        {
+            this.Calls++;
+            this.LastParameter = parameter;
+        }
+    }
+}
diff --git a/Phantom.Workspaces.Gui.Shared/Controls/CopyableLinkTextBlock.cs b/Phantom.Workspaces.Gui.Shared/Controls/CopyableLinkTextBlock.cs
new file mode 100644
index 00000000..04f8fb96
--- /dev/null
+++ b/Phantom.Workspaces.Gui.Shared/Controls/CopyableLinkTextBlock.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Windows.Input;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+
+namespace Phantom.Workspaces.Gui.Shared.Controls;
+
+/// <summary>A selectable link: a click activates its command, while a drag selects text.</summary>
+public class CopyableLinkTextBlock : SafeSelectableTextBlock
+{
+    public static readonly StyledProperty<ICommand?> CommandProperty =
+        AvaloniaProperty.Register<CopyableLinkTextBlock, ICommand?>(nameof(Command));
+
+    public static readonly StyledProperty<object?> CommandParameterProperty =
+        AvaloniaProperty.Register<CopyableLinkTextBlock, object?>(nameof(CommandParameter));
+
+    private Point? pressPosition;
+    private bool dragged;
+
+    public ICommand? Command
+    {
+        get => this.GetValue(CommandProperty);
+        set => this.SetValue(CommandProperty, value);
+    }
+
+    public object? CommandParameter
+    {
+        get => this.GetValue(CommandParameterProperty);
+        set => this.SetValue(CommandParameterProperty, value);
+    }
+
+    protected override void OnPointerPressed(PointerPressedEventArgs e)
+    {
+        this.pressPosition = e.GetCurrentPoint(this).Properties.IsLeftButtonPressed
+            ? e.GetPosition(this)
+            : null;
+        this.dragged = false;
+        base.OnPointerPressed(e);
+    }
+
+    protected override void OnPointerMoved(PointerEventArgs e)
+    {
+        if (this.pressPosition is { } start)
+        {
+            var position = e.GetPosition(this);
+            if (Math.Abs(position.X - start.X) > 4 || Math.Abs(position.Y - start.Y) > 4)
+                this.dragged = true;
+        }
+        base.OnPointerMoved(e);
+    }
+
+    protected override void OnPointerReleased(PointerReleasedEventArgs e)
+    {
+        var activate = this.pressPosition is not null
+            && e.InitialPressMouseButton == MouseButton.Left
+            && !this.dragged
+            && string.IsNullOrEmpty(this.SelectedText)
+            && new Rect(this.Bounds.Size).Contains(e.GetPosition(this));
+        this.pressPosition = null;
+        base.OnPointerReleased(e);
+
+        if (activate && this.Command?.CanExecute(this.CommandParameter) == true)
+        {
+            this.Command.Execute(this.CommandParameter);
+            e.Handled = true;
+        }
+    }
+
+    protected override void OnKeyDown(KeyEventArgs e)
+    {
+        base.OnKeyDown(e);
+        if (!e.Handled && (e.Key is Key.Enter or Key.Space) && this.Command?.CanExecute(this.CommandParameter) == true)
+        {
+            this.Command.Execute(this.CommandParameter);
+            e.Handled = true;
+        }
+    }
+}
diff --git a/Phantom.Workspaces.Gui.Shared/Styles/SharedStyles.axaml b/Phantom.Workspaces.Gui.Shared/Styles/SharedStyles.axaml
index 157800ef..4ccfa303 100644
--- a/Phantom.Workspaces.Gui.Shared/Styles/SharedStyles.axaml
+++ b/Phantom.Workspaces.Gui.Shared/Styles/SharedStyles.axaml
@@ -11,6 +11,13 @@
     <StyleInclude Source="avares://Markdown.Avalonia.SyntaxHigh/StyleCollections/AppendixOfFluentTheme.axaml" />
 
     <Styles.Resources>
+        <DataTemplate x:Key="CopyableCardButtonContentTemplate">
+            <controls:CopyableLinkTextBlock Text="{Binding}"
+                                            Background="Transparent"
+                                            Command="{Binding $parent[Button].Command}"
+                                            CommandParameter="{Binding $parent[Button].CommandParameter}"
+                                            TextWrapping="Wrap" />
+        </DataTemplate>
         <!-- WorkspaceMarkdownView code styling resources (issue #1173). Values mirror the WebView
              chat-output-shell.html tokens (chat-font-family, chat-foreground, chat-tool-body-background).
              Brushes are aliased to Fluent-theme color keys so they swap with light/dark theming just
@@ -327,6 +334,18 @@
             </ItemsPanelTemplate>
         </Setter>
     </Style>
+    <!-- Only explicitly opted-in entity Views use ordinary scrolling below 100 total nodes.
+         Other consumers retain the virtualizing default; both panels share the width limits. -->
+    <Style Selector="TreeView.entity-card-tree.entity-card-tree-small, TreeView.entity-card-tree-view.entity-card-tree-small">
+        <Setter Property="ItemsPanel">
+            <ItemsPanelTemplate>
+                <StackPanel Orientation="Vertical"
+                            HorizontalAlignment="Stretch"
+                            MinWidth="160"
+                            MaxWidth="{Binding $parent[ScrollViewer].Viewport.Width}" />
+            </ItemsPanelTemplate>
+        </Setter>
+    </Style>
     <!-- Issue #1048: scope hover/selection highlights to the item's own header StackPanel so
          ancestor/descendant chains are not highlighted. The StackPanel.entity-card-tree-item sits
          in grid row 0 and does NOT contain the row-1 ItemsPresenter, so its :pointerover is true
@@ -454,7 +473,7 @@
         <Setter Property="Margin" Value="0,0,4,4" />
         <Setter Property="VerticalAlignment" Value="Center" />
     </Style>
-    <Style Selector="Border.status-badge > TextBlock.status-badge-text">
+    <Style Selector="Border.status-badge > :is(TextBlock).status-badge-text">
         <Setter Property="Foreground" Value="{DynamicResource Theme.Status.Foreground}" />
         <Setter Property="FontSize" Value="12" />
         <Setter Property="FontWeight" Value="SemiBold" />
@@ -1391,15 +1410,18 @@
         <Setter Property="ToolTip.Tip" Value="{Binding Content.TabViewModel.TabTooltip}" />
     </Style>
 
-    <Style Selector="Button.workspace-url-link">
+    <Style Selector="controls|CopyableLinkTextBlock.workspace-url-link, controls|CopyableLinkTextBlock.workspace-entity-reference-link">
         <Setter Property="Background" Value="Transparent" />
-        <Setter Property="BorderThickness" Value="0" />
-        <Setter Property="Padding" Value="0" />
+        <Setter Property="Foreground" Value="{DynamicResource Theme.Class.muted.Foreground}" />
+        <Setter Property="Opacity" Value="0.65" />
+        <Setter Property="Cursor" Value="Arrow" />
+        <Setter Property="TextWrapping" Value="Wrap" />
+    </Style>
+    <Style Selector="controls|CopyableLinkTextBlock.workspace-url-link.available, controls|CopyableLinkTextBlock.workspace-entity-reference-link.available">
         <Setter Property="Foreground" Value="{DynamicResource SystemAccentColor}" />
+        <Setter Property="Opacity" Value="1" />
         <Setter Property="Cursor" Value="Hand" />
-    </Style>
-    <Style Selector="Button.workspace-url-link:pointerover /template/ ContentPresenter">
-        <Setter Property="Background" Value="Transparent" />
+        <Setter Property="TextDecorations" Value="Underline" />
     </Style>
 
     <!-- Issue #1120: shared pane-collapser toggle. Rounded box with white ">>"/"<<" chevron
@@ -1446,4 +1468,3 @@
     </Style>
 
 </Styles>
-
diff --git a/Phantom.Workspaces.Install.Tests/CopilotWrapperPackagingTests.cs b/Phantom.Workspaces.Install.Tests/CopilotWrapperPackagingTests.cs
index 972c7bb1..0bbb401c 100644
--- a/Phantom.Workspaces.Install.Tests/CopilotWrapperPackagingTests.cs
+++ b/Phantom.Workspaces.Install.Tests/CopilotWrapperPackagingTests.cs
@@ -6,7 +6,7 @@ public sealed class CopilotWrapperPackagingTests
     [Fact]
     public void RuntimePayload_CommandUsesFocusedIsolatedNonReusableBuild()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         var arguments = MxcRepositoryTestSupport.CreateCopilotRuntimePayloadArguments(
             "payload",
             "isolated-artifacts",
@@ -41,7 +41,7 @@ public void RuntimePayload_CommandUsesFocusedIsolatedNonReusableBuild()
     [Fact]
     public async Task RuntimePayload_WinX64_IncludesSdkRuntimePairAndSidecars()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory(
             cleanupProgress: message => Console.WriteLine($"Copilot payload {message}"));
         await using var buildArtifacts = new MxcRepositoryTestSupport.TestDirectory(
@@ -106,7 +106,7 @@ await HashFileAsync(prerequisite.WrapperExecutable),
     [Fact]
     public async Task RuntimePayload_MissingSdkRuntimeWrapper_FailsValidation()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = CreateValidatorPayload(prerequisite);
         File.Delete(Path.Combine(payload.Path, "runtimes", "win-x64", "native", "copilot-runtime.exe"));
 
@@ -122,7 +122,7 @@ public async Task RuntimePayload_MissingSdkRuntimeWrapper_FailsValidation()
     [Fact]
     public async Task RuntimePayload_MissingSdkRuntimeNode_FailsValidation()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = CreateValidatorPayload(prerequisite);
         File.Delete(Path.Combine(payload.Path, "runtimes", "win-x64", "native", "runtime.node"));
 
@@ -138,7 +138,7 @@ public async Task RuntimePayload_MissingSdkRuntimeNode_FailsValidation()
     [Fact]
     public async Task RuntimePayload_UnequalSdkRuntimePair_FailsPublish()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var source = new MxcRepositoryTestSupport.TestDirectory();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         var nativeSource = Path.Combine(source.Path, "runtimes", "win-x64", "native");
@@ -176,7 +176,7 @@ public async Task RuntimePayload_UnequalSdkRuntimePair_FailsPublish()
     [Fact]
     public async Task RuntimeZip_SdkRuntimePairPreserved_PassesValidation()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = CreateValidatorPayload(prerequisite);
         await using var archive = new MxcRepositoryTestSupport.TestDirectory();
         var zip = Path.Combine(archive.Path, "release.zip");
@@ -198,7 +198,7 @@ public async Task RuntimeZip_SdkRuntimePairPreserved_PassesValidation()
     [Fact]
     public async Task RuntimeZip_ExtractedInstalledLayout_StartsRealSdkWithoutExplicitCredentials()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = CreateValidatorPayload(prerequisite);
         CopyStagedSdkAssets(prerequisite, payload.Path);
         await using var archive = new MxcRepositoryTestSupport.TestDirectory();
@@ -220,7 +220,7 @@ public async Task RuntimeZip_ExtractedInstalledLayout_StartsRealSdkWithoutExplic
     [Fact]
     public async Task InstalledPayload_SdkClientStartup_SucceedsFromCurrentNativeDirectory()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = CreateValidatorPayload(prerequisite);
         CopyStagedSdkAssets(prerequisite, payload.Path);
 
@@ -318,7 +318,7 @@ await File.WriteAllTextAsync(script,
     public async Task RuntimePayload_GitHubFinalCommand_AcceptedNativeExitIsClean(
         bool useNativeErrorPreference)
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = CreateValidatorPayload(prerequisite);
 
         var result = await InvokeValidatorAsGitHubStepAsync(
@@ -337,7 +337,7 @@ public async Task RuntimePayload_GitHubFinalCommand_AcceptedNativeExitIsClean(
     [Fact]
     public async Task RuntimePayload_GitHubFinalCommand_UnexpectedNativeExitFails()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = CreateValidatorPayload(prerequisite);
         File.Copy(
             Path.Combine(
@@ -360,7 +360,7 @@ public async Task RuntimePayload_GitHubFinalCommand_UnexpectedNativeExitFails()
     [Fact]
     public async Task RuntimePayload_GitHubFinalCommand_NativeLaunchFailureFails()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = CreateValidatorPayload(prerequisite);
         await File.WriteAllTextAsync(
             Path.Combine(payload.Path, "runtimes", "win-x64", "native", "copilot.exe"),
@@ -380,7 +380,7 @@ await File.WriteAllTextAsync(
     [Fact]
     public async Task RuntimePayload_GitHubFinalCommand_NonExecutablePeFailsBeforeLaunch()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = CreateValidatorPayload(prerequisite);
         var executable = Path.Combine(
             payload.Path,
@@ -408,7 +408,7 @@ public async Task RuntimePayload_GitHubFinalCommand_NonExecutablePeFailsBeforeLa
     [Fact]
     public async Task RuntimePayload_GitHubFinalCommand_NativeLaunchFailure_CompletesRepeatedlyWithoutHang()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         var attempts = Enumerable.Range(0, 4).Select(async _ =>
         {
             await using var payload = CreateValidatorPayload(prerequisite);
@@ -446,7 +446,7 @@ public void InvokeValidatorAsGitHubStep_UsesValidatorTimeout_NotLongRunningTimeo
     [Fact]
     public async Task RuntimePayload_MissingPreparedFingerprint_FailsClosed()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var buildArtifacts = new MxcRepositoryTestSupport.TestDirectory();
         await using var normalOutput = new MxcRepositoryTestSupport.TestDirectory();
@@ -482,7 +482,7 @@ public async Task RuntimePayload_MissingPreparedFingerprint_FailsClosed()
     [Fact]
     public async Task RuntimePayload_WrongPreparedFingerprint_FailsClosed()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var buildArtifacts = new MxcRepositoryTestSupport.TestDirectory();
         await using var normalOutput = new MxcRepositoryTestSupport.TestDirectory();
@@ -521,7 +521,7 @@ public async Task RuntimePayload_WrongPreparedFingerprint_FailsClosed()
     [Fact]
     public async Task RuntimePayload_TamperedPreparedPath_FailsClosed()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var buildArtifacts = new MxcRepositoryTestSupport.TestDirectory();
         await using var normalOutput = new MxcRepositoryTestSupport.TestDirectory();
@@ -550,7 +550,7 @@ public async Task RuntimePayload_TamperedPreparedPath_FailsClosed()
     [Fact]
     public async Task RuntimePayload_TamperedPreparedHash_FailsClosed()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var buildArtifacts = new MxcRepositoryTestSupport.TestDirectory();
         await using var normalOutput = new MxcRepositoryTestSupport.TestDirectory();
@@ -575,7 +575,7 @@ public async Task RuntimePayload_TamperedPreparedHash_FailsClosed()
     [Fact]
     public async Task RuntimePayload_TamperedSdkRuntimeWrapperHash_FailsClosed()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var artifacts = new MxcRepositoryTestSupport.TestDirectory();
         await using var normalOutput = new MxcRepositoryTestSupport.TestDirectory();
@@ -597,7 +597,7 @@ public async Task RuntimePayload_TamperedSdkRuntimeWrapperHash_FailsClosed()
     [Fact]
     public async Task RuntimePayload_PreparedPropertiesWithoutTestOptIn_FailClosed()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var buildArtifacts = new MxcRepositoryTestSupport.TestDirectory();
         await using var normalOutput = new MxcRepositoryTestSupport.TestDirectory();
@@ -622,7 +622,7 @@ public async Task RuntimePayload_PreparedPropertiesWithoutTestOptIn_FailClosed()
     [Fact]
     public async Task RuntimePayload_ProductionBuildRefusesPreparedOverride()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var buildArtifacts = new MxcRepositoryTestSupport.TestDirectory();
         await using var normalOutput = new MxcRepositoryTestSupport.TestDirectory();
@@ -647,7 +647,7 @@ public async Task RuntimePayload_ProductionBuildRefusesPreparedOverride()
     [Fact]
     public async Task RuntimePayload_ConcurrentMatchingAndMismatchedRids_AreIsolated()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var matchingPayload = new MxcRepositoryTestSupport.TestDirectory();
         await using var matchingArtifacts = new MxcRepositoryTestSupport.TestDirectory();
         await using var matchingNormalOutput = new MxcRepositoryTestSupport.TestDirectory();
diff --git a/Phantom.Workspaces.Install.Tests/CopilotWrapperPrerequisiteCleanTests.cs b/Phantom.Workspaces.Install.Tests/CopilotWrapperPrerequisiteCleanTests.cs
new file mode 100644
index 00000000..f628a844
--- /dev/null
+++ b/Phantom.Workspaces.Install.Tests/CopilotWrapperPrerequisiteCleanTests.cs
@@ -0,0 +1,437 @@
+namespace Phantom.Workspaces.Install.Tests;
+
+public sealed partial class CopilotWrapperNestedPublishTests
+{
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_CleanAfterMultipleFingerprints_RemovesAllCacheEntriesAndPointers()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var result = await fixture.CleanProjectAsync();
+        Assert.Equal(0, result.ExitCode);
+        fixture.AssertRemoved();
+        Assert.True(File.Exists(fixture.OutsideFile));
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_RepeatedClean_IsIdempotent()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        Assert.Equal(0, (await fixture.CleanProjectAsync()).ExitCode);
+        Assert.Equal(0, (await fixture.CleanProjectAsync()).ExitCode);
+        fixture.AssertRemoved();
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_CustomBaseIntermediateWithSpaces_CleansOnlyCanonicalRoot()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        File.WriteAllText(fixture.PointerFile, fixture.OutsideFile);
+        var result = await fixture.CleanProjectAsync();
+        Assert.True(result.ExitCode == 0, result.StandardOutput + result.StandardError);
+        fixture.AssertRemoved();
+        Assert.True(File.Exists(fixture.OutsideFile));
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_CleanWhileInUse_FailsWithoutPartialDeletion()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        using (File.Open(fixture.LockFile, FileMode.Open, FileAccess.Read, FileShare.Read))
+        {
+            var result = await fixture.CleanProjectAsync();
+            Assert.NotEqual(0, result.ExitCode);
+            Assert.Contains("in use", result.StandardOutput + result.StandardError,
+                StringComparison.OrdinalIgnoreCase);
+            Assert.True(File.Exists(fixture.PointerFile));
+            Assert.Equal(3, Directory.GetDirectories(fixture.CacheRoot).Length);
+        }
+        Assert.Equal(0, (await fixture.CleanProjectAsync()).ExitCode);
+        fixture.AssertRemoved();
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_CleanWhileTestHostActive_PreservesPointerAndCache()
+    {
+        var pointer = Path.Combine(
+            AppContext.BaseDirectory, "copilot-wrapper-prerequisite.path");
+        var cache = File.ReadAllText(pointer).Trim();
+        var result = await MxcRepositoryTestSupport.InvokeAsync(
+            "dotnet", "msbuild",
+            Path.Combine("Phantom.Workspaces.Install.Tests",
+                "Phantom.Workspaces.Install.Tests.csproj"),
+            "-target:CleanCopilotWrapperTestPrerequisite", "-nologo", "/nodeReuse:false");
+        Assert.NotEqual(0, result.ExitCode);
+        Assert.Contains("in use", result.StandardOutput + result.StandardError,
+            StringComparison.OrdinalIgnoreCase);
+        Assert.Equal(cache, File.ReadAllText(pointer).Trim());
+        Assert.True(File.Exists(Path.Combine(cache, "prerequisite.json")));
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_ReparsePoint_IsRejectedBeforeAnyDeletion()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var junction = Path.Combine(fixture.CacheRoot, "cccccccccccccccc");
+        var result = await MxcRepositoryTestSupport.InvokeAsync(
+            "cmd", "/c", "mklink", "/J", junction, fixture.BaseDirectory);
+        Assert.True(result.ExitCode == 0, result.StandardOutput + result.StandardError);
+        var clean = await fixture.CleanProjectAsync();
+        Assert.NotEqual(0, clean.ExitCode);
+        Assert.True(File.Exists(fixture.PointerFile));
+        Assert.True(File.Exists(fixture.OutsideFile));
+        fixture.AssertEntriesPresent();
+        Directory.Delete(junction);
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_ReparseRoot_IsRejectedBeforeAnyDeletion()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var target = fixture.CacheRoot + "-outside";
+        Directory.Move(fixture.CacheRoot, target);
+        var junction = await MxcRepositoryTestSupport.InvokeAsync(
+            "cmd", "/c", "mklink", "/J", fixture.CacheRoot, target);
+        Assert.Equal(0, junction.ExitCode);
+        try
+        {
+            var result = await fixture.CleanProjectAsync();
+            Assert.NotEqual(0, result.ExitCode);
+            Assert.True(File.Exists(fixture.PointerFile));
+            Assert.True(File.Exists(Path.Combine(target, "aaaaaaaaaaaaaaaa",
+                "prepared", "phantom-copilot-wrapper.exe")));
+            fixture.AssertEntriesPresent();
+        }
+        finally
+        {
+            Directory.Delete(fixture.CacheRoot);
+            Directory.Move(target, fixture.CacheRoot);
+        }
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_ReparseAncestor_IsRejectedBeforeAnyDeletion()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var target = fixture.BaseDirectory + "-outside";
+        Directory.Move(fixture.BaseDirectory, target);
+        var junction = await MxcRepositoryTestSupport.InvokeAsync(
+            "cmd", "/c", "mklink", "/J", fixture.BaseDirectory, target);
+        Assert.Equal(0, junction.ExitCode);
+        try
+        {
+            var result = await fixture.CleanProjectAsync();
+            Assert.NotEqual(0, result.ExitCode);
+            Assert.True(File.Exists(fixture.PointerFile));
+            Assert.True(File.Exists(fixture.OutsideFile));
+            fixture.AssertEntriesPresent();
+        }
+        finally
+        {
+            Directory.Delete(fixture.BaseDirectory);
+            Directory.Move(target, fixture.BaseDirectory);
+        }
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task CopilotWrapperPrerequisite_DirectoryPointer_IsRejectedBeforeAnyDeletion(
+        bool copiedPointer)
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var pointer = copiedPointer ? fixture.CopiedPointerFile : fixture.PointerFile;
+        File.Delete(pointer);
+        Directory.CreateDirectory(pointer);
+        File.WriteAllText(Path.Combine(pointer, "outside.txt"), "untouched");
+        var result = await fixture.CleanProjectAsync();
+        Assert.NotEqual(0, result.ExitCode);
+        Assert.True(Directory.Exists(fixture.CacheRoot));
+        Assert.True(File.Exists(Path.Combine(pointer, "outside.txt")));
+        Assert.True(File.Exists(fixture.OutsideFile));
+        fixture.AssertEntriesPresent();
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task CopilotWrapperPrerequisite_ReparsePointer_IsRejectedBeforeAnyDeletion(
+        bool copiedPointer)
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var pointer = copiedPointer ? fixture.CopiedPointerFile : fixture.PointerFile;
+        var external = Path.Combine(fixture.BaseDirectory, "outside-pointer");
+        Directory.CreateDirectory(external);
+        File.WriteAllText(Path.Combine(external, "untouched.txt"), "untouched");
+        File.Delete(pointer);
+        var junction = await MxcRepositoryTestSupport.InvokeAsync(
+            "cmd", "/c", "mklink", "/J", pointer, external);
+        Assert.Equal(0, junction.ExitCode);
+        try
+        {
+            var result = await fixture.CleanProjectAsync();
+            Assert.NotEqual(0, result.ExitCode);
+            Assert.True(Directory.Exists(fixture.CacheRoot));
+            Assert.True(File.Exists(Path.Combine(external, "untouched.txt")));
+            Assert.True(File.Exists(fixture.OutsideFile));
+            fixture.AssertEntriesPresent();
+        }
+        finally
+        {
+            Directory.Delete(pointer);
+        }
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_UnexpectedRootEntry_IsRejectedBeforeAnyDeletion()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var unrelated = Path.Combine(fixture.CacheRoot, "not-a-cache-entry.txt");
+        File.WriteAllText(unrelated, "untouched");
+        var result = await fixture.CleanProjectAsync();
+        Assert.NotEqual(0, result.ExitCode);
+        Assert.True(File.Exists(unrelated));
+        Assert.True(File.Exists(fixture.PointerFile));
+        Assert.True(File.Exists(fixture.OutsideFile));
+        fixture.AssertEntriesPresent();
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_UnownedCopiedOutput_IsRejectedBeforeAnyDeletion()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        using var external = new MxcRepositoryTestSupport.TestDirectory();
+        var result = await fixture.CleanWithOutDirAsync(external.Path);
+        Assert.NotEqual(0, result.ExitCode);
+        Assert.True(Directory.Exists(fixture.CacheRoot));
+        Assert.True(File.Exists(fixture.PointerFile));
+        Assert.True(File.Exists(fixture.OutsideFile));
+        fixture.AssertEntriesPresent();
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_ExternalIntermediateRoot_IsRejected()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var externalBase = Path.Combine(
+            MxcRepositoryTestSupport.Root.FullName, "TestResults",
+            $"external clean {Guid.NewGuid():N}");
+        Directory.CreateDirectory(externalBase);
+        try
+        {
+            var result = await MxcRepositoryTestSupport.InvokeAsync(
+                "dotnet", "clean",
+                Path.Combine("Phantom.Workspaces.Install.Tests",
+                    "Phantom.Workspaces.Install.Tests.csproj"),
+                "--nologo", "/nodeReuse:false",
+                $"-p:BaseIntermediateOutputPath={externalBase}{Path.DirectorySeparatorChar}");
+            Assert.NotEqual(0, result.ExitCode);
+            Assert.True(File.Exists(fixture.PointerFile));
+            Assert.True(File.Exists(fixture.OutsideFile));
+            fixture.AssertEntriesPresent();
+        }
+        finally
+        {
+            Directory.Delete(externalBase, true);
+        }
+    }
+
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_LockedCacheFile_FailsBeforePartialDeletion()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var lockedFile = Path.Combine(fixture.CacheRoot, "bbbbbbbbbbbbbbbb",
+            "prepared", "phantom-copilot-wrapper.exe");
+        using (File.Open(lockedFile, FileMode.Open, FileAccess.Read, FileShare.None))
+        {
+            var result = await fixture.CleanProjectAsync();
+            Assert.NotEqual(0, result.ExitCode);
+            Assert.True(Directory.Exists(fixture.CacheRoot));
+            Assert.Equal(3, Directory.GetDirectories(fixture.CacheRoot).Length);
+            Assert.True(File.Exists(fixture.PointerFile));
+        }
+        Assert.Equal(0, (await fixture.CleanProjectAsync()).ExitCode);
+    }
+
+    [Fact]
+    [Trait("Category", "SlowLayout")]
+    public async Task CopilotWrapperPrerequisite_CleanThenTest_RecreatesValidatedCache()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        Assert.Equal(0, (await fixture.CleanProjectAsync()).ExitCode);
+        var result = await fixture.PrepareAsync();
+        Assert.True(result.ExitCode == 0, result.StandardOutput + result.StandardError);
+        var cacheDirectory = File.ReadAllText(fixture.PointerFile).Trim();
+        Assert.Equal(fixture.CacheRoot, Path.GetDirectoryName(cacheDirectory),
+            ignoreCase: true);
+        using var manifest = System.Text.Json.JsonDocument.Parse(
+            File.ReadAllText(Path.Combine(cacheDirectory, "prerequisite.json")));
+        var fingerprint = manifest.RootElement.GetProperty("CacheKey").GetString();
+        Assert.Matches("^[0-9a-f]{64}$", fingerprint);
+        Assert.Equal(fingerprint, File.ReadAllText(
+            Path.Combine(cacheDirectory, "prerequisite.fingerprint")).Trim());
+        foreach (var artifact in manifest.RootElement.GetProperty("Artifacts").EnumerateArray())
+        {
+            var path = Path.Combine(cacheDirectory,
+                artifact.GetProperty("RelativePath").GetString()!.Replace('/', '\\'));
+            Assert.Equal(artifact.GetProperty("Sha256").GetString(),
+                MxcRepositoryTestSupport.ComputeSha256(path));
+        }
+        Assert.Equal(cacheDirectory, File.ReadAllText(fixture.CopiedPointerFile).Trim());
+        using (var prerequisite =
+               MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite(
+                   fixture.CopiedPointerFile))
+        {
+            await using var payload = new MxcRepositoryTestSupport.TestDirectory();
+            await using var artifacts = new MxcRepositoryTestSupport.TestDirectory();
+            var publish = await MxcRepositoryTestSupport.InvokeAsync(
+                "dotnet", MxcRepositoryTestSupport.CreateCopilotWrapperPublishArguments(
+                    payload.Path, artifacts.Path, prerequisite));
+            Assert.True(publish.ExitCode == 0,
+                "Custom prerequisite publish failed:" + Environment.NewLine +
+                publish.StandardOutput + Environment.NewLine + publish.StandardError);
+        }
+        Assert.Equal(0, (await fixture.CleanProjectAsync()).ExitCode);
+        fixture.AssertRemoved();
+    }
+}
+
+public sealed partial class BuildIntegrationTests
+{
+    [Fact]
+    public async Task CopilotWrapperPrerequisite_SolutionClean_RemovesInstallTestCache()
+    {
+        using var fixture = new CacheCleanFixture();
+        fixture.AddEntries();
+        var result = await fixture.CleanSolutionAsync();
+        Assert.True(result.ExitCode == 0, result.StandardOutput + result.StandardError);
+        fixture.AssertRemoved();
+    }
+}
+
+internal sealed class CacheCleanFixture : IDisposable
+{
+    private readonly string projectDirectory = Path.Combine(
+        MxcRepositoryTestSupport.Root.FullName, "Phantom.Workspaces.Install.Tests");
+    private readonly string name = "c s" + Guid.NewGuid().ToString("N")[..6];
+    private readonly string outputDirectory;
+
+    internal CacheCleanFixture()
+    {
+        BaseDirectory = Path.Combine(projectDirectory, "obj", name);
+        outputDirectory = Path.Combine(projectDirectory, "bin", name);
+        CacheRoot = Path.Combine(BaseDirectory, "mxcw");
+        PointerFile = Path.Combine(BaseDirectory, "Debug", "net10.0",
+            "copilot-wrapper-prerequisite.path");
+        CopiedPointerFile = Path.Combine(outputDirectory, "Debug", "net10.0",
+            "copilot-wrapper-prerequisite.path");
+        OutsideFile = Path.Combine(BaseDirectory, "untouched.txt");
+        LockFile = Path.Combine(BaseDirectory, "mxcw.lock");
+    }
+
+    internal string BaseDirectory { get; }
+    internal string CacheRoot { get; }
+    internal string PointerFile { get; }
+    internal string CopiedPointerFile { get; }
+    internal string OutsideFile { get; }
+    internal string LockFile { get; }
+
+    internal void AddEntries()
+    {
+        foreach (var name in new[]
+        {
+            "aaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbb", "dddddddddddddddd.staging-123"
+        })
+        {
+            var entry = Path.Combine(CacheRoot, name, "prepared");
+            Directory.CreateDirectory(entry);
+            File.WriteAllText(Path.Combine(entry, "phantom-copilot-wrapper.exe"), "fixture");
+        }
+        Directory.CreateDirectory(Path.GetDirectoryName(PointerFile)!);
+        Directory.CreateDirectory(Path.GetDirectoryName(CopiedPointerFile)!);
+        File.WriteAllText(PointerFile, Path.Combine(CacheRoot, "aaaaaaaaaaaaaaaa"));
+        File.WriteAllText(CopiedPointerFile, Path.Combine(CacheRoot, "aaaaaaaaaaaaaaaa"));
+        File.WriteAllText(OutsideFile, "untouched");
+        File.WriteAllText(LockFile, string.Empty);
+    }
+
+    private string[] Arguments(string entryPoint) =>
+    [
+        "clean", entryPoint, "--nologo", "/nodeReuse:false",
+        $"-p:BaseIntermediateOutputPath=obj\\{name}\\",
+        $"-p:BaseOutputPath=bin\\{name}\\"
+    ];
+
+    internal Task<MxcRepositoryTestSupport.ProcessResult> CleanProjectAsync() =>
+        MxcRepositoryTestSupport.InvokeAsync(
+            "dotnet", Arguments(Path.Combine("Phantom.Workspaces.Install.Tests",
+                "Phantom.Workspaces.Install.Tests.csproj")));
+
+    internal Task<MxcRepositoryTestSupport.ProcessResult> CleanSolutionAsync() =>
+        MxcRepositoryTestSupport.InvokeAsync(
+            "dotnet", Arguments("Phantom.Workspaces.slnx"));
+
+    internal Task<MxcRepositoryTestSupport.ProcessResult> CleanWithOutDirAsync(string outDir) =>
+        MxcRepositoryTestSupport.InvokeAsync("dotnet",
+            "clean", Path.Combine("Phantom.Workspaces.Install.Tests",
+                "Phantom.Workspaces.Install.Tests.csproj"),
+            "--nologo", "/nodeReuse:false",
+            $"-p:BaseIntermediateOutputPath=obj\\{name}\\",
+            $"-p:OutDir={outDir}{Path.DirectorySeparatorChar}");
+
+    internal Task<MxcRepositoryTestSupport.ProcessResult> PrepareAsync() =>
+        MxcRepositoryTestSupport.InvokeAsync("dotnet",
+            new MxcRepositoryTestSupport.InvocationOptions
+            {
+                Timeout = TimeSpan.FromMinutes(25),
+                StandardOutputObserver = line => Console.WriteLine(line)
+            },
+            [
+                "msbuild",
+                Path.Combine("Phantom.Workspaces.Install.Tests",
+                    "Phantom.Workspaces.Install.Tests.csproj"),
+                "-target:PrepareCopilotWrapperTestPrerequisite", "-nologo", "/nodeReuse:false",
+                $"-p:BaseIntermediateOutputPath=obj\\{name}\\",
+                $"-p:BaseOutputPath=bin\\{name}\\"
+            ]);
+
+    internal void AssertRemoved()
+    {
+        Assert.False(Directory.Exists(CacheRoot));
+        Assert.False(File.Exists(PointerFile));
+        Assert.False(File.Exists(CopiedPointerFile));
+    }
+
+    internal void AssertEntriesPresent()
+    {
+        foreach (var name in new[]
+        {
+            "aaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbb", "dddddddddddddddd.staging-123"
+        })
+        {
+            Assert.True(File.Exists(Path.Combine(CacheRoot, name, "prepared",
+                "phantom-copilot-wrapper.exe")));
+        }
+    }
+
+    public void Dispose()
+    {
+        if (Directory.Exists(BaseDirectory))
+            Directory.Delete(BaseDirectory, true);
+        if (Directory.Exists(outputDirectory))
+            Directory.Delete(outputDirectory, true);
+    }
+}
diff --git a/Phantom.Workspaces.Install.Tests/MxcIntegrationTests.cs b/Phantom.Workspaces.Install.Tests/MxcIntegrationTests.cs
index a0eedda7..8a892c0e 100644
--- a/Phantom.Workspaces.Install.Tests/MxcIntegrationTests.cs
+++ b/Phantom.Workspaces.Install.Tests/MxcIntegrationTests.cs
@@ -1,9 +1,35 @@
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
 using System.Text.Json;
 
 namespace Phantom.Workspaces.Install.Tests;
 
+internal static class CopilotWrapperTestHostLease
+{
+    private static FileStream? lease;
+
+    [ModuleInitializer]
+    internal static void Start()
+    {
+        if (!OperatingSystem.IsWindows())
+            return;
+        var pointer = Path.Combine(
+            AppContext.BaseDirectory, "copilot-wrapper-prerequisite.path");
+        if (!File.Exists(pointer))
+            return;
+        var cacheDirectory = File.ReadAllText(pointer).Trim();
+        lease = MxcRepositoryTestSupport.OpenCopilotWrapperPrerequisiteLease(cacheDirectory);
+        if (!string.Equals(cacheDirectory, File.ReadAllText(pointer).Trim(),
+                StringComparison.OrdinalIgnoreCase) || !Directory.Exists(cacheDirectory))
+        {
+            lease.Dispose();
+            lease = null;
+            throw new InvalidDataException("The prerequisite changed while the test host acquired its cache lease.");
+        }
+    }
+}
+
 [CollectionDefinition(Name, DisableParallelization = true)]
 public sealed class MxcIntegrationCollection
 {
@@ -11,7 +37,7 @@ public sealed class MxcIntegrationCollection
 }
 
 [Collection(MxcIntegrationCollection.Name)]
-public sealed class BuildIntegrationTests
+public sealed partial class BuildIntegrationTests
 {
     [Fact]
     public async Task BuildSolution_MxcSourceDependency_BuildsThroughStandardEntryPoint()
@@ -165,7 +191,7 @@ public sealed class MxcSdkVersionTests
     [Fact]
     public void MxcSdkVersion_AppReleaseVersionOverride_LeavesSdkAssemblyVersionUnchanged()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
 
         Assert.Equal("0.0.21", prerequisite.Manifest.AppReleaseVersion);
         Assert.Equal(
@@ -218,7 +244,7 @@ public void MxcSdkVersion_AppReleaseVersionOverride_LeavesSdkAssemblyVersionUnch
     [Fact]
     public async Task MxcSdkVersion_ProductPublishWithReleaseVersion_ValidatorPasses()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         var appResult = await MxcRepositoryTestSupport.InvokePowerShellAsync(
             "packaging", "validate", "Assert-PhantomReleaseVersion.ps1",
             "-ExpectedVersion", prerequisite.Manifest.AppReleaseVersion,
@@ -347,7 +373,7 @@ public sealed class MxcRuntimePayloadTests
     [Fact]
     public void MxcRuntimePayload_CommandConsumesTopLevelNativeBuild()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         var arguments = MxcRepositoryTestSupport.CreateMxcRuntimePayloadArguments(
             "payload",
             "isolated-artifacts",
@@ -373,7 +399,7 @@ public void MxcRuntimePayload_CommandConsumesTopLevelNativeBuild()
     [Fact]
     public async Task MxcRuntimePayload_RequiredNativeUnit_IsPresent()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         var processObserver = new RecordingProcessObserver();
         MxcRepositoryTestSupport.ProcessResult? publish = null;
         MxcRepositoryTestSupport.ProcessResult? validation = null;
@@ -880,12 +906,12 @@ public async Task Install_Arm64Architecture_ReportsUnsupportedArchitecture()
 }
 
 [Collection(MxcIntegrationCollection.Name)]
-public sealed class CopilotWrapperNestedPublishTests
+public sealed partial class CopilotWrapperNestedPublishTests
 {
     [Fact]
     public void NestedPublish_CommandRequiresPreparedReleaseWrapper()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         var arguments = MxcRepositoryTestSupport.CreateCopilotWrapperPublishArguments(
             "payload",
             "isolated-artifacts",
@@ -908,7 +934,7 @@ public void NestedPublish_CommandRequiresPreparedReleaseWrapper()
     [Fact]
     public void PreparedWrapper_SourceToolchainAndPayloadProvenanceAreCurrent()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
 
         Assert.Equal(5, prerequisite.Manifest.SchemaVersion);
         Assert.True(prerequisite.Manifest.ProductionPublishValidated);
@@ -984,7 +1010,7 @@ public void NestedPublish_ColdNativeBuildIsPreparedBeforeBlameMonitorsTestHost()
     [Fact]
     public async Task NestedPublish_RidConsistentGraphProducesUniqueCompleteWrapperPayload()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory(
             cleanupProgress: message => Console.WriteLine($"wrapper payload {message}"));
         await using var buildArtifacts = new MxcRepositoryTestSupport.TestDirectory(
@@ -1042,7 +1068,7 @@ public async Task NestedPublish_RidConsistentGraphProducesUniqueCompleteWrapperP
     [Fact]
     public async Task NestedPublish_CustomIntermediateWithSpaces_IsCanonicalAndInvocationUnique()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var intermediateOwner = new MxcRepositoryTestSupport.TestDirectory();
         await using var firstPayload = new MxcRepositoryTestSupport.TestDirectory();
         await using var firstArtifacts = new MxcRepositoryTestSupport.TestDirectory();
@@ -1091,7 +1117,7 @@ public async Task NestedPublish_CustomIntermediateWithSpaces_IsCanonicalAndInvoc
     [Fact]
     public async Task NestedPublish_CustomBaseIntermediateWithSpaces_StaysUnderCanonicalBase()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var intermediateOwner = new MxcRepositoryTestSupport.TestDirectory();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var artifacts = new MxcRepositoryTestSupport.TestDirectory();
@@ -1117,7 +1143,7 @@ public async Task NestedPublish_CustomBaseIntermediateWithSpaces_StaysUnderCanon
     [Fact]
     public async Task NestedPublish_ReparseIntermediate_FailsBeforeWritingChildOutput()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var intermediateOwner = new MxcRepositoryTestSupport.TestDirectory();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var artifacts = new MxcRepositoryTestSupport.TestDirectory();
@@ -1164,7 +1190,7 @@ public async Task NestedPublish_ReparseIntermediate_FailsBeforeWritingChildOutpu
     [Fact]
     public async Task NestedPublish_MissingChildOutput_FailsClosed()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var payload = new MxcRepositoryTestSupport.TestDirectory();
         await using var artifacts = new MxcRepositoryTestSupport.TestDirectory();
         var result = await MxcRepositoryTestSupport.InvokeAsync(
@@ -1191,7 +1217,7 @@ public async Task NestedPublish_MissingChildOutput_FailsClosed()
     [Fact]
     public async Task NestedPublish_SharedPreparedWrapperProducesConcurrentIsolatedPayloads()
     {
-        var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
+        using var prerequisite = MxcRepositoryTestSupport.LoadCopilotWrapperPrerequisite();
         await using var firstPayload = new MxcRepositoryTestSupport.TestDirectory();
         await using var firstArtifacts = new MxcRepositoryTestSupport.TestDirectory();
         await using var secondPayload = new MxcRepositoryTestSupport.TestDirectory();
@@ -1366,6 +1392,12 @@ private static string[] CreatePreparedCopilotPayloadProperties(
     [
         $"-p:NoBuild={noBuild.ToString().ToLowerInvariant()}",
         $"-p:UsePreparedCopilotPayloadForTests={usePreparedPayload.ToString().ToLowerInvariant()}",
+        .. !string.Equals(
+            Directory.GetParent(prerequisite.CacheDirectory)!.FullName,
+            Path.Combine(Root.FullName, "Phantom.Workspaces.Install.Tests", "obj", "mxcw"),
+            StringComparison.OrdinalIgnoreCase)
+            ? new[] { $"-p:PreparedCopilotPayloadCacheRoot={Directory.GetParent(prerequisite.CacheDirectory)!.FullName}" }
+            : Array.Empty<string>(),
         $"-p:PreparedCopilotPayloadDirectory={preparedDirectory ?? prerequisite.PreparedDirectory}",
         $"-p:PreparedCopilotPayloadFingerprint={preparedFingerprint ?? prerequisite.Manifest.CacheKey}",
         $"-p:PreparedCopilotPayloadConfiguration={prerequisite.Manifest.Configuration}",
@@ -1436,12 +1468,30 @@ internal static void AssertExclusivelyOpenable(string path)
     internal static CopilotWrapperPrerequisite LoadCopilotWrapperPrerequisite()
     {
         var pathFile = Path.Combine(
-            AppContext.BaseDirectory,
-            "copilot-wrapper-prerequisite.path");
-        Assert.True(
-            File.Exists(pathFile),
-            $"The pre-VSTest wrapper prerequisite path file is missing: '{pathFile}'.");
+            AppContext.BaseDirectory, "copilot-wrapper-prerequisite.path");
+        return LoadCopilotWrapperPrerequisite(pathFile);
+    }
+
+    internal static CopilotWrapperPrerequisite LoadCopilotWrapperPrerequisite(string pathFile)
+    {
         var cacheDirectory = File.ReadAllText(pathFile).Trim();
+        var lease = OpenCopilotWrapperPrerequisiteLease(cacheDirectory);
+        try
+        {
+            Assert.Equal(cacheDirectory, File.ReadAllText(pathFile).Trim(),
+                ignoreCase: true);
+            return LoadCopilotWrapperPrerequisiteCore(lease, cacheDirectory);
+        }
+        catch
+        {
+            lease.Dispose();
+            throw;
+        }
+    }
+
+    private static CopilotWrapperPrerequisite LoadCopilotWrapperPrerequisiteCore(
+        FileStream lease, string cacheDirectory)
+    {
         var manifestPath = Path.Combine(cacheDirectory, "prerequisite.json");
         Assert.True(
             File.Exists(manifestPath),
@@ -1452,11 +1502,7 @@ internal static CopilotWrapperPrerequisite LoadCopilotWrapperPrerequisite()
         Assert.Equal(5, manifest.SchemaVersion);
         Assert.Matches("^[0-9a-f]{64}$", manifest.CacheKey);
         Assert.Matches("^[0-9a-f]{64}$", manifest.SourceFingerprint);
-        var expectedCacheRoot = Path.GetFullPath(Path.Combine(
-            Root.FullName,
-            "Phantom.Workspaces.Install.Tests",
-            "obj",
-            "mxcw"));
+        var expectedCacheRoot = GetOwnedPrerequisiteCacheRoot(cacheDirectory);
         Assert.Equal(
             expectedCacheRoot,
             Directory.GetParent(cacheDirectory)!.FullName,
@@ -1501,11 +1547,55 @@ string ArtifactPath(string relativePath)
             ArtifactPath("prepared/Phantom.Workspaces.dll"),
             ArtifactPath("prepared/Microsoft.Mxc.Sdk.dll"),
             ArtifactPath("prepared/phantom-copilot-wrapper.dll"),
-            ArtifactPath("prepared/Phantom.Workspaces.Llm.Core.dll"));
+            ArtifactPath("prepared/Phantom.Workspaces.Llm.Core.dll"),
+            lease);
         prerequisite.AssertArtifactHashes();
         return prerequisite;
     }
 
+    internal static string GetOwnedPrerequisiteCacheRoot(string cacheDirectory)
+    {
+        var project = Path.Combine(Root.FullName, "Phantom.Workspaces.Install.Tests");
+        var root = Directory.GetParent(cacheDirectory)?.FullName
+            ?? throw new InvalidDataException("The prerequisite cache directory has no parent.");
+        if (!Path.IsPathFullyQualified(cacheDirectory) ||
+            !string.Equals(Path.GetFullPath(cacheDirectory),
+                Path.TrimEndingDirectorySeparator(cacheDirectory),
+                StringComparison.OrdinalIgnoreCase) ||
+            !root.StartsWith(project + Path.DirectorySeparatorChar,
+                StringComparison.OrdinalIgnoreCase) ||
+            !string.Equals(Path.GetFileName(root), "mxcw",
+                StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidDataException("The prerequisite cache root is not project-owned and canonical.");
+        }
+        var current = project;
+        foreach (var part in Path.GetRelativePath(project, root)
+                     .Split(Path.DirectorySeparatorChar))
+        {
+            current = Path.Combine(current, part);
+            if ((Directory.Exists(current) || File.Exists(current)) &&
+                (File.GetAttributes(current) & FileAttributes.ReparsePoint) != 0)
+            {
+                throw new InvalidDataException(
+                    $"The prerequisite cache path contains a reparse point: '{current}'.");
+            }
+        }
+        return root;
+    }
+
+    internal static FileStream OpenCopilotWrapperPrerequisiteLease(string cacheDirectory)
+    {
+        var root = GetOwnedPrerequisiteCacheRoot(cacheDirectory);
+        var lockPath = Path.Combine(Directory.GetParent(root)!.FullName, "mxcw.lock");
+        if (File.Exists(lockPath) &&
+            (File.GetAttributes(lockPath) & FileAttributes.ReparsePoint) != 0)
+        {
+            throw new InvalidDataException($"The prerequisite lease is a reparse point: '{lockPath}'.");
+        }
+        return File.Open(lockPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+    }
+
     internal static string ComputeSha256(string path) =>
         Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path))).ToLowerInvariant();
 
@@ -1706,8 +1796,10 @@ internal sealed record CopilotWrapperPrerequisite(
         string AppAssembly,
         string MxcSdkAssembly,
         string CopilotWrapperAssembly,
-        string LlmCoreAssembly)
+        string LlmCoreAssembly,
+        FileStream Lease) : IDisposable
     {
+        public void Dispose() => Lease.Dispose();
         internal string ArtifactSha256(string relativePath) =>
             Assert.Single(
                 Manifest.Artifacts,
diff --git a/Phantom.Workspaces.Install.Tests/Phantom.Workspaces.Install.Tests.csproj b/Phantom.Workspaces.Install.Tests/Phantom.Workspaces.Install.Tests.csproj
index 6ab75409..4f9b46d4 100644
--- a/Phantom.Workspaces.Install.Tests/Phantom.Workspaces.Install.Tests.csproj
+++ b/Phantom.Workspaces.Install.Tests/Phantom.Workspaces.Install.Tests.csproj
@@ -1,4 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="..\scripts\CopilotWrapperPrerequisiteLease.targets" />
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -33,10 +34,14 @@
           BeforeTargets="VSTest"
           Condition="$([MSBuild]::IsOSPlatform('Windows')) And '$(DesignTimeBuild)' != 'true'">
     <PropertyGroup>
-      <_CopilotWrapperPrerequisiteCache>$(MSBuildProjectDirectory)\$(BaseIntermediateOutputPath)mxcw</_CopilotWrapperPrerequisiteCache>
-      <_CopilotWrapperPrerequisitePathFile>$(MSBuildProjectDirectory)\$(IntermediateOutputPath)copilot-wrapper-prerequisite.path</_CopilotWrapperPrerequisitePathFile>
+      <_CopilotWrapperPrerequisiteCache>$([System.IO.Path]::GetFullPath('$(BaseIntermediateOutputPath)mxcw', '$(MSBuildProjectDirectory)'))</_CopilotWrapperPrerequisiteCache>
+      <_CopilotWrapperPrerequisitePathFile>$([System.IO.Path]::GetFullPath('$(IntermediateOutputPath)copilot-wrapper-prerequisite.path', '$(MSBuildProjectDirectory)'))</_CopilotWrapperPrerequisitePathFile>
+      <_CopilotWrapperPrerequisiteBase>$([System.IO.Path]::TrimEndingDirectorySeparator($([System.IO.Path]::GetFullPath('$(BaseIntermediateOutputPath)', '$(MSBuildProjectDirectory)'))))</_CopilotWrapperPrerequisiteBase>
     </PropertyGroup>
-    <Exec Command="pwsh -NoProfile -NonInteractive -File &quot;$(MSBuildProjectDirectory)\..\scripts\prepare-copilot-wrapper-test-prerequisite.ps1&quot; -RepositoryRoot &quot;$(MSBuildProjectDirectory)\..&quot; -CacheRoot &quot;$(_CopilotWrapperPrerequisiteCache)&quot; -PathOutputFile &quot;$(_CopilotWrapperPrerequisitePathFile)&quot;"
+    <HoldCopilotWrapperPrerequisiteLease
+        CacheRoot="$(_CopilotWrapperPrerequisiteCache)"
+        ProjectDirectory="$(MSBuildProjectDirectory)" />
+    <Exec Command="pwsh -NoProfile -NonInteractive -File &quot;$(MSBuildProjectDirectory)\..\scripts\prepare-copilot-wrapper-test-prerequisite.ps1&quot; -RepositoryRoot &quot;$(MSBuildProjectDirectory)\..&quot; -ProjectDirectory &quot;$(MSBuildProjectDirectory)&quot; -BaseIntermediateOutputPath &quot;$(_CopilotWrapperPrerequisiteBase)&quot; -CacheRoot &quot;$(_CopilotWrapperPrerequisiteCache)&quot; -PathOutputFile &quot;$(_CopilotWrapperPrerequisitePathFile)&quot;"
           StandardOutputImportance="high"
           StandardErrorImportance="high" />
     <Error Condition="!Exists('$(_CopilotWrapperPrerequisitePathFile)')"
@@ -45,4 +50,17 @@
           DestinationFiles="$(OutDir)copilot-wrapper-prerequisite.path"
           SkipUnchangedFiles="true" />
   </Target>
+  <Target Name="CleanCopilotWrapperTestPrerequisite"
+          BeforeTargets="Clean"
+          Condition="$([MSBuild]::IsOSPlatform('Windows')) And '$(DesignTimeBuild)' != 'true'">
+    <PropertyGroup>
+      <_CopilotWrapperPrerequisiteCache>$([System.IO.Path]::GetFullPath('$(BaseIntermediateOutputPath)mxcw', '$(MSBuildProjectDirectory)'))</_CopilotWrapperPrerequisiteCache>
+      <_CopilotWrapperPrerequisitePathFile>$([System.IO.Path]::GetFullPath('$(IntermediateOutputPath)copilot-wrapper-prerequisite.path', '$(MSBuildProjectDirectory)'))</_CopilotWrapperPrerequisitePathFile>
+      <_CopilotWrapperPrerequisiteBase>$([System.IO.Path]::TrimEndingDirectorySeparator($([System.IO.Path]::GetFullPath('$(BaseIntermediateOutputPath)', '$(MSBuildProjectDirectory)'))))</_CopilotWrapperPrerequisiteBase>
+      <_CopilotWrapperPrerequisiteCopiedPathFile>$([System.IO.Path]::GetFullPath('$(OutDir)copilot-wrapper-prerequisite.path', '$(MSBuildProjectDirectory)'))</_CopilotWrapperPrerequisiteCopiedPathFile>
+    </PropertyGroup>
+    <Exec Command="pwsh -NoProfile -NonInteractive -File &quot;$(MSBuildProjectDirectory)\..\scripts\clean-copilot-wrapper-test-prerequisite.ps1&quot; -ProjectDirectory &quot;$(MSBuildProjectDirectory)&quot; -BaseIntermediateOutputPath &quot;$(_CopilotWrapperPrerequisiteBase)&quot; -CacheRoot &quot;$(_CopilotWrapperPrerequisiteCache)&quot; -PathOutputFile &quot;$(_CopilotWrapperPrerequisitePathFile)&quot; -CopiedPathFile &quot;$(_CopilotWrapperPrerequisiteCopiedPathFile)&quot;"
+          StandardOutputImportance="high"
+          StandardErrorImportance="high" />
+  </Target>
 </Project>
diff --git a/Phantom.Workspaces.Llm.Core.Tests/CopilotSdkStreamAdapterTests.cs b/Phantom.Workspaces.Llm.Core.Tests/CopilotSdkStreamAdapterTests.cs
index b505b550..89440ec8 100644
--- a/Phantom.Workspaces.Llm.Core.Tests/CopilotSdkStreamAdapterTests.cs
+++ b/Phantom.Workspaces.Llm.Core.Tests/CopilotSdkStreamAdapterTests.cs
@@ -539,6 +539,56 @@ public async Task TranslateCopilotSdkSessionEvents_SystemNotificationEvent_Strip
             text.AdditionalProperties![CopilotSdkStreamAdapter.ContentTypePropertyName]);
     }
 
+    [Fact]
+    public async Task TranslateCopilotSdkSessionEvents_ToolAndIdleNotificationSequence_PreservesProviderOrderAndSystemRole()
+    {
+        var updates = await TranslateAsync(
+            new ToolExecutionStartEvent
+            {
+                AgentId = string.Empty,
+                Data = new ToolExecutionStartData { ToolCallId = "parent-1", ToolName = "task" },
+            },
+            new SystemNotificationEvent
+            {
+                AgentId = string.Empty,
+                Data = new SystemNotificationData
+                {
+                    Content = "<system_notification>agent idle</system_notification>",
+                    Kind = new SystemNotificationAgentIdle
+                    {
+                        AgentId = "agent-1", AgentType = "background", Description = "idle",
+                    },
+                },
+            },
+            new ToolExecutionCompleteEvent
+            {
+                AgentId = string.Empty,
+                Data = new ToolExecutionCompleteData
+                {
+                    ToolCallId = "parent-1", Success = true,
+                    Result = new ToolExecutionCompleteResult { Content = "done" },
+                },
+            },
+            new ToolExecutionStartEvent
+            {
+                AgentId = string.Empty,
+                Data = new ToolExecutionStartData { ToolCallId = "parent-2", ToolName = "task" },
+            });
+
+        Assert.Equal(4, updates.Count);
+        Assert.Equal(ChatRole.Assistant, updates[0].Role);
+        Assert.Equal(ChatRole.System, updates[1].Role);
+        Assert.Equal(ChatRole.Tool, updates[2].Role);
+        Assert.Equal(ChatRole.Assistant, updates[3].Role);
+        Assert.Equal("parent-1", Assert.IsType<FunctionCallContent>(Assert.Single(updates[0].Contents)).CallId);
+        Assert.Equal("agent idle", Assert.IsType<TextContent>(Assert.Single(updates[1].Contents)).Text);
+        Assert.Equal("parent-1", Assert.IsType<FunctionResultContent>(Assert.Single(updates[2].Contents)).CallId);
+        Assert.Equal("parent-2", Assert.IsType<FunctionCallContent>(Assert.Single(updates[3].Contents)).CallId);
+        Assert.Equal(CopilotSdkStreamAdapter.SystemNotificationContentType,
+            Assert.IsType<TextContent>(Assert.Single(updates[1].Contents))
+                .AdditionalProperties![CopilotSdkStreamAdapter.ContentTypePropertyName]);
+    }
+
     [Fact]
     public async Task TranslateCopilotSdkSessionEvents_SessionIdleEvent_CompletesStream()
     {
diff --git a/Phantom.Workspaces.Llm.Core.Tests/RemoteAgentChatNotificationPipelineTests.cs b/Phantom.Workspaces.Llm.Core.Tests/RemoteAgentChatNotificationPipelineTests.cs
new file mode 100644
index 00000000..181f63b9
--- /dev/null
+++ b/Phantom.Workspaces.Llm.Core.Tests/RemoteAgentChatNotificationPipelineTests.cs
@@ -0,0 +1,139 @@
+using System.Collections.Specialized;
+using System.Text.Json;
+using System.Threading.Channels;
+using GitHub.Copilot;
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Phantom.Workspaces.Llm.Remote;
+using Phantom.Workspaces.Transport;
+
+namespace Phantom.Workspaces.Llm.Tests;
+
+public sealed partial class RemoteAgentChatTests
+{
+    [Fact]
+    public async Task SdkNotification_CoalescedRemoteStreamingPromotionAndSnapshot_PreserveEncounterOrderAndSubagentContext()
+    {
+        var source = Channel.CreateUnbounded<SessionEvent>();
+        source.Writer.TryWrite(new ToolExecutionStartEvent
+        {
+            AgentId = string.Empty,
+            Data = new ToolExecutionStartData { ToolCallId = "parent", ToolName = "task" },
+        });
+        source.Writer.TryWrite(new SystemNotificationEvent
+        {
+            AgentId = string.Empty,
+            Data = new SystemNotificationData
+            {
+                Content = "<system_notification>child idle</system_notification>",
+                Kind = new SystemNotificationAgentIdle
+                {
+                    AgentId = "child", AgentType = "background", Description = "idle",
+                },
+            },
+        });
+        source.Writer.TryWrite(new ToolExecutionCompleteEvent
+        {
+            AgentId = string.Empty,
+            Data = new ToolExecutionCompleteData
+            {
+                ToolCallId = "parent", Success = true,
+                Result = new ToolExecutionCompleteResult { Content = "done" },
+            },
+        });
+        source.Writer.Complete();
+
+        var updates = new List<AgentResponseUpdate>();
+        await foreach (var update in CopilotSdkStreamAdapter.TranslateCopilotSdkSessionEvents(
+            source.Reader, CancellationToken.None))
+        {
+            updates.Add(new AgentResponseUpdate { Role = update.Role, Contents = update.Contents });
+        }
+        var items = AgentResponseUpdateCoalescer.Coalesce(updates.ToArray(), TimeProvider.System)
+            .Select(item => item with { AssistantRunId = "ordered-run" }).ToArray();
+        Assert.Equal(new[] { ChatRole.Assistant, ChatRole.System, ChatRole.Tool },
+            items.Select(item => item.Role));
+
+        static JsonElement Json(object value)
+            => JsonSerializer.SerializeToElement(value, AIJsonUtilities.DefaultOptions);
+        var child = Json(new
+        {
+            AgentId = "child", Name = "background", DisplayName = "Background agent",
+            Description = "Parent task child", CompletionState = AgentChatCompletionState.Running,
+            LastUpdatedAt = DateTime.UnixEpoch, SubAgents = Array.Empty<object>(),
+        });
+        var (transport, chat) = await AttachAsync();
+        await using (chat)
+        {
+            var subagentReady = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            ((INotifyCollectionChanged)chat.SubAgents).CollectionChanged += (_, _) =>
+            {
+                if (chat.SubAgents.Count == 1) subagentReady.TrySetResult();
+            };
+            await transport.SendAsync(Frame(2, new SubagentsChangedEvent { Subagents = [child] }));
+            await subagentReady.Task;
+
+            var started = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            ((INotifyCollectionChanged)chat.RunningItems).CollectionChanged += (_, _) =>
+            {
+                if (chat.RunningItems.Count == 1) started.TrySetResult();
+            };
+            await transport.SendAsync(Frame(3, new StreamingStartedEvent
+            {
+                RunId = "stream", Item = Json(items[0]),
+            }));
+            await started.Task;
+            var running = Assert.Single(chat.RunningItems);
+            Assert.Equal("ordered-run", running.AssistantRunId);
+            Assert.Equal("parent", Assert.IsType<FunctionCallContent>(Assert.Single(running.Items[0].Contents)).CallId);
+            Assert.Equal("child", Assert.Single(chat.SubAgents).AgentId);
+
+            var updated = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            running.Items.CollectionChanged += (_, _) =>
+            {
+                if (running.Items.Count == items.Length) updated.TrySetResult();
+            };
+            await transport.SendAsync(Frame(4, new StreamingUpdatedEvent
+            {
+                RunId = "stream", Update = Json(items),
+            }));
+            await updated.Task;
+            Assert.Equal(ChatRole.System, running.Items[1].Role);
+            Assert.Equal("child idle", Assert.IsType<TextContent>(Assert.Single(running.Items[1].Contents)).Text);
+
+            var promoted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            ((INotifyCollectionChanged)chat.History).CollectionChanged += (_, _) =>
+            {
+                if (chat.History.Count == items.Length) promoted.TrySetResult();
+            };
+            await transport.SendAsync(Frame(5, new StreamingCompletedEvent
+            {
+                RunId = "stream", Item = Json(items[^1]), Items = items.Select(Json).ToArray(),
+            }));
+            await promoted.Task;
+            Assert.Empty(chat.RunningItems);
+            Assert.Equal(items.Select(item => item.Role), chat.History.Select(item => item.Role));
+            Assert.Equal("child", Assert.Single(chat.SubAgents).AgentId);
+        }
+
+        var snapshot = AgentSessionProtocolCodecTests.Snapshot() with
+        {
+            History = items.Select(Json).ToArray(),
+            Subagents = [child],
+        };
+        var reloadTransport = new TestTransport();
+        var attaching = RemoteAgentChat.AttachAsync(new RemoteAgentChatAttachOptions
+        {
+            Client = new RemoteAgentSessionClient(reloadTransport),
+            OpenRequest = AgentSessionProtocolCodecTests.Open(),
+            ForegroundScheduler = TaskScheduler.Default,
+        });
+        await reloadTransport.SendAsync(Frame(1, new SessionSnapshotEvent { Snapshot = snapshot }));
+        await using var reloaded = await attaching;
+        Assert.Equal(items.Select(item => item.Role), reloaded.History.Select(item => item.Role));
+        Assert.Equal("parent", Assert.IsType<FunctionCallContent>(Assert.Single(reloaded.History[0].Contents)).CallId);
+        Assert.Equal("child idle", Assert.IsType<TextContent>(Assert.Single(reloaded.History[1].Contents)).Text);
+        Assert.Equal("parent", Assert.IsType<FunctionResultContent>(Assert.Single(reloaded.History[2].Contents)).CallId);
+        Assert.Equal("child", Assert.Single(reloaded.SubAgents).AgentId);
+    }
+}
diff --git a/Phantom.Workspaces.Llm.Core/Remote/RemoteAgentChat.cs b/Phantom.Workspaces.Llm.Core/Remote/RemoteAgentChat.cs
index d31f53fd..375ca7ae 100644
--- a/Phantom.Workspaces.Llm.Core/Remote/RemoteAgentChat.cs
+++ b/Phantom.Workspaces.Llm.Core/Remote/RemoteAgentChat.cs
@@ -883,15 +883,21 @@ private sealed class RemoteRunningSubagent : IRemoteSubagentReference
 
         internal void Update(RemoteRunningSubagent incoming)
         {
+            var presentationChanged = this.DisplayName != incoming.DisplayName
+                || this.Description != incoming.Description
+                || this.Name != incoming.Name
+                || this.CompletionState != incoming.CompletionState
+                || !this.SubAgents.Select(child => (child.AgentId, child.DisplayName, child.CompletionState))
+                    .SequenceEqual(incoming.SubAgents.Select(child => (child.AgentId, child.DisplayName, child.CompletionState)));
             this.AgentSessionId = incoming.AgentSessionId;
             this.DisplayName = incoming.DisplayName;
             this.Description = incoming.Description;
             this.Name = incoming.Name;
             this.LastUpdatedAt = incoming.LastUpdatedAt;
             this.SubAgents = incoming.SubAgents;
-            if (this.CompletionState == incoming.CompletionState) return;
             this.CompletionState = incoming.CompletionState;
-            this.CompletionStateChanged?.Invoke(this, EventArgs.Empty);
+            if (presentationChanged)
+                this.CompletionStateChanged?.Invoke(this, EventArgs.Empty);
         }
 
         internal static RemoteRunningSubagent FromJson(JsonElement value)
diff --git a/Phantom.Workspaces.Tests/EntityBrowserWorkspaceTabViewModelTests.cs b/Phantom.Workspaces.Tests/EntityBrowserWorkspaceTabViewModelTests.cs
index f5dfef0c..d6b740b9 100644
--- a/Phantom.Workspaces.Tests/EntityBrowserWorkspaceTabViewModelTests.cs
+++ b/Phantom.Workspaces.Tests/EntityBrowserWorkspaceTabViewModelTests.cs
@@ -1,4 +1,9 @@
 using Avalonia.Headless.XUnit;
+using Avalonia.Controls;
+using Avalonia.Controls.Templates;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using Phantom.Workspaces.Templates;
 using System.Collections.Specialized;
 using System.Text.Json;
 using System.Threading;
@@ -11,6 +16,80 @@ namespace Phantom.Workspaces.Tests;
 
 public sealed class EntityBrowserWorkspaceTabViewModelTests
 {
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task BrowserTemplate_ActualItemsCountBinding_SwitchesStyledPanelAtThreshold()
+    {
+        var broker = await CreateBrokerAsync();
+        var subscription = await broker.SubscribeGetAsync(new GetRequest
+        {
+            Entities = [new GetEntityRequest
+            {
+                EntityName = EntityName.Root,
+                EnumerateChildren = EnumerateChildrenAction.EnumerateSelf,
+            }],
+            Timestamps = [null],
+        }, TestContext.Current.CancellationToken);
+        var model = new EntityBrowserWorkspaceTabViewModel(broker, subscription)
+        {
+            Id = "browser-panel-test",
+            Title = "Browser",
+        };
+        // Freeze the broker-driven rebuild; this test mutates the real bound list deterministically.
+        await model.DisposeAsync();
+        var view = new EntityBrowserWorkspaceTabView { DataContext = model };
+        var tree = Assert.IsType<TreeView>(view.FindControl<TreeView>("BrowserTreeView"));
+        tree.ItemTemplate = new FuncDataTemplate<EntityListItemViewModel>(
+            (item, _) => new TextBlock { Text = item.ItemKey, Height = 25 });
+        var window = new Window { Content = view, Width = 400, Height = 320 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            Assert.Same(tree, Assert.Single(view.GetVisualDescendants().OfType<TreeView>()));
+            model.EntityList.Items.Clear();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+            var first = new EntityListNodeViewModel("One", "entity", ["one"], "one");
+            model.EntityList.Items.Add(new EntityListItemViewModel(first, 0, 0, "one"));
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+            model.EntityList.Items.Clear();
+            window.Content = null;
+            for (int i = 0; i < 100; i++)
+            {
+                var node = new EntityListNodeViewModel($"Node {i}", "entity", [$"node-{i}"], $"node-{i}");
+                model.EntityList.Items.Add(new EntityListItemViewModel(node, i, 0, $"node-{i}"));
+            }
+            window.Content = view;
+            Dispatcher.UIThread.RunJobs();
+            Assert.Equal(100, model.EntityList.Items.Count);
+            Assert.Equal(100, model.EntityList.NodeCount);
+            Assert.Equal(100, Phantom.Workspaces.Controls.EntityTreePanel.GetNodeCount(tree));
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+            model.EntityList.Items.RemoveAt(99);
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+            model.EntityList.ApplyFindFilter([], hideUnmatched: true);
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+
+            window.Content = null;
+            for (int i = 99; i < 1000; i++)
+            {
+                var node = new EntityListNodeViewModel($"Node {i}", "entity", [$"node-{i}"], $"node-{i}");
+                model.EntityList.Items.Add(new EntityListItemViewModel(node, i, 0, $"node-{i}"));
+            }
+            window.Content = view;
+            Dispatcher.UIThread.RunJobs();
+            Assert.Equal(1000, Phantom.Workspaces.Controls.EntityTreePanel.GetNodeCount(tree));
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+            Assert.True(tree.ItemsPanelRoot!.Children.Count < 500);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
     [AvaloniaFact]
     public async Task BrowserList_TracksParentChildMetadataAndExpansion()
     {
diff --git a/Phantom.Workspaces.Tests/EntityCardControlInteractionTests.cs b/Phantom.Workspaces.Tests/EntityCardControlInteractionTests.cs
index 6f19ca0b..db67ad2b 100644
--- a/Phantom.Workspaces.Tests/EntityCardControlInteractionTests.cs
+++ b/Phantom.Workspaces.Tests/EntityCardControlInteractionTests.cs
@@ -62,7 +62,7 @@ public void EntityCardControl_WhenTappedEventAlreadyHandled_DoesNotOpenEntity()
     [AvaloniaFact(Timeout = 15_000)]
     public void EntityCardControl_WhenTappedOnBackground_OpensEntity()
     {
-        // A tap on a non-interactive area (e.g. the title TextBlock or empty card space) arrives
+        // A tap on a non-interactive area (e.g. empty card space) arrives
         // with Handled=false; the handler must activate the entity and claim the event.
         var card = new SpyEntityCardControl();
         var e = (TappedEventArgs)RuntimeHelpers.GetUninitializedObject(typeof(TappedEventArgs));
diff --git a/Phantom.Workspaces.Tests/EntityCardControlTests.cs b/Phantom.Workspaces.Tests/EntityCardControlTests.cs
index 2aed9a2f..2ceefa7e 100644
--- a/Phantom.Workspaces.Tests/EntityCardControlTests.cs
+++ b/Phantom.Workspaces.Tests/EntityCardControlTests.cs
@@ -4,7 +4,11 @@
 using System.Threading.Tasks;
 using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Headless;
 using Avalonia.Headless.XUnit;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Input.Raw;
 using Avalonia.Layout;
 using Avalonia.Threading;
 using Avalonia.VisualTree;
@@ -22,6 +26,44 @@ namespace Phantom.Workspaces.Tests;
 // entity's non-abstract types may be silently hidden.
 public sealed class EntityCardControlTests
 {
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_ExternalAndNote_RendersLinksAndNoteMarkdown()
+    {
+        var broker = await EntityBroker.CreateInitializedAsync(
+            new UnknownRepositorySource(), TestContext.Current.CancellationToken);
+        var catalog = await EntityTypeViewCatalog.CreateAsync(broker);
+        var entity = new SubscribedEntityViewModel(
+            ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot(
+                types: "\"entity\", \"tool\", \"external\", \"note\""));
+        var vm = new EntityCardViewModel(
+            entity, cardViewName: new EntityCardViewResolver().ResolveViewName(entity),
+            fieldEditorFactory: new FieldEditorFactory(broker, catalog));
+        Assert.Empty(vm.FieldEditors);
+
+        var window = new Window { Content = new EntityCardControl { DataContext = vm } };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            await vm.FieldEditorsBuildTask;
+            Dispatcher.UIThread.RunJobs();
+
+            Assert.True(vm.ShowFieldEditors);
+            Assert.Equal("content", Assert.Single(vm.FieldEditors).FieldName);
+            Assert.Single(window.GetVisualDescendants().OfType<CopyableLinkTextBlock>(),
+                link => link.Classes.Contains("workspace-url-link")
+                    && link.Text == "https://example.com/first");
+            Assert.Single(window.GetVisualDescendants().OfType<WorkspaceMarkdownView>(),
+                view => view.Markdown == "# First note");
+            Assert.DoesNotContain(window.GetVisualDescendants().OfType<TextBlock>(),
+                block => block.Text is { } text && text.Contains("must never appear", StringComparison.Ordinal));
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
     [AvaloniaFact(Timeout = 15_000)]
     public async Task EntityCardControl_ToolAndNote_RendersNoteMarkdown()
     {
@@ -459,6 +501,645 @@ public void EntityCardControl_GitWorktree_AllPropertyValuesAreCopyable()
         }
     }
 
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_GitWorktree_MouseSelectionAndCtrlC_CopiesEveryTextItem()
+    {
+        const string path = @"C:\repos\Phantom Workspaces\worktrees\20";
+        const string sha = "a1b2c3d4e5f678901234567890abcdef12345678";
+        var entity = new SubscribedEntityViewModel(BuildGitWorktreeSnapshotForTests());
+        var fields = new EntityFieldEditorViewModel[]
+        {
+            new StringFieldEditorViewModel("path", path),
+            new StringFieldEditorViewModel("branch", "fix/1624-copyable-card-text"),
+            new StringFieldEditorViewModel("head-commit", sha),
+            new StringFieldEditorViewModel("target-branch", "features"),
+        };
+        var vm = new EntityCardViewModel(entity, fields);
+        var card = new NavigationSpyCard { DataContext = vm };
+        var tree = new TreeView();
+        tree.Classes.Add("entity-card-tree");
+        tree.Items.Add(new TreeViewItem { Header = card });
+        var window = new Window { Content = tree, Width = 900, Height = 600 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+
+            var textItems = window.GetVisualDescendants().OfType<SafeSelectableTextBlock>()
+                .Where(t => t.IsEffectivelyVisible &&
+                    (t.Classes.Contains("workspace-entity-title") ||
+                     t.Classes.Contains("muted") && !t.Classes.Contains("workspace-field-label") ||
+                     t.Classes.Contains("workspace-field-label") ||
+                     t.Classes.Contains("workspace-field-read-value")))
+                .ToArray();
+            Assert.Contains(textItems, t => t.Text == path);
+            Assert.Contains(textItems, t => t.Text == sha);
+            Assert.Contains(textItems, t => t.Text == "head-commit");
+
+            foreach (var item in textItems)
+            {
+                var expected = item.Text;
+                if (string.IsNullOrEmpty(expected))
+                    continue;
+
+                var origin = item.TranslatePoint(new Point(0, 0), window)!.Value;
+                var y = origin.Y + Math.Min(item.Bounds.Height / 2, 8);
+                window.MouseDown(new Point(origin.X + 1, y), MouseButton.Left);
+                window.MouseUp(new Point(origin.X + 1, y), MouseButton.Left);
+                Assert.Equal(0, card.ActivationCount);
+                window.MouseDown(new Point(origin.X + 1, y), MouseButton.Left);
+                window.MouseMove(new Point(origin.X + item.Bounds.Width + 10, y), RawInputModifiers.LeftMouseButton);
+                window.MouseUp(new Point(origin.X + item.Bounds.Width + 10, y), MouseButton.Left);
+                Assert.NotEmpty(item.SelectedText);
+                Assert.Equal(0, card.ActivationCount);
+                item.SelectAll();
+                window.KeyPress(Key.C, RawInputModifiers.Control, PhysicalKey.C, "c");
+                using var clipboardData = await window.Clipboard!.TryGetDataAsync();
+                Assert.NotNull(clipboardData);
+                Assert.Equal(expected, await clipboardData.TryGetTextAsync());
+            }
+
+            vm.SearchQuery = "worktree";
+            Dispatcher.UIThread.RunJobs();
+            var title = textItems.Single(t => t.Classes.Contains("workspace-entity-title"));
+            Assert.Contains(title.Inlines!.OfType<Avalonia.Controls.Documents.Run>(),
+                run => run.Background is not null);
+            title.Focus();
+            title.SelectAll();
+            window.KeyPress(Key.C, RawInputModifiers.Control, PhysicalKey.C, "c");
+            using (var highlightedCopy = await window.Clipboard!.TryGetDataAsync())
+            {
+                Assert.NotNull(highlightedCopy);
+                Assert.Equal("worktree, system-defined", await highlightedCopy.TryGetTextAsync());
+            }
+
+            var root = card.GetVisualDescendants().OfType<StackPanel>()
+                .Single(panel => panel.Classes.Contains("workspace-entity-card-content"));
+            var rootOrigin = root.TranslatePoint(new Point(0, 0), window)!.Value;
+            var emptySpace = new Point(rootOrigin.X + root.Bounds.Width - 3,
+                rootOrigin.Y + root.Bounds.Height - 3);
+            window.MouseDown(emptySpace, MouseButton.Left);
+            window.MouseUp(emptySpace, MouseButton.Left);
+            Assert.Equal(1, card.ActivationCount);
+
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    private sealed class NavigationSpyCard : EntityCardControl
+    {
+        public int ActivationCount { get; private set; }
+
+        internal override void ActivateCard() => this.ActivationCount++;
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_ShortcutAndJsonButtonLabels_SelectCopyAndActivateOnce()
+    {
+        var entity = new SubscribedEntityViewModel(BuildGitWorktreeSnapshotForTests());
+        var vm = new EntityCardViewModel(entity);
+        var shortcut = new EntityShortcutViewModel
+        {
+            Shortcut = new Shortcut("Go", "Go"),
+            Entity = entity,
+            ShortcutManager = new ShortcutManager(),
+        };
+        object? invokedWith = null;
+        var calls = 0;
+        vm.SetShortcuts(new[] { shortcut }, new RelayCommand(parameter =>
+        {
+            invokedWith = parameter;
+            calls++;
+        }));
+        var card = new NavigationSpyCard { DataContext = vm };
+        var window = new Window { Content = card, Width = 500, Height = 250 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var labels = window.GetVisualDescendants().OfType<CopyableLinkTextBlock>().ToArray();
+            var shortcutLabel = Assert.Single(labels, t => t.Text == "Go");
+            var jsonLabel = Assert.Single(labels, t => t.Text == "{}");
+
+            ClickText(window, shortcutLabel);
+            Assert.Equal(1, calls);
+            Assert.Same(shortcut, invokedWith);
+            ClickText(window, jsonLabel);
+            Assert.True(vm.ShowRawJsonEditor);
+            Assert.Equal(0, card.ActivationCount);
+
+            await AssertMouseSelectAndCopyAsync(window, shortcutLabel);
+            Assert.Equal(1, calls);
+            await AssertMouseSelectAndCopyAsync(window, jsonLabel);
+            Assert.True(vm.ShowRawJsonEditor);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_EditActionLabels_CopyAndRetainButtonCommands()
+    {
+        var vm = new EntityCardViewModel("Editable", "note",
+            new EntityFieldEditorViewModel[] { new StringFieldEditorViewModel("name", "value") });
+        var card = new NavigationSpyCard { DataContext = vm };
+        var window = new Window { Content = card, Width = 500, Height = 260 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var edit = window.GetVisualDescendants().OfType<CopyableLinkTextBlock>()
+                .Single(t => t.Text == "✎");
+            await AssertMouseSelectAndCopyAsync(window, edit);
+            Assert.False(vm.IsEditMode);
+            edit.ClearSelection();
+            edit.Focus();
+            window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, "\r");
+            Assert.True(vm.IsEditMode);
+            await vm.Validation.UpdateAsync("{}");
+            vm.SaveEditModeCommand.RaiseCanExecuteChanged();
+            Dispatcher.UIThread.RunJobs();
+
+            var actions = window.GetVisualDescendants().OfType<CopyableLinkTextBlock>()
+                .Where(t => t.IsEffectivelyVisible && (t.Text is "💾" or "✖")).ToArray();
+            Assert.Equal(2, actions.Length);
+            foreach (var action in actions)
+            {
+                Assert.True(action.IsEffectivelyEnabled, $"Action {action.Text} is disabled");
+                await AssertMouseSelectAndCopyAsync(window, action);
+                Assert.True(vm.IsEditMode);
+            }
+
+            var discard = actions.Single(t => t.Text == "✖");
+            discard.ClearSelection();
+            discard.Focus();
+            window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, "\r");
+            Assert.False(vm.IsEditMode);
+            Assert.Equal(0, card.ActivationCount);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    private static void ClickText(Window window, SafeSelectableTextBlock item)
+    {
+        var origin = item.TranslatePoint(new Point(0, 0), window)!.Value;
+        var point = new Point(origin.X + Math.Min(2, item.Bounds.Width / 2),
+            origin.Y + Math.Min(8, item.Bounds.Height / 2));
+        window.MouseMove(point);
+        window.MouseDown(point, MouseButton.Left);
+        window.MouseUp(point, MouseButton.Left);
+    }
+
+    private static async Task AssertMouseSelectAndCopyAsync(Window window, SafeSelectableTextBlock item)
+    {
+        var origin = item.TranslatePoint(new Point(0, 0), window)!.Value;
+        var start = new Point(origin.X + 1, origin.Y + Math.Min(8, item.Bounds.Height / 2));
+        var end = new Point(origin.X + item.Bounds.Width + 2, start.Y);
+        window.MouseMove(start);
+        window.MouseDown(start, MouseButton.Left);
+        window.MouseMove(end, RawInputModifiers.LeftMouseButton);
+        window.MouseUp(end, MouseButton.Left);
+        Assert.NotEmpty(item.SelectedText);
+        item.Focus();
+        item.SelectAll();
+        window.KeyPress(Key.C, RawInputModifiers.Control, PhysicalKey.C, "c");
+        using var data = await window.Clipboard!.TryGetDataAsync();
+        Assert.NotNull(data);
+        Assert.Equal(item.Text, await data.TryGetTextAsync());
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_UnavailableReferences_AreMutedButStillCopyable()
+    {
+        const string id = "a1b2c3d4-e5f6-4123-8123-123456789abc";
+        var opened = 0;
+        var editors = new EntityFieldEditorViewModel[]
+        {
+            new EntityReferenceFieldEditorViewModel("unavailable-reference", id, Array.Empty<string>(), null),
+            new EntityReferenceFieldEditorViewModel("available-reference", id, Array.Empty<string>(), null, _ => opened++),
+            new EntityListFieldEditorViewModel("unavailable-list", new[] { id }, Array.Empty<string>(), null),
+            new EntityListFieldEditorViewModel("available-list", new[] { id }, Array.Empty<string>(), null, _ => opened++),
+        };
+        var window = new Window
+        {
+            Content = new EntityCardControl
+            {
+                DataContext = new EntityCardViewModel(
+                    new SubscribedEntityViewModel(BuildGitWorktreeSnapshotForTests()), editors),
+            },
+            Width = 600,
+            Height = 420,
+        };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var links = window.GetVisualDescendants().OfType<CopyableLinkTextBlock>()
+                .Where(link => link.Classes.Contains("workspace-entity-reference-link")).ToArray();
+            Assert.Equal(4, links.Length);
+            foreach (var link in links)
+            {
+                var available = link.DataContext switch
+                {
+                    EntityReferenceFieldEditorViewModel reference => reference.CanOpen,
+                    EntityReferenceListItemViewModel item => item.CanOpen,
+                    _ => throw new InvalidOperationException("Unexpected reference link context"),
+                };
+                Assert.Equal(available, link.Classes.Contains("available"));
+                Assert.True(link.IsEnabled);
+                Assert.Equal(available ? 1 : 0.65, link.Opacity);
+                Assert.Equal(available ? "Hand" : "Arrow", link.Cursor?.ToString());
+                Assert.Equal(available, link.TextDecorations is { Count: > 0 });
+                Assert.Equal(available, link.Command!.CanExecute(null));
+
+                if (!available)
+                {
+                    ClickText(window, link);
+                    link.Focus();
+                    window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, "\r");
+                    Assert.Equal(0, opened);
+                    await AssertMouseSelectAndCopyAsync(window, link);
+                    Assert.Equal(0, opened);
+                }
+            }
+            Assert.Equal(2, links.Count(link => link.Classes.Contains("available")));
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_EntityListLink_MouseCopiesAndClickOpens()
+    {
+        const string id = "a1b2c3d4-e5f6-4123-8123-123456789abc";
+        string? opened = null;
+        var editor = new EntityListFieldEditorViewModel(
+            "related", new[] { id }, Array.Empty<string>(), null, value => opened = value);
+        editor.Items[0].DisplayName = "Referenced worktree";
+        var card = new NavigationSpyCard
+        {
+            DataContext = new EntityCardViewModel(
+                new SubscribedEntityViewModel(BuildGitWorktreeSnapshotForTests()),
+                new EntityFieldEditorViewModel[] { editor }),
+        };
+        var window = new Window { Content = card, Width = 550, Height = 300 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var link = window.GetVisualDescendants().OfType<CopyableLinkTextBlock>()
+                .Single(t => t.Text == "Referenced worktree");
+            ClickText(window, link);
+            Assert.Equal(id, opened);
+            opened = null;
+            await AssertMouseSelectAndCopyAsync(window, link);
+            Assert.Null(opened);
+            Assert.Equal(0, card.ActivationCount);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_ArrayAndObjectHeaders_CopyWithoutTogglingExpanders()
+    {
+        var editors = new EntityFieldEditorViewModel[]
+        {
+            new ArrayFieldEditorViewModel("array-items", Array.Empty<EntityFieldEditorViewModel>()),
+            new ObjectFieldEditorViewModel("object-info", Array.Empty<EntityFieldEditorViewModel>()),
+        };
+        var card = new NavigationSpyCard
+        {
+            DataContext = new EntityCardViewModel(
+                new SubscribedEntityViewModel(BuildGitWorktreeSnapshotForTests()), editors),
+        };
+        var window = new Window { Content = card, Width = 500, Height = 350 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var expanders = window.GetVisualDescendants().OfType<Expander>()
+                .Where(e => e.Classes.Contains("workspace-field-expander")).ToArray();
+            Assert.Equal(2, expanders.Length);
+            foreach (var expander in expanders)
+            {
+                var label = expander.GetVisualDescendants().OfType<SafeSelectableTextBlock>()
+                    .Single(t => t.Text is "array-items" or "object-info");
+                await AssertMouseSelectAndCopyAsync(window, label);
+                Assert.False(expander.IsExpanded);
+            }
+            Assert.Equal(0, card.ActivationCount);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task EntityCardControl_MarkdownAttachment_HeaderAndRenderedContent_CopyWithMouse()
+    {
+        const string body = "Selectable markdown content";
+        var editor = new MarkdownMimeAttachmentFieldEditorViewModel(
+            "notes", "text/markdown", body, null);
+        var card = new NavigationSpyCard
+        {
+            DataContext = new EntityCardViewModel(
+                new SubscribedEntityViewModel(BuildGitWorktreeSnapshotForTests()),
+                new EntityFieldEditorViewModel[] { editor }),
+        };
+        var window = new Window { Content = card, Width = 600, Height = 420 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var expander = window.GetVisualDescendants().OfType<Expander>()
+                .Single(e => e.Classes.Contains("workspace-field-expander"));
+            var header = expander.GetVisualDescendants().OfType<SafeSelectableTextBlock>()
+                .Single(t => t.Text == "notes");
+            await AssertMouseSelectAndCopyAsync(window, header);
+            Assert.False(expander.IsExpanded);
+            expander.IsExpanded = true;
+            Dispatcher.UIThread.RunJobs();
+
+            var markdown = expander.GetVisualDescendants().OfType<WorkspaceMarkdownView>()
+                .Single(view => view.IsEffectivelyVisible && view.Markdown == body);
+            Assert.True(markdown.SelectionEnabled);
+            var text = markdown.GetVisualDescendants().OfType<Control>()
+                .First(t => t.GetType().Name == "CTextBlock" && t.Bounds.Width > 0);
+            var origin = text.TranslatePoint(new Point(0, 0), window)!.Value;
+            var start = new Point(origin.X + 2, origin.Y + Math.Min(8, text.Bounds.Height / 2));
+            var end = new Point(origin.X + text.Bounds.Width - 3, start.Y);
+            window.MouseMove(start);
+            window.MouseDown(start, MouseButton.Left);
+            window.MouseMove(end, RawInputModifiers.LeftMouseButton);
+            window.MouseUp(end, MouseButton.Left);
+            window.KeyPress(Key.C, RawInputModifiers.Control, PhysicalKey.C, "c");
+            using var data = await window.Clipboard!.TryGetDataAsync();
+            Assert.NotNull(data);
+            Assert.Equal(body, (await data.TryGetTextAsync())?.TrimEnd('\r', '\n'));
+            Assert.Equal(0, card.ActivationCount);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_ReferenceSearchCandidate_MouseCopiesAndClickSelects()
+    {
+        const string id = "a1b2c3d4-e5f6-4123-8123-123456789abc";
+        var editor = new EntityReferenceFieldEditorViewModel("related", null, Array.Empty<string>(),
+            new CandidateSearch(new EntityReferenceCandidate(id, "Candidate worktree", "worktrees")));
+        var vm = new EntityCardViewModel(
+            new SubscribedEntityViewModel(BuildGitWorktreeSnapshotForTests()),
+            new EntityFieldEditorViewModel[] { editor });
+        vm.IsEditMode = true;
+        editor.SearchText = "worktree";
+        await editor.SearchAsync();
+        var card = new NavigationSpyCard { DataContext = vm };
+        var window = new Window { Content = card, Width = 550, Height = 350 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var button = window.GetVisualDescendants().OfType<Button>()
+                .Single(b => b.Classes.Contains("workspace-entity-reference-candidate"));
+            var label = button.GetVisualDescendants().OfType<CopyableLinkTextBlock>()
+                .Single(t => t.Text == "Candidate worktree");
+            await AssertMouseSelectAndCopyAsync(window, label);
+            Assert.Equal(string.Empty, editor.Value);
+            label.ClearSelection();
+            label.Focus();
+            window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, "\r");
+            Assert.Equal(id, editor.Value);
+            Assert.Equal(0, card.ActivationCount);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    private sealed class CandidateSearch(EntityReferenceCandidate candidate) : IEntityReferenceSearch
+    {
+        public Task<IReadOnlyList<EntityReferenceCandidate>> SearchAsync(
+            string searchText, System.Collections.Generic.IReadOnlyCollection<string> entityTypes,
+            System.Threading.CancellationToken cancellationToken = default)
+            => Task.FromResult<IReadOnlyList<EntityReferenceCandidate>>(new[] { candidate });
+
+        public Task<EntityReferenceCandidate?> ResolveAsync(
+            string entityId, System.Threading.CancellationToken cancellationToken = default)
+            => Task.FromResult<EntityReferenceCandidate?>(candidate);
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_ReferenceLink_DragCopiesText_ClickNavigates()
+    {
+        const string id = "a1b2c3d4-e5f6-4123-8123-123456789abc";
+        string? opened = null;
+        var editor = new EntityReferenceFieldEditorViewModel("related", id, Array.Empty<string>(), null,
+            value => opened = value);
+        var entity = new SubscribedEntityViewModel(BuildGitWorktreeSnapshotForTests());
+        var card = new NavigationSpyCard
+        {
+            DataContext = new EntityCardViewModel(entity, new EntityFieldEditorViewModel[] { editor }),
+        };
+        var window = new Window { Content = card, Width = 500, Height = 300 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var link = window.GetVisualDescendants().OfType<CopyableLinkTextBlock>()
+                .Single(t => t.Classes.Contains("workspace-entity-reference-link"));
+            Assert.Equal(id, link.Text);
+            Assert.True(link.Command!.CanExecute(null));
+            var origin = link.TranslatePoint(new Point(0, 0), window)!.Value;
+            var point = new Point(origin.X + 2, origin.Y + link.Bounds.Height / 2);
+
+            window.MouseDown(point, MouseButton.Left);
+            window.MouseUp(point, MouseButton.Left);
+            Assert.Equal(id, opened);
+            Assert.Equal(0, card.ActivationCount);
+            opened = null;
+
+            window.MouseDown(point, MouseButton.Left);
+            window.MouseMove(new Point(point.X + link.Bounds.Width, point.Y), RawInputModifiers.LeftMouseButton);
+            window.MouseUp(new Point(point.X + link.Bounds.Width, point.Y), MouseButton.Left);
+            Assert.NotEmpty(link.SelectedText);
+            Assert.Null(opened);
+            link.SelectAll();
+            window.KeyPress(Key.C, RawInputModifiers.Control, PhysicalKey.C, "c");
+            using (var data = await window.Clipboard!.TryGetDataAsync())
+            {
+                Assert.NotNull(data);
+                Assert.Equal(id, await data.TryGetTextAsync());
+            }
+
+            Assert.Null(opened);
+            link.Focus();
+            window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, "\r");
+            Assert.Equal(id, opened);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_ExternalUrlAndKey_CanBeSelectedAndCopied()
+    {
+        const string url = "https://example.com/full/path?query=value";
+        using var document = JsonDocument.Parse(
+            """{"entity-id":"bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb","entity-types":["entity","external"],"names":[["externals","link"]],"display-name":{"default":"Link"},"urls":{"docs":"https://example.com/full/path?query=value"}}""");
+        var snapshot = new EntitySnapshot
+        {
+            EntityId = new EntityId(document.RootElement.GetProperty("entity-id").GetString()!),
+            ConcurrencyTag = new ConcurrencyTag("1"),
+            ModifiedTime = new Timestamp(DateTimeOffset.UtcNow, "1"),
+            Data = document.RootElement.Clone(),
+            Relationships = Array.Empty<EntitySnapshot>(),
+        };
+        var card = new NavigationSpyCard
+        {
+            DataContext = new EntityCardViewModel(new SubscribedEntityViewModel(snapshot), cardViewName: "external"),
+        };
+        var window = new Window { Content = card, Width = 220, Height = 300 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var link = window.GetVisualDescendants().OfType<CopyableLinkTextBlock>()
+                .Single(t => t.Classes.Contains("workspace-url-link"));
+            var key = window.GetVisualDescendants().OfType<SafeSelectableTextBlock>()
+                .Single(t => t.Text == "docs");
+            Assert.Equal(url, link.Text);
+            Assert.True(link.TextLayout.TextLines.Count > 1, "Long URLs must wrap without truncating the copied text.");
+            Assert.NotNull(link.Command);
+            var opened = 0;
+            // Replace the shell-launching command, not the rendered link, so activation is
+            // exercised without opening a real browser during the headless test.
+            link.Command = new RelayCommand(_ => opened++);
+            ClickText(window, link);
+            Assert.Equal(1, opened);
+            foreach (var item in new SafeSelectableTextBlock[] { key, link })
+            {
+                var origin = item.TranslatePoint(new Point(0, 0), window)!.Value;
+                var point = new Point(origin.X + 1, origin.Y + Math.Min(item.Bounds.Height / 2, 8));
+                window.MouseDown(point, MouseButton.Left);
+                window.MouseMove(new Point(point.X + item.Bounds.Width, point.Y), RawInputModifiers.LeftMouseButton);
+                window.MouseUp(new Point(point.X + item.Bounds.Width, point.Y), MouseButton.Left);
+                Assert.True(!string.IsNullOrEmpty(item.SelectedText),
+                    $"Could not select {item.Text} at {point} (bounds {item.Bounds}).");
+                item.SelectAll();
+                window.KeyPress(Key.C, RawInputModifiers.Control, PhysicalKey.C, "c");
+                using var data = await window.Clipboard!.TryGetDataAsync();
+                Assert.NotNull(data);
+                Assert.Equal(item.Text, await data.TryGetTextAsync());
+            }
+            Assert.Equal(1, opened);
+            Assert.Equal(0, card.ActivationCount);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_MimeExpanderHeaderAndUrl_CopyWithoutOpeningOrCollapsing()
+    {
+        const string url = "https://example.com/attachment/full/path";
+        var entity = new SubscribedEntityViewModel(BuildGitWorktreeSnapshotForTests());
+        var editor = new PlainMimeAttachmentFieldEditorViewModel(
+            "attachment", "text/plain", "body", url);
+        var card = new NavigationSpyCard
+        {
+            DataContext = new EntityCardViewModel(entity, new EntityFieldEditorViewModel[] { editor }),
+        };
+        var window = new Window { Content = card, Width = 600, Height = 400 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var expander = window.GetVisualDescendants().OfType<Expander>()
+                .Single(e => e.Classes.Contains("workspace-field-expander"));
+            expander.IsExpanded = true;
+            Dispatcher.UIThread.RunJobs();
+            var values = window.GetVisualDescendants().OfType<SafeSelectableTextBlock>().ToArray();
+            var header = Assert.Single(values, t => t.Text == "attachment");
+            var urlText = Assert.Single(values, t => t.Text == url);
+            foreach (var item in new[] { header, urlText })
+            {
+                var origin = item.TranslatePoint(new Point(0, 0), window)!.Value;
+                var point = new Point(origin.X + 1, origin.Y + item.Bounds.Height / 2);
+                window.MouseDown(point, MouseButton.Left);
+                window.MouseMove(new Point(point.X + item.Bounds.Width, point.Y), RawInputModifiers.LeftMouseButton);
+                window.MouseUp(new Point(point.X + item.Bounds.Width, point.Y), MouseButton.Left);
+                Assert.NotEmpty(item.SelectedText);
+                item.SelectAll();
+                window.KeyPress(Key.C, RawInputModifiers.Control, PhysicalKey.C, "c");
+                using var data = await window.Clipboard!.TryGetDataAsync();
+                Assert.NotNull(data);
+                Assert.Equal(item.Text, await data.TryGetTextAsync());
+            }
+            Assert.True(expander.IsExpanded);
+            Assert.Equal(0, card.ActivationCount);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact(Timeout = 15_000)]
+    public async Task EntityCardControl_StatusBadge_MouseSelectionAndCtrlC_CopiesStatus()
+    {
+        var vm = new EntityCardViewModel(displayName: "Task", entityType: "task");
+        var badges = new StatusBadgesModel();
+        badges.SetBadges(new[] { new StatusBadgeModel("completed", "Theme.Status.Good", "status: completed") });
+        vm.SetStatusBadges(new StatusBadgesViewModel(badges));
+        var card = new NavigationSpyCard { DataContext = vm };
+        var window = new Window { Content = card, Width = 400, Height = 200 };
+        try
+        {
+            window.Show();
+            Dispatcher.UIThread.RunJobs();
+            var badge = window.GetVisualDescendants().OfType<SafeSelectableTextBlock>()
+                .Single(t => t.Classes.Contains("status-badge-text"));
+            var origin = badge.TranslatePoint(new Point(0, 0), window)!.Value;
+            var point = new Point(origin.X + 1, origin.Y + badge.Bounds.Height / 2);
+            window.MouseDown(point, MouseButton.Left);
+            window.MouseMove(new Point(point.X + badge.Bounds.Width, point.Y), RawInputModifiers.LeftMouseButton);
+            window.MouseUp(new Point(point.X + badge.Bounds.Width, point.Y), MouseButton.Left);
+            Assert.NotEmpty(badge.SelectedText);
+            badge.SelectAll();
+            window.KeyPress(Key.C, RawInputModifiers.Control, PhysicalKey.C, "c");
+            using var data = await window.Clipboard!.TryGetDataAsync();
+            Assert.NotNull(data);
+            Assert.Equal("completed", await data.TryGetTextAsync());
+            Assert.Equal(0, card.ActivationCount);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
     // Issue #1214: regression guard for #1006/#1177 — header-row selectable text blocks still wrap
     // (word-level, not character-clipped) when the row is constrained narrow after the swap to
     // SafeSelectableTextBlock.
diff --git a/Phantom.Workspaces.Tests/EntityCardViewModelTests.cs b/Phantom.Workspaces.Tests/EntityCardViewModelTests.cs
index 6ec90a2a..05121673 100644
--- a/Phantom.Workspaces.Tests/EntityCardViewModelTests.cs
+++ b/Phantom.Workspaces.Tests/EntityCardViewModelTests.cs
@@ -12,6 +12,60 @@ namespace Phantom.Workspaces.Tests;
 
 public sealed class EntityCardViewModelTests : IAsyncDisposable
 {
+    [AvaloniaFact]
+    public async Task EntityCardViewModel_ExternalAndNote_SnapshotUpdateRefreshesLinksAndContent()
+    {
+        var broker = await EntityBroker.CreateInitializedAsync(
+            new UnknownRepositorySource(), TestContext.Current.CancellationToken);
+        var catalog = await EntityTypeViewCatalog.CreateAsync(broker);
+        var entity = new SubscribedEntityViewModel(ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot());
+        var card = new EntityCardViewModel(entity,
+            fieldEditorFactory: new FieldEditorFactory(broker, catalog),
+            autoResolveCardView: true);
+        Assert.Empty(card.FieldEditors);
+        card.EnsureFieldEditorsBuilt();
+        await card.FieldEditorsBuildTask;
+        Assert.Equal("content", Assert.Single(card.FieldEditors).FieldName);
+
+        entity.UpdateSnapshot(ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot(
+            url: "https://example.com/second", body: "# Second note"));
+        await card.FieldEditorsBuildTask;
+
+        Assert.Equal("external-note", card.CardViewName);
+        Assert.True(card.ShowFieldEditors);
+        Assert.Equal("https://example.com/second", Assert.Single(card.ExternalCard!.Urls).Url);
+        var editor = Assert.IsType<LocalizedMimeAttachmentFieldEditorViewModel>(Assert.Single(card.FieldEditors));
+        Assert.Equal("# Second note",
+            Assert.IsType<MarkdownMimeAttachmentFieldEditorViewModel>(editor.ActiveEditor).TextContent);
+
+        entity.UpdateSnapshot(ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot(
+            types: "\"entity\", \"note\""));
+        await card.FieldEditorsBuildTask;
+        Assert.Equal("raw", card.CardViewName);
+        Assert.Null(card.ExternalCard);
+        Assert.True(card.ShowFieldEditors);
+
+        entity.UpdateSnapshot(ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot());
+        await card.FieldEditorsBuildTask;
+        Assert.Equal("external-note", card.CardViewName);
+        Assert.NotNull(card.ExternalCard);
+        Assert.Equal("content", Assert.Single(card.FieldEditors).FieldName);
+    }
+
+    [AvaloniaFact]
+    public void EntityCardViewModel_ExplicitRaw_RemainsRawAfterTypeChange()
+    {
+        var entity = new SubscribedEntityViewModel(
+            ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot(
+                types: "\"entity\", \"note\""));
+        var card = new EntityCardViewModel(entity, cardViewName: EntityCardViewResolver.RawViewName);
+
+        entity.UpdateSnapshot(ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot());
+
+        Assert.Equal(EntityCardViewResolver.RawViewName, card.CardViewName);
+        Assert.Null(card.ExternalCard);
+    }
+
     private readonly MainWindowViewModel mainWindowViewModel;
 
     public EntityCardViewModelTests()
diff --git a/Phantom.Workspaces.Tests/EntityTreePanelTests.cs b/Phantom.Workspaces.Tests/EntityTreePanelTests.cs
new file mode 100644
index 00000000..a1fcc82b
--- /dev/null
+++ b/Phantom.Workspaces.Tests/EntityTreePanelTests.cs
@@ -0,0 +1,475 @@
+using System.Collections.ObjectModel;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Data;
+using Avalonia.Headless.XUnit;
+using Avalonia.VisualTree;
+using Avalonia.Input;
+using Phantom.Workspaces.Data;
+using Phantom.Workspaces.Controls;
+using Phantom.Workspaces.Testing.Gui;
+using Phantom.Workspaces.ViewModels;
+
+namespace Phantom.Workspaces.Tests;
+
+public sealed class EntityTreePanelTests
+{
+    [AvaloniaTheory]
+    [InlineData(0, false)]
+    [InlineData(1, false)]
+    [InlineData(99, false)]
+    [InlineData(100, true)]
+    [InlineData(1000, true)]
+    public void EntityCardTreeView_WhenBoundToPopulation_UsesPanelForCompleteNodeCount(int count, bool virtualized)
+    {
+        var list = new EntityListViewModel();
+        for (int i = 0; i < count; i++)
+        {
+            var node = new EntityListNodeViewModel($"Node {i}", "entity", [$"node-{i}"], $"node-{i}");
+            list.Items.Add(new EntityListItemViewModel(node, i, 0, $"node-{i}"));
+        }
+
+        var tree = CreateTree(list.Items);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Items.Count") { Source = list });
+        var window = new Window { Content = tree, Width = 400, Height = 320 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.Equal(virtualized, tree.ItemsPanelRoot is VirtualizingStackPanel);
+            if (!virtualized)
+            {
+                Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+            }
+            else if (count == 1000)
+            {
+                Assert.True(tree.ItemsPanelRoot!.Children.Count < count / 2);
+            }
+            Assert.Single(tree.GetVisualDescendants().OfType<ScrollViewer>());
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void EntityCardTreeView_WhenNestedViewHasHundredNodes_UsesVirtualizingPanel()
+    {
+        var roots = new ObservableCollection<TreeNode>([new TreeNode("First"), new TreeNode("Second")]);
+        var nodes = new ObservableCollection<TreeNode>(roots);
+        for (int i = 0; i < 98; i++)
+        {
+            var child = new TreeNode($"Child {i}");
+            roots[0].Children.Add(child);
+            nodes.Add(child);
+        }
+        var tree = CreateTree(roots);
+        tree.ItemTemplate = new Avalonia.Controls.Templates.FuncTreeDataTemplate<TreeNode>(
+            (node, _) => new TextBlock { Text = node.Name, Height = 34 },
+            node => node.Children);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Count") { Source = nodes });
+        var window = new Window { Content = tree, Width = 400, Height = 320 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.Equal(2, roots.Count);
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+            Assert.False(Assert.IsType<TreeViewItem>(tree.ContainerFromIndex(0)).IsExpanded);
+            Assert.Equal(100, nodes.Count);
+            roots[0].Children.RemoveAt(97);
+            nodes.RemoveAt(99);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaTheory]
+    [InlineData(99)]
+    [InlineData(100)]
+    public void EntityCardTreeView_BothPanelsRetainNarrowViewportHorizontalScroll(int count)
+    {
+        var nodes = new ObservableCollection<string>(Enumerable.Range(0, count).Select(i => $"Node {i}"));
+        var tree = CreateTree(nodes);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Count") { Source = nodes });
+        var window = new Window { Content = tree, Width = 120, Height = 320 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var panel = Assert.IsAssignableFrom<Panel>(tree.ItemsPanelRoot);
+            var scroll = Assert.Single(tree.GetVisualDescendants().OfType<ScrollViewer>());
+            Assert.Equal(160, panel.MinWidth);
+            Assert.True(scroll.Extent.Width >= 160);
+            Assert.True(scroll.Viewport.Width < 160);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaTheory]
+    [InlineData("entity-card-tree")]
+    [InlineData("entity-card-tree-view")]
+    public void OtherSharedTreeConsumers_WithoutNodeCount_KeepVirtualization(string styleClass)
+    {
+        var tree = new TreeView { ItemsSource = new[] { "item" } };
+        tree.Classes.Add(styleClass);
+        var window = new Window { Content = tree, Width = 400, Height = 320 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void EntityCardTreeView_WhenPopulationCrossesThreshold_PreservesSelectionExpansionFocusAndScroll()
+    {
+        var nodes = new ObservableCollection<TreeNode>(
+            Enumerable.Range(0, 99).Select(i => new TreeNode($"Node {i}")));
+        nodes[0].Children.Add(new TreeNode("Child"));
+        var tree = CreateTree(nodes);
+        tree.ItemTemplate = new Avalonia.Controls.Templates.FuncTreeDataTemplate<TreeNode>(
+            (node, _) => new TextBlock { Text = node.Name, Height = 34 },
+            node => node.Children);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Count") { Source = nodes });
+        var window = new Window { Content = tree, Width = 400, Height = 320 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var first = Assert.IsType<TreeViewItem>(tree.ContainerFromIndex(0));
+            first.IsExpanded = true;
+            tree.SelectedItem = nodes[0];
+            Assert.IsType<TreeViewItem>(tree.ContainerFromIndex(3)).Focus();
+            var scroll = Assert.Single(tree.GetVisualDescendants().OfType<ScrollViewer>());
+            scroll.Offset = new Vector(0, 48);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var offset = scroll.Offset.Y;
+            nodes.Add(new TreeNode("Node 99"));
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+            Assert.Same(nodes[0], tree.SelectedItem);
+            Assert.True(Assert.IsType<TreeViewItem>(tree.ContainerFromIndex(0)).IsExpanded);
+            Assert.Equal(offset, scroll.Offset.Y, 1);
+            Assert.True(Assert.IsType<TreeViewItem>(tree.ContainerFromIndex(3)).IsFocused);
+
+            nodes.RemoveAt(99);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+            Assert.Same(nodes[0], tree.SelectedItem);
+            Assert.True(Assert.IsType<TreeViewItem>(tree.ContainerFromIndex(0)).IsExpanded);
+            Assert.Equal(offset, scroll.Offset.Y, 1);
+            Assert.True(Assert.IsType<TreeViewItem>(tree.ContainerFromIndex(3)).IsFocused);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void EntityCardTreeView_InsertAndRemoveBeforeViewport_PreserveVisibleObjectAtVariableHeights()
+    {
+        var nodes = new ObservableCollection<TreeNode>(
+            Enumerable.Range(0, 99).Select(i => new TreeNode($"Node {i}")));
+        var tree = CreateTree(nodes);
+        tree.ItemTemplate = new Avalonia.Controls.Templates.FuncTreeDataTemplate<TreeNode>(
+            (node, _) => new TextBlock { Text = node.Name, Height = node.Height },
+            node => node.Children);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Count") { Source = nodes });
+        var window = new Window { Content = tree, Width = 400, Height = 240 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var scroll = Assert.Single(tree.GetVisualDescendants().OfType<ScrollViewer>());
+            scroll.Offset = new Vector(0, 410);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var anchor = Assert.IsType<TreeViewItem>(tree.ContainerFromItem(nodes[7]));
+            var before = Assert.NotNull(anchor.TranslatePoint(default, scroll)).Y;
+
+            var inserted = new TreeNode("Tall item") { Height = 91 };
+            nodes.Insert(3, inserted);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+            Assert.Equal(before, Assert.NotNull(
+                Assert.IsType<TreeViewItem>(tree.ContainerFromItem(anchor.DataContext!))
+                    .TranslatePoint(default, scroll)).Y, 1);
+
+            nodes.Remove(inserted);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+            Assert.Equal(before, Assert.NotNull(
+                Assert.IsType<TreeViewItem>(tree.ContainerFromItem(anchor.DataContext!))
+                    .TranslatePoint(default, scroll)).Y, 1);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void EntityCardTreeView_ThresholdChangesBeforeLoaded_PreserveVisibleAnchorAndEditorFocus()
+    {
+        var nodes = new ObservableCollection<TreeNode>(
+            Enumerable.Range(0, 99).Select(i => new TreeNode($"Node {i}")));
+        var inserted = new TreeNode("Tall item") { Height = 91 };
+        nodes.Insert(3, inserted);
+        var tree = CreateTree(nodes);
+        tree.ItemTemplate = new Avalonia.Controls.Templates.FuncTreeDataTemplate<TreeNode>(
+            (node, _) => new TextBox { Text = node.Name, Height = node.Height },
+            node => node.Children);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Count") { Source = nodes });
+        var window = new Window { Content = tree, Width = 400, Height = 240 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var scroll = tree.GetVisualDescendants().OfType<ScrollViewer>().First();
+            var focusedNode = nodes[30];
+
+            void AssertImmediateTransition(Action change, Type expectedPanel)
+            {
+                var original = Assert.IsType<TreeViewItem>(tree.ContainerFromItem(focusedNode));
+                var editor = Assert.Single(original.GetVisualDescendants().OfType<TextBox>());
+                Assert.True(editor.Focus());
+                var screenY = Assert.NotNull(original.TranslatePoint(default, window)).Y;
+                Assert.InRange(screenY, 0, window.Bounds.Height);
+                bool loadedCallbackRan = false;
+                Avalonia.Threading.Dispatcher.UIThread.Post(
+                    () => loadedCallbackRan = true, Avalonia.Threading.DispatcherPriority.Loaded);
+
+                change();
+                // Offset invalidation from the panel swap can require a second synchronous
+                // layout pass; neither pass may rely on the queued Loaded restoration.
+                tree.UpdateLayout();
+                tree.UpdateLayout();
+                Assert.False(loadedCallbackRan);
+                Assert.IsType(expectedPanel, tree.ItemsPanelRoot);
+                var replacement = Assert.IsType<TreeViewItem>(tree.ContainerFromItem(focusedNode));
+                Assert.Equal(screenY, Assert.NotNull(replacement.TranslatePoint(default, window)).Y, 1);
+                Assert.True(Assert.Single(replacement.GetVisualDescendants().OfType<TextBox>()).IsFocused);
+            }
+
+            tree.ScrollIntoView(focusedNode);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var initialY = Assert.NotNull(
+                Assert.IsType<TreeViewItem>(tree.ContainerFromItem(focusedNode))
+                    .TranslatePoint(default, window)).Y;
+            scroll.Offset = new Vector(0, scroll.Offset.Y + initialY - 40);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            AssertImmediateTransition(() => nodes.Remove(inserted), typeof(StackPanel));
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            AssertImmediateTransition(() => nodes.Insert(3, inserted), typeof(VirtualizingStackPanel));
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void EntityCardTreeView_NestedEditorFocus_SurvivesBothPanelTransitions()
+    {
+        var nodes = new ObservableCollection<TreeNode>(
+            Enumerable.Range(0, 99).Select(i => new TreeNode($"Node {i}")));
+        var child = new TreeNode("Nested");
+        nodes[0].Children.Add(child);
+        var tree = CreateTree(nodes);
+        tree.ItemTemplate = new Avalonia.Controls.Templates.FuncTreeDataTemplate<TreeNode>(
+            (node, _) => new Button { Name = "Editor", Content = node.Name, Height = 34 },
+            node => node.Children);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Count") { Source = nodes });
+        var window = new Window { Content = tree, Width = 400, Height = 240 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<TreeViewItem>(tree.ContainerFromIndex(0)).IsExpanded = true;
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var editor = tree.GetVisualDescendants().OfType<Button>()
+                .Single(button => Equals(button.Content, "Nested"));
+            editor.Focus();
+            Assert.True(editor.IsFocused);
+
+            nodes.Add(new TreeNode("Node 99"));
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.True(tree.GetVisualDescendants().OfType<Button>()
+                .Single(button => Equals(button.Content, "Nested")).IsFocused);
+            nodes.RemoveAt(99);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.True(tree.GetVisualDescendants().OfType<Button>()
+                .Single(button => Equals(button.Content, "Nested")).IsFocused);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void EntityCardTreeView_RapidThresholdReversals_DoNotRestoreStaleAnchorOrFocus()
+    {
+        var nodes = new ObservableCollection<TreeNode>(
+            Enumerable.Range(0, 99).Select(i => new TreeNode($"Node {i}")));
+        var tree = CreateTree(nodes);
+        tree.ItemTemplate = new Avalonia.Controls.Templates.FuncTreeDataTemplate<TreeNode>(
+            (node, _) => new Button { Content = node.Name, Height = 34 },
+            node => node.Children);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Count") { Source = nodes });
+        var window = new Window { Content = tree, Width = 400, Height = 240 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var scroll = Assert.Single(tree.GetVisualDescendants().OfType<ScrollViewer>());
+            scroll.Offset = new Vector(0, 500);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var original = new TreeNode("First insertion") { Height = 91 };
+            nodes.Insert(2, original);
+            nodes.Remove(original);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+
+            scroll.Offset = new Vector(0, 1200);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var focused = tree.GetVisualDescendants().OfType<Button>()
+                .First(button => Equals(button.Content, "Node 20"));
+            focused.Focus();
+            var before = Assert.NotNull(
+                Assert.IsType<TreeViewItem>(tree.ContainerFromItem(nodes[20]))
+                    .TranslatePoint(default, scroll)).Y;
+            nodes.Insert(2, new TreeNode("Second insertion") { Height = 91 });
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+            Assert.Equal(before, Assert.NotNull(
+                Assert.IsType<TreeViewItem>(tree.ContainerFromItem(nodes[21]))
+                    .TranslatePoint(default, scroll)).Y, 1);
+            Assert.True(tree.GetVisualDescendants().OfType<Button>()
+                .Single(button => Equals(button.Content, "Node 20")).IsFocused);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void EntityCardTreeView_UnrealizedFocusedItemWithVisibleAnchor_RestoresFocusedControl()
+    {
+        var nodes = new ObservableCollection<TreeNode>(
+            Enumerable.Range(0, 99).Select(i => new TreeNode($"Node {i}")));
+        var tree = CreateTree(nodes);
+        tree.ItemTemplate = new Avalonia.Controls.Templates.FuncTreeDataTemplate<TreeNode>(
+            (node, _) => new TextBox { Text = node.Name, Height = 34 },
+            node => node.Children);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Count") { Source = nodes });
+        var window = new Window { Content = tree, Width = 400, Height = 240 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var focused = tree.GetVisualDescendants().OfType<TextBox>()
+                .Single(box => box.Text == "Node 80");
+            focused.Focus();
+            Assert.True(focused.IsFocused);
+            var scroll = tree.GetVisualDescendants().OfType<ScrollViewer>().First();
+            scroll.Offset = default;
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.True(focused.IsFocused);
+
+            nodes.Add(new TreeNode("Node 99"));
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+            Assert.Contains(tree.GetVisualDescendants().OfType<TextBox>(),
+                box => box.Text == "Node 80" && box.IsFocused);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void EntityCardTreeView_RealCardFieldEditor_RetainsSemanticTextBoxFocusAcrossThreshold()
+    {
+        using var doc = System.Text.Json.JsonDocument.Parse("""{"display-name":"Card","entity-types":["entity"]}""");
+        var entity = new SubscribedEntityViewModel(new EntitySnapshot
+        {
+            EntityId = new EntityId(Guid.NewGuid().ToString()),
+            ModifiedTime = new Timestamp(DateTimeOffset.UtcNow, "1"),
+            Data = doc.RootElement.Clone(),
+            Relationships = [],
+        });
+        var field = new StringFieldEditorViewModel("path", "editable value");
+        var card = new EntityCardViewModel(entity, [field]);
+        card.EnterEditMode();
+        var nodes = new ObservableCollection<CardNode>(
+            Enumerable.Range(0, 99).Select(i => new CardNode($"Node {i}", i == 0 ? card : null)));
+        var tree = CreateTree(nodes);
+        tree.ItemTemplate = new Avalonia.Controls.Templates.FuncTreeDataTemplate<CardNode>(
+            (node, _) => node.Card is null
+                ? new TextBlock { Text = node.Name, Height = 34 }
+                : new EntityCardControl { DataContext = node.Card },
+            node => node.Children);
+        tree.Bind(EntityTreePanel.NodeCountProperty, new Binding("Count") { Source = nodes });
+        var window = new Window { Content = tree, Width = 400, Height = 320 };
+        try
+        {
+            window.Show();
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var editor = tree.GetVisualDescendants().OfType<TextBox>()
+                .Single(box => ReferenceEquals(box.DataContext, field));
+            Assert.True(editor.Focus());
+            Assert.True(editor.IsFocused);
+            nodes.Add(new CardNode("Node 99", null));
+            card.SetFieldEditors([new StringFieldEditorViewModel("new field", "other"), field]);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.True(tree.GetVisualDescendants().OfType<TextBox>()
+                .Single(box => ReferenceEquals(box.DataContext, field)).IsFocused);
+            nodes.RemoveAt(99);
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.True(tree.GetVisualDescendants().OfType<TextBox>()
+                .Single(box => ReferenceEquals(box.DataContext, field)).IsFocused);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    private static TreeView CreateTree(System.Collections.IEnumerable items)
+    {
+        var tree = new TreeView { ItemsSource = items };
+        tree.Classes.Add("entity-card-tree");
+        return tree;
+    }
+
+    private sealed class TreeNode(string name)
+    {
+        public string Name { get; } = name;
+        public double Height { get; init; } = 34;
+        public ObservableCollection<TreeNode> Children { get; } = [];
+    }
+
+    private sealed class CardNode(string name, EntityCardViewModel? card)
+    {
+        public string Name { get; } = name;
+        public EntityCardViewModel? Card { get; } = card;
+        public ObservableCollection<CardNode> Children { get; } = [];
+    }
+}
diff --git a/Phantom.Workspaces.Tests/EntityWorkspaceTabViewModelTests.cs b/Phantom.Workspaces.Tests/EntityWorkspaceTabViewModelTests.cs
index 5d6d324a..5bf731f5 100644
--- a/Phantom.Workspaces.Tests/EntityWorkspaceTabViewModelTests.cs
+++ b/Phantom.Workspaces.Tests/EntityWorkspaceTabViewModelTests.cs
@@ -1,8 +1,14 @@
 using System;
+using System.Linq;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Avalonia.Controls;
 using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using Phantom.Workspaces.Controls;
 using Phantom.Workspaces.Data;
+using Phantom.Workspaces.Gui.Shared.Controls;
 using Phantom.Workspaces.ViewModels;
 
 namespace Phantom.Workspaces.Tests;
@@ -40,6 +46,111 @@ public void EntityWorkspaceTabViewModel_SingleEntityCard_ShowsShortcuts()
         Assert.NotNull(cardNode.Card.ActivateShortcutCommand);
     }
 
+    [AvaloniaFact]
+    public void EntityWorkspaceTabViewModel_ExternalAndNote_OpenAndReopenShowsBoth()
+    {
+        var entity = new SubscribedEntityViewModel(ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot());
+        EntityWorkspaceTabViewModel Open() => new()
+        {
+            Id = "mixed",
+            Title = "Mixed",
+            Entity = entity,
+        };
+
+        var first = Open().EntityCardNode!.Card;
+        Assert.Equal("external-note", first.CardViewName);
+        Assert.True(first.ShowFieldEditors);
+        Assert.Equal("https://example.com/first", Assert.Single(first.ExternalCard!.Urls).Url);
+        Assert.Empty(first.FieldEditors);
+
+        var reopened = Open().EntityCardNode!.Card;
+        Assert.Equal("external-note", reopened.CardViewName);
+        Assert.NotNull(reopened.ExternalCard);
+        Assert.True(reopened.ShowFieldEditors);
+
+        entity.UpdateSnapshot(ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot(types: "\"entity\", \"external\""));
+        Assert.Equal("external", first.CardViewName);
+        Assert.False(first.ShowFieldEditors);
+        Assert.Equal("external", Open().EntityCardNode!.Card.CardViewName);
+
+        entity.UpdateSnapshot(ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot(types: "\"entity\", \"note\""));
+        Assert.Equal("raw", first.CardViewName);
+        Assert.Null(first.ExternalCard);
+        Assert.Equal("raw", Open().EntityCardNode!.Card.CardViewName);
+    }
+
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task EntityWorkspaceTabViewModel_ExternalAndNote_OpenAndReopenRendersLinksAndMarkdown()
+    {
+        var broker = await EntityBroker.CreateInitializedAsync(
+            new UnknownRepositorySource(), TestContext.Current.CancellationToken);
+        var catalog = await EntityTypeViewCatalog.CreateAsync(broker);
+        var entity = new SubscribedEntityViewModel(
+            ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot());
+
+        EntityWorkspaceTabViewModel Open() => new(broker, catalog)
+        {
+            Id = "mixed",
+            Title = "Mixed",
+            Entity = entity,
+        };
+
+        static void AssertRendered(Window window, EntityCardViewModel card, string url, string markdown)
+        {
+            Assert.Same(card, Assert.Single(window.GetVisualDescendants()
+                .OfType<EntityCardControl>()).DataContext);
+            Assert.Equal("content", Assert.Single(card.FieldEditors).FieldName);
+            var link = Assert.Single(window.GetVisualDescendants().OfType<CopyableLinkTextBlock>(),
+                item => item.Classes.Contains("workspace-url-link"));
+            Assert.Equal(url, link.Text);
+            Assert.NotNull(link.Command);
+            Assert.Equal(markdown, Assert.Single(
+                window.GetVisualDescendants().OfType<WorkspaceMarkdownView>()).Markdown);
+            Assert.DoesNotContain(window.GetVisualDescendants().OfType<TextBlock>(),
+                block => block.Text?.Contains("must never appear", StringComparison.Ordinal) == true);
+        }
+
+        var firstTab = Open();
+        var firstCard = firstTab.EntityCardNode!.Card;
+        Assert.Empty(firstCard.FieldEditors);
+        var firstWindow = new Window { Content = firstTab, Width = 900, Height = 600 };
+        try
+        {
+            firstWindow.Show();
+            Dispatcher.UIThread.RunJobs();
+            await firstCard.FieldEditorsBuildTask;
+            Dispatcher.UIThread.RunJobs();
+            AssertRendered(firstWindow, firstCard, "https://example.com/first", "# First note");
+
+            entity.UpdateSnapshot(ExternalEntityCardViewModelTests.MixedExternalNoteTestData.CreateSnapshot(
+                url: "https://example.com/second", body: "# Second note"));
+            await firstCard.FieldEditorsBuildTask;
+            Dispatcher.UIThread.RunJobs();
+            AssertRendered(firstWindow, firstCard, "https://example.com/second", "# Second note");
+        }
+        finally
+        {
+            firstWindow.Close();
+        }
+
+        var reopenedTab = Open();
+        var reopenedCard = reopenedTab.EntityCardNode!.Card;
+        Assert.Empty(reopenedCard.FieldEditors);
+        var reopenedWindow = new Window { Content = reopenedTab, Width = 900, Height = 600 };
+        try
+        {
+            reopenedWindow.Show();
+            Dispatcher.UIThread.RunJobs();
+            await reopenedCard.FieldEditorsBuildTask;
+            Dispatcher.UIThread.RunJobs();
+            AssertRendered(reopenedWindow, reopenedCard, "https://example.com/second", "# Second note");
+        }
+        finally
+        {
+            reopenedWindow.Close();
+        }
+    }
+
     private static SubscribedEntityViewModel CreateEntity(string entityType)
     {
         using var document = JsonDocument.Parse(
diff --git a/Phantom.Workspaces.Tests/ExternalEntityCardViewModelTests.cs b/Phantom.Workspaces.Tests/ExternalEntityCardViewModelTests.cs
index ea346041..4562d2a8 100644
--- a/Phantom.Workspaces.Tests/ExternalEntityCardViewModelTests.cs
+++ b/Phantom.Workspaces.Tests/ExternalEntityCardViewModelTests.cs
@@ -1,9 +1,20 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Headless;
 using Avalonia.Headless.XUnit;
+using Avalonia.Input;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
 using Phantom.Workspaces.Data;
+using Phantom.Workspaces.Services;
 using Phantom.Workspaces.ViewModels;
+using Phantom.Workspaces.Gui.Shared.Controls;
 
 using Phantom.Workspaces.Testing.Gui;
 
@@ -11,6 +22,350 @@ namespace Phantom.Workspaces.Tests;
 
 public sealed class ExternalEntityCardViewModelTests
 {
+    private sealed class RecordingOpener : IUrlOpener
+    {
+        public List<OpenUrlRequest> Requests { get; } = new();
+        public bool Fail { get; set; }
+
+        public Task OpenAsync(OpenUrlRequest request, CancellationToken cancellationToken = default)
+        {
+            if (this.Fail)
+            {
+                throw new InvalidOperationException("Cannot launch");
+            }
+
+            this.Requests.Add(request);
+            return Task.CompletedTask;
+        }
+    }
+
+    private sealed class RecordingTabService : IWorkspaceTabService
+    {
+        public List<WorkspaceTabViewModel> OpenedTabs { get; } = new();
+        public List<string> FocusAttempts { get; } = new();
+
+        public Task OpenTabAsync(WorkspaceTabViewModel tab, string? insertAfterTabId = null,
+            bool focus = true, string? workspacePaneId = null)
+        {
+            this.OpenedTabs.Add(tab);
+            return Task.CompletedTask;
+        }
+
+        public Task<bool> TryFocusExistingWebTabAsync(string url)
+        {
+            this.FocusAttempts.Add(url);
+            return Task.FromResult(this.OpenedTabs.OfType<WebViewModel>().Any(tab => tab.AddressBarUrl == url));
+        }
+
+        public Task ReplaceTabAsync(WorkspaceTabViewModel oldTab, WorkspaceTabViewModel newTab) => Task.CompletedTask;
+        public void CloseTab(WorkspaceTabViewModel tab) { }
+    }
+
+    private static async Task ClickAsync(ExternalUrlViewModel url)
+    {
+        url.OpenCommand.Execute(null);
+        await url.OpenCommand.LastExecutionTask!;
+    }
+
+    [AvaloniaFact]
+    public async Task ExternalEntityCardViewModel_DefaultHttpUrl_OpensEmbeddedWebTab()
+    {
+        var tabs = new RecordingTabService();
+        var external = new List<string>();
+        var opener = new UrlOpener(tabs, url => { external.Add(url); return Task.CompletedTask; });
+        var card = ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity("""{ "default": "http://example.com" }""")),
+            () => opener);
+
+        var link = Assert.Single(card.Urls);
+        Assert.False(link.ShowKey);
+        await ClickAsync(link);
+
+        Assert.Single(tabs.OpenedTabs);
+        Assert.IsType<WebViewModel>(tabs.OpenedTabs[0]);
+        Assert.Empty(external);
+    }
+
+    [AvaloniaFact]
+    public async Task ExternalEntityCardViewModel_OpenerRegisteredAfterCardCreation_OpensUrl()
+    {
+        IUrlOpener? registeredOpener = null;
+        var link = Assert.Single(ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity("""{ "default": "https://example.com" }""")),
+            () => registeredOpener).Urls);
+        var opener = new RecordingOpener();
+        registeredOpener = opener;
+
+        await ClickAsync(link);
+
+        Assert.Equal("https://example.com", Assert.Single(opener.Requests).Url);
+    }
+
+    [AvaloniaFact]
+    public async Task ExternalEntityCardViewModel_NamedHttpsUrls_OpenEmbeddedWebTabs()
+    {
+        var opener = new RecordingOpener();
+        var card = ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity(
+                """{ "default": "https://example.com", "docs": "https://example.com/docs" }""")),
+            () => opener);
+
+        foreach (var link in card.Urls)
+        {
+            Assert.True(link.ShowKey);
+            await ClickAsync(link);
+        }
+
+        Assert.Equal(new[] { "https://example.com", "https://example.com/docs" },
+            opener.Requests.Select(request => request.Url));
+        Assert.All(opener.Requests, request => Assert.Equal(UrlOpenPreference.Auto, request.Preference));
+    }
+
+    [AvaloniaFact]
+    public async Task ExternalEntityCardViewModel_SameUrlAlreadyOpen_FocusesExistingWebTab()
+    {
+        var tabs = new RecordingTabService();
+        var external = new List<string>();
+        var opener = new UrlOpener(tabs, url => { external.Add(url); return Task.CompletedTask; });
+        var link = Assert.Single(ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity("""{ "default": "https://example.com" }""")),
+            () => opener).Urls);
+
+        await ClickAsync(link);
+        await ClickAsync(link);
+
+        Assert.Equal(2, tabs.FocusAttempts.Count);
+        Assert.Single(tabs.OpenedTabs);
+        Assert.Empty(external);
+    }
+
+    [AvaloniaFact]
+    public async Task ExternalEntityCardViewModel_MailtoAndTelUrls_UseExternalLauncher()
+    {
+        var tabs = new RecordingTabService();
+        var external = new List<string>();
+        var opener = new UrlOpener(tabs, url => { external.Add(url); return Task.CompletedTask; });
+        var card = ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity(
+                """{ "email": "mailto:someone@example.com", "phone": "tel:+15551234567" }""")),
+            () => opener);
+
+        foreach (var link in card.Urls)
+        {
+            await ClickAsync(link);
+        }
+
+        Assert.Equal(new[] { "mailto:someone@example.com", "tel:+15551234567" }, external);
+        Assert.Empty(tabs.OpenedTabs);
+    }
+
+    [AvaloniaFact]
+    public async Task ExternalEntityCardViewModel_InvalidOrUnsafeUrl_DoesNotLaunch()
+    {
+        var opener = new RecordingOpener();
+        var card = ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity(
+                """{ "empty": "", "bad": "not a url", "script": "javascript:alert(1)", "file": "file:///secret", "credentials": "https://user:pass@example.com" }""")),
+            () => opener);
+
+        Assert.Equal(5, card.Urls.Count);
+        foreach (var link in card.Urls)
+        {
+            Assert.False(link.OpenCommand.CanExecute(null));
+            Assert.True(link.HasError);
+            Assert.NotNull(link.ErrorMessage);
+        }
+
+        Assert.Empty(opener.Requests);
+
+        var missing = Assert.Single(ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity("""{ "default": "https://example.com" }"""))).Urls);
+        await ClickAsync(missing);
+        Assert.Contains("unavailable", missing.ErrorMessage);
+
+        opener.Fail = true;
+        var failing = Assert.Single(ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity("""{ "default": "https://example.com" }""")),
+            () => opener).Urls);
+        await ClickAsync(failing);
+        Assert.Contains("Cannot launch", failing.ErrorMessage);
+    }
+
+    [AvaloniaFact]
+    public async Task EntityCardViewModel_ExternalSnapshotUpdated_UpdatedUrlsUseUrlOpener()
+    {
+        var entity = new SubscribedEntityViewModel(CreateExternalEntity(
+            """{ "default": "https://old.example.com" }"""));
+        var opener = new RecordingOpener();
+        var card = new EntityCardViewModel(entity, cardViewName: "external", urlOpenerProvider: () => opener);
+
+        Assert.False(Assert.Single(card.ExternalCard!.Urls).ShowKey);
+        entity.UpdateSnapshot(CreateExternalEntity(
+            """{ "default": "https://new.example.com", "docs": "https://new.example.com/docs" }"""));
+        var updated = card.ExternalCard!;
+        Assert.All(updated.Urls, link => Assert.True(link.ShowKey));
+        foreach (var link in updated.Urls)
+        {
+            await ClickAsync(link);
+        }
+
+        Assert.Equal(new[] { "https://new.example.com", "https://new.example.com/docs" },
+            opener.Requests.Select(request => request.Url));
+    }
+
+    [AvaloniaFact]
+    public async Task EntityWorkspaceTab_ExternalCard_LateRegisteredOpenerAndSnapshotRefresh()
+    {
+        await using var owner = new MainWindowViewModel(new UnknownRepositorySource());
+        var entity = new SubscribedEntityViewModel(CreateExternalEntity(
+            """{ "default": "https://old.example.com" }"""));
+        var tab = new EntityWorkspaceTabViewModel(mainWindowViewModel: owner)
+        {
+            Id = "external-test",
+            Title = "External",
+            Entity = entity,
+        };
+        var card = Assert.IsType<ExternalEntityCardViewModel>(tab.EntityCardNode!.Card.ExternalCard);
+        var initial = Assert.Single(card.Urls);
+        Assert.False(initial.ShowKey);
+        await ClickAsync(initial);
+        Assert.Contains("unavailable", initial.ErrorMessage);
+
+        var opener = new RecordingOpener();
+        owner.ApplicationServices.SetUrlOpener(opener);
+        await ClickAsync(initial);
+        Assert.Null(initial.ErrorMessage);
+
+        entity.UpdateSnapshot(CreateExternalEntity(
+            """{ "default": "https://new.example.com", "docs": "https://new.example.com/docs" }"""));
+        var refreshed = tab.EntityCardNode.Card.ExternalCard!;
+        Assert.All(refreshed.Urls, url => Assert.True(url.ShowKey));
+        foreach (var link in refreshed.Urls)
+        {
+            await ClickAsync(link);
+        }
+
+        Assert.Equal(new[] { "https://old.example.com", "https://new.example.com", "https://new.example.com/docs" },
+            opener.Requests.Select(request => request.Url));
+        Assert.All(opener.Requests, request => Assert.Equal(UrlOpenPreference.Auto, request.Preference));
+    }
+
+    [AvaloniaFact]
+    public async Task ExternalCardTemplate_CopyableLinksShowErrorsAndPreserveRouting()
+    {
+        var opener = new RecordingOpener { Fail = true };
+        var card = ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity(
+                """{ "default": "https://example.com", "docs": "https://example.com/docs", "unsafe": "javascript:alert(1)" }""")),
+            () => opener);
+        var window = new Window { Width = 800, Height = 300, Content = new ContentControl { Content = card } };
+        window.Show();
+        try
+        {
+            Dispatcher.UIThread.RunJobs();
+            var links = window.GetVisualDescendants().OfType<CopyableLinkTextBlock>()
+                .Where(link => link.Classes.Contains("workspace-url-link")).ToArray();
+            Assert.Equal(3, links.Length);
+            Assert.All(card.Urls, url => Assert.True(url.ShowKey));
+            var namedLabels = window.GetVisualDescendants().OfType<SafeSelectableTextBlock>()
+                .Where(label => label.Classes.Contains("workspace-field-label"))
+                .ToArray();
+            Assert.Equal(3, namedLabels.Length);
+            Assert.All(namedLabels, label => Assert.True(label.IsVisible));
+            Assert.Equal(new[] { "default", "docs", "unsafe" }, namedLabels.Select(label => label.Text));
+            Assert.All(links.Take(2), link =>
+            {
+                Assert.Contains("available", link.Classes);
+                Assert.Equal(1, link.Opacity);
+                Assert.Equal("Hand", link.Cursor?.ToString());
+                Assert.NotEmpty(link.TextDecorations!);
+            });
+            Assert.DoesNotContain("available", links[2].Classes);
+            Assert.True(links[2].IsEnabled);
+            Assert.Equal(0.65, links[2].Opacity);
+            Assert.Equal("Arrow", links[2].Cursor?.ToString());
+            Assert.True(links[2].TextDecorations is null or { Count: 0 });
+            Assert.False(links[2].Command!.CanExecute(null));
+            var unsafePoint = links[2].TranslatePoint(
+                new Point(links[2].Bounds.Width / 2, links[2].Bounds.Height / 2), window);
+            Assert.NotNull(unsafePoint);
+            window.MouseDown(unsafePoint.Value, MouseButton.Left);
+            window.MouseUp(unsafePoint.Value, MouseButton.Left);
+            links[2].Focus();
+            window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, "\r");
+            links[2].SelectAll();
+            window.KeyPress(Key.C, RawInputModifiers.Control, PhysicalKey.C, "c");
+            using (var copied = await window.Clipboard!.TryGetDataAsync())
+            {
+                Assert.NotNull(copied);
+                Assert.Equal("javascript:alert(1)", await copied.TryGetTextAsync());
+            }
+            Assert.Empty(opener.Requests);
+            Assert.Contains(window.GetVisualDescendants().OfType<TextBlock>(),
+                text => text.IsVisible && text.Text == "Invalid or unsupported URL.");
+
+            Assert.Same(card.Urls[0].OpenCommand, links[0].Command);
+            var point = links[0].TranslatePoint(
+                new Point(links[0].Bounds.Width / 2, links[0].Bounds.Height / 2), window);
+            Assert.NotNull(point);
+            window.MouseDown(point.Value, MouseButton.Left);
+            window.MouseUp(point.Value, MouseButton.Left);
+            await card.Urls[0].OpenCommand.LastExecutionTask!;
+            Dispatcher.UIThread.RunJobs();
+            Assert.Contains(window.GetVisualDescendants().OfType<TextBlock>(),
+                text => text.IsVisible && text.Text == "Failed to open URL: Cannot launch");
+            Assert.Empty(opener.Requests);
+        }
+        finally
+        {
+            window.Close();
+        }
+
+        var single = ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity("""{ "default": "https://example.com" }""")),
+            () => opener);
+        var singleWindow = new Window { Content = new ContentControl { Content = single } };
+        singleWindow.Show();
+        try
+        {
+            Dispatcher.UIThread.RunJobs();
+            var label = Assert.Single(singleWindow.GetVisualDescendants().OfType<SafeSelectableTextBlock>(),
+                text => text.Classes.Contains("workspace-field-label"));
+            Assert.False(label.IsVisible);
+            Assert.Equal("https://example.com", Assert.Single(singleWindow.GetVisualDescendants().OfType<CopyableLinkTextBlock>(),
+                link => link.Classes.Contains("workspace-url-link")).Text);
+        }
+        finally
+        {
+            singleWindow.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public async Task ExternalCard_ProductionLauncherFails_ReportsFailure()
+    {
+        var tabs = new RecordingTabService();
+        var attempted = new List<string>();
+        var opener = UrlOpener.CreateDefault(
+            tabs,
+            () => null,
+            launchUri: _ => Task.FromResult(false),
+            shellLauncher: url =>
+            {
+                attempted.Add(url);
+                throw new InvalidOperationException("No registered handler");
+            });
+        var link = Assert.Single(ExternalEntityCardViewModel.Create(
+            new SubscribedEntityViewModel(CreateExternalEntity("""{ "default": "mailto:someone@example.com" }""")),
+            () => opener).Urls);
+
+        await ClickAsync(link);
+
+        Assert.Equal(new[] { "mailto:someone@example.com" }, attempted);
+        Assert.Contains("No registered handler", link.ErrorMessage);
+        Assert.Empty(tabs.OpenedTabs);
+    }
+
     [AvaloniaFact]
     public void ExternalEntityCardViewModel_SingleDefaultUrl_SuppressesKeyLabel()
     {
@@ -96,6 +451,49 @@ public void EntityCardViewResolver_ExternalEntity_WithRawRequested_ReturnsRaw()
         Assert.Equal(EntityCardViewResolver.RawViewName, viewName);
     }
 
+    [AvaloniaFact]
+    public void EntityCardViewResolver_ExternalAndNote_ReturnsCompositeViewName()
+    {
+        var entity = new SubscribedEntityViewModel(MixedExternalNoteTestData.CreateSnapshot());
+        var resolver = new EntityCardViewResolver();
+
+        Assert.Equal("external-note", resolver.ResolveViewName(entity));
+        Assert.Equal(EntityCardViewResolver.RawViewName,
+            resolver.ResolveViewName(entity, EntityCardViewResolver.RawViewName));
+    }
+
+    [AvaloniaFact]
+    public async Task EntityWorkspaceTab_ExternalAndNote_LateRegisteredOpenerSurvivesSnapshotRefresh()
+    {
+        await using var owner = new MainWindowViewModel(new UnknownRepositorySource());
+        var entity = new SubscribedEntityViewModel(MixedExternalNoteTestData.CreateSnapshot());
+        var tab = new EntityWorkspaceTabViewModel(mainWindowViewModel: owner)
+        {
+            Id = "mixed-external-note-test",
+            Title = "Mixed external note",
+            Entity = entity,
+        };
+        var card = tab.EntityCardNode!.Card;
+        Assert.Equal("external-note", card.CardViewName);
+        Assert.True(card.ShowFieldEditors);
+        var initial = Assert.Single(card.ExternalCard!.Urls);
+        await ClickAsync(initial);
+        Assert.Contains("unavailable", initial.ErrorMessage);
+
+        var opener = new RecordingOpener();
+        owner.ApplicationServices.SetUrlOpener(opener);
+        await ClickAsync(initial);
+
+        entity.UpdateSnapshot(MixedExternalNoteTestData.CreateSnapshot(
+            url: "https://example.com/second", body: "# Second note"));
+        Assert.Equal("external-note", card.CardViewName);
+        Assert.True(card.ShowFieldEditors);
+        await ClickAsync(Assert.Single(card.ExternalCard!.Urls));
+
+        Assert.Equal(new[] { "https://example.com/first", "https://example.com/second" },
+            opener.Requests.Select(request => request.Url));
+    }
+
     private static EntitySnapshot CreateExternalEntity(string urlsJson)
     {
         var json = $$"""
@@ -122,4 +520,39 @@ private static EntitySnapshot CreateSnapshot(string json)
             Relationships = Array.Empty<EntitySnapshot>(),
         };
     }
+
+    internal static class MixedExternalNoteTestData
+    {
+        public static EntitySnapshot CreateSnapshot(
+            string types = "\"entity\", \"external\", \"note\"",
+            string url = "https://example.com/first",
+            string body = "# First note")
+        {
+            using var document = JsonDocument.Parse(
+                $$"""
+                {
+                  "entity-id": "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+                  "entity-types": [{{types}}],
+                  "names": [["externals", "my-link"]],
+                  "display-name": { "default": "My Link" },
+                  "urls": { "default": {{JsonSerializer.Serialize(url)}} },
+                  "content": {
+                    "default": {
+                      "mime-type": "text/markdown",
+                      "content": { "text": {{JsonSerializer.Serialize(body)}} }
+                    }
+                  },
+                  "internal-metadata": "must never appear"
+                }
+                """);
+            return new EntitySnapshot
+            {
+                EntityId = new EntityId("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"),
+                ConcurrencyTag = new ConcurrencyTag("1"),
+                ModifiedTime = new Timestamp(DateTimeOffset.UtcNow, Guid.NewGuid().ToString()),
+                Data = document.RootElement.Clone(),
+                Relationships = Array.Empty<EntitySnapshot>(),
+            };
+        }
+    }
 }
diff --git a/Phantom.Workspaces.Tests/MainWindowIntegrationTests.cs b/Phantom.Workspaces.Tests/MainWindowIntegrationTests.cs
index 11775c8c..7622a738 100644
--- a/Phantom.Workspaces.Tests/MainWindowIntegrationTests.cs
+++ b/Phantom.Workspaces.Tests/MainWindowIntegrationTests.cs
@@ -48,6 +48,74 @@ namespace Phantom.Workspaces.Tests;
 
 public sealed class MainWindowIntegrationTests
 {
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task PrimaryViewTree_ActualPopulationBinding_CountsCollapsedDescendantsAndViewSwitch()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var window = new MainWindow(viewModel);
+        window.Show();
+        try
+        {
+            Dispatcher.UIThread.RunJobs();
+            var tree = window.GetVisualDescendants().OfType<TreeView>()
+                .Single(item => item.Classes.Contains("entity-card-tree-entity"));
+            var population = viewModel.CurrentViewPopulation;
+            population.Entities.Clear();
+            population.RootEntities.Clear();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+
+            ViewEntityViewModel CreateNode(int i) => new(
+                new SubscribedEntityViewModel(new EntitySnapshot
+                {
+                    EntityId = new EntityId(Guid.NewGuid().ToString()),
+                    ModifiedTime = new Timestamp(DateTimeOffset.UtcNow, i.ToString()),
+                    Data = JsonDocument.Parse("""{"display-name":"Node","entity-types":["entity"]}""").RootElement.Clone(),
+                    Relationships = [],
+                }),
+                viewModel, new ShortcutManager(), indentLevel: i == 0 ? 0 : 1);
+
+            var root = CreateNode(0);
+            population.RootEntities.Add(root);
+            population.RootEntities.Add(CreateNode(1));
+            population.Entities.Add(root);
+            population.Entities.Add(population.RootEntities[1]);
+            for (int i = 2; i < 99; i++)
+            {
+                var child = CreateNode(i);
+                root.AddChild(child);
+                population.Entities.Add(child);
+            }
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+            var lastChild = CreateNode(99);
+            root.AddChild(lastChild);
+            population.Entities.Add(lastChild);
+            Dispatcher.UIThread.RunJobs();
+            Assert.Equal(2, population.RootEntities.Count);
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+            Assert.Equal(100, Phantom.Workspaces.Controls.EntityTreePanel.GetNodeCount(tree));
+            population.ApplyFind("nonexistent", hideUnmatched: true);
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsType<VirtualizingStackPanel>(tree.ItemsPanelRoot);
+            population.Entities.RemoveAt(99);
+            Dispatcher.UIThread.RunJobs();
+            Assert.IsType<StackPanel>(tree.ItemsPanelRoot);
+
+            var previousPopulation = viewModel.CurrentViewPopulation;
+            var alternative = viewModel.TopLevelViews.First(view => view != viewModel.SelectedTopLevelView);
+            viewModel.SelectedTopLevelView = alternative;
+            Dispatcher.UIThread.RunJobs();
+            Assert.NotSame(previousPopulation, viewModel.CurrentViewPopulation);
+            Assert.Equal(viewModel.CurrentViewPopulation.Entities.Count,
+                Phantom.Workspaces.Controls.EntityTreePanel.GetNodeCount(tree));
+        }
+        finally
+        {
+            await CloseWindowAsync(window);
+        }
+    }
+
     [AvaloniaFact(Timeout = 15_000)]
     public async Task TrustedExecutor_Production_UsesTransportFactoryRegistry()
     {
@@ -955,6 +1023,319 @@ public async Task MainWindowViewModel_SessionsView_GetEntitySubViewsIncludeAgent
             static entity => string.Equals(entity.EntityType, "view", StringComparison.Ordinal));
     }
 
+    [AvaloniaFact(Timeout = 60_000)]
+    public async Task OpenViewTab_SubViewsAndRelatedEntities_ShowsSameHierarchyAsSelectedView()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var broker = GetEntityBroker(viewModel);
+        var viewId = new EntityId("16220010-0000-4000-8000-000000000001");
+        var noteId = new EntityId("16220010-0000-4000-8000-000000000002");
+        var referencedId = new EntityId("16220010-0000-4000-8000-000000000003");
+        var getId = new EntityId("16220010-0000-4000-8000-000000000004");
+        var workspaceId = new EntityId("16220010-0000-4000-8000-000000000005");
+        var childId = new EntityId("16220010-0000-4000-8000-000000000006");
+        var relationshipId = new EntityId("16220010-0000-4000-8000-000000000007");
+        await UpsertEntityAndLoadAsync(broker, noteId, $$$"""
+            {
+              "entity-id": "{{{noteId}}}",
+              "entity-types": ["entity", "note"],
+              "names": [["views", "issue1622", "hierarchy"]],
+              "display-name": {"default": "Parent context"},
+              "content": {"mime-type": "text/markdown", "content": {"text": "Context"}}
+            }
+            """);
+        await UpsertEntityAndLoadAsync(broker, referencedId, $$$"""
+            {
+              "entity-id": "{{{referencedId}}}",
+              "entity-types": ["entity", "view"],
+              "names": [["views", "issue1622", "referenced"]],
+              "title": {"default": "Referenced"},
+              "sub-views": []
+            }
+            """);
+        await UpsertEntityAndLoadAsync(broker, getId, $$$"""
+            {
+              "entity-id": "{{{getId}}}",
+              "entity-types": ["entity", "note"],
+              "names": [["notes", "issue1622-get"]],
+              "display-name": {"default": "Get result"},
+              "content": {"mime-type": "text/markdown", "content": {"text": "Get"}}
+            }
+            """);
+        await UpsertEntityAndLoadAsync(broker, workspaceId, $$$"""
+            {
+              "entity-id": "{{{workspaceId}}}",
+              "entity-types": ["entity", "workspace"],
+              "names": [["workspaces", "issue1622-hierarchy"]],
+              "display-name": {"default": "Hierarchy workspace"},
+              "regions": []
+            }
+            """);
+        await UpsertEntityAndLoadAsync(broker, childId, $$$"""
+            {
+              "entity-id": "{{{childId}}}",
+              "entity-types": ["entity", "note"],
+              "names": [["notes", "issue1622-child"]],
+              "display-name": {"default": "Related child"},
+              "content": {"mime-type": "text/markdown", "content": {"text": "Child"}}
+            }
+            """);
+        await UpsertEntityAndLoadAsync(broker, relationshipId, $$$"""
+            {
+              "entity-id": "{{{relationshipId}}}",
+              "entity-types": ["entity", "related", "relationship"],
+              "names": [["relationships", "issue1622-child"]],
+              "participants": {"entities": ["{{{workspaceId}}}", "{{{childId}}}"]}
+            }
+            """);
+        var viewEntity = await UpsertEntityAndLoadAsync(broker, viewId, $$$"""
+            {
+              "entity-id": "{{{viewId}}}",
+              "entity-types": ["entity", "view"],
+              "names": [["views", "issue1622", "hierarchy"]],
+              "title": {"default": "Issue1622 hierarchy"},
+              "sub-views": [
+                {"disposition": "expanded", "view-entity-id": ["views", "issue1622", "referenced"]},
+                {"disposition": "expanded", "get-entity": [{"entity-id": "{{{getId}}}"}]},
+                {"disposition": "expanded", "query": {"clauses": [{
+                  "clause-identifier": {"value": "workspaces"},
+                  "clause": {"clause-type": "entity-type", "entity-type-names": {"values": ["workspace"]}}
+                }]}, "relationships-to-return": [{"relationship-type-names": ["related"]}]}
+              ]
+            }
+            """);
+        var selected = new ViewDefinitionViewModel
+        {
+            Id = viewId.ToString(), Title = "Issue1622 hierarchy",
+            Description = "Hierarchy fixture", IconGlyph = "", ViewEntity = viewEntity,
+        };
+        viewModel.SelectedTopLevelView = selected;
+        var apply = typeof(MainWindowViewModel).GetMethod(
+            "ApplySelectedViewAsync", BindingFlags.Instance | BindingFlags.NonPublic)!;
+        await (Task)apply.Invoke(viewModel, [])!;
+        await (Task)apply.Invoke(viewModel, [])!;
+
+        var leftPopulation = viewModel.CurrentViewPopulation;
+        var tab = await viewModel.CreateViewTabAsync(viewEntity);
+
+        Assert.NotSame(leftPopulation, tab.Population);
+        var leftHierarchy = DescribeViewHierarchy(leftPopulation);
+        var tabHierarchy = DescribeViewHierarchy(tab.Population);
+        Assert.True(leftHierarchy.SequenceEqual(tabHierarchy),
+            $"Left: {string.Join(", ", leftHierarchy)}; tab: {string.Join(", ", tabHierarchy)}");
+        Assert.Contains(tab.Population.RootEntities, node => node.EntityId == noteId.ToString() && node.IsParentContext);
+        Assert.Contains(tab.Population.RootEntities, node => node.EntityId == referencedId.ToString());
+        Assert.Contains(tab.Population.RootEntities, node => node.EntityId == getId.ToString());
+        var workspaceNode = Assert.Single(tab.Population.RootEntities, node => node.EntityId == workspaceId.ToString());
+        Assert.Contains(workspaceNode.Children, child => child.EntityId == childId.ToString());
+        Assert.All(tab.Population.Entities,
+            node => Assert.Empty(node.EntityCardNode.Card.FieldEditors));
+        Assert.Same(selected, viewModel.SelectedTopLevelView);
+        Assert.Same(leftPopulation, viewModel.CurrentViewPopulation);
+        await tab.DisposeAsync();
+    }
+
+    private static string[] DescribeViewHierarchy(ViewPopulationViewModel population)
+    {
+        static IEnumerable<string> Walk(ViewEntityViewModel node, string path)
+        {
+            var current = $"{path}/{node.EntityId}:{node.IsParentContext}";
+            yield return current;
+            foreach (var child in node.Children)
+            {
+                foreach (var descendant in Walk(child, current))
+                {
+                    yield return descendant;
+                }
+            }
+        }
+
+        return population.RootEntities.SelectMany(root => Walk(root, "")).ToArray();
+    }
+
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task OpenViewTab_MissingNoteAndBrokenReferences_RendersEmptyHierarchy()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var broker = GetEntityBroker(viewModel);
+        var viewId = new EntityId("16220011-0000-4000-8000-000000000001");
+        var missingId = new EntityId("16220011-0000-4000-8000-000000000002");
+        var viewEntity = await UpsertEntityAndLoadAsync(broker, viewId, $$$"""
+            {
+              "entity-id": "{{{viewId}}}",
+              "entity-types": ["entity", "view"],
+              "names": [["views", "issue1622", "empty"]],
+              "title": {"default": "Empty view"},
+              "sub-views": [
+                {"disposition": "expanded", "view-entity-id": ["views", "issue1622", "missing"]},
+                {"disposition": "expanded", "get-entity": [{"entity-id": "{{{missingId}}}"}]},
+                {"disposition": "expanded", "query": {"clauses": [{
+                  "clause-identifier": {"value": "missing"},
+                  "clause": {"clause-type": "entity-type",
+                             "entity-type-names": {"values": ["issue1622-nonexistent-type"]}}
+                }]}}
+              ]
+            }
+            """);
+        var tab = await viewModel.CreateViewTabAsync(viewEntity);
+        Assert.Empty(tab.Population.RootEntities);
+        Assert.Empty(tab.Population.Entities);
+        await tab.DisposeAsync();
+    }
+
+    [AvaloniaFact(Timeout = 60_000)]
+    public async Task OpenViewTab_LargeView_DoesNotBuildFieldEditorsForNonRealizedEntities()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var broker = GetEntityBroker(viewModel);
+        var changes = new List<EntityChange>();
+        for (var i = 1; i <= 48; i++)
+        {
+            var id = new EntityId($"16220012-0000-4000-8000-{i:D12}");
+            using var document = JsonDocument.Parse($$"""
+                {
+                  "entity-id": "{{id}}",
+                  "entity-types": ["entity", "workspace"],
+                  "names": [["workspaces", "issue1622-lazy-{{i}}"]],
+                  "display-name": {"default": "Lazy workspace {{i}}"},
+                  "regions": []
+                }
+                """);
+            changes.Add(new EntityChange
+            {
+                EntityId = id, EntityChangeMode = EntityChangeMode.Replace,
+                Data = document.RootElement.Clone(),
+            });
+        }
+
+        var result = await broker.UpdateAsync(new UpdateRequest
+        {
+            UpdateMetadata = new UpdateMetadata { Comment = new Markdown { Text = "Seed lazy view" } },
+            Changes = changes,
+        });
+        Assert.DoesNotContain(result.EntityResults, entity => entity.UpdateState == UpdateState.Failed);
+
+        var workspaces = Assert.Single(viewModel.TopLevelViews, view => view.Title == "Workspaces");
+        var tab = await viewModel.CreateViewTabAsync(workspaces.ViewEntity!);
+        var nodes = tab.Population.Entities
+            .Where(node => node.EntityId.StartsWith("16220012-", StringComparison.Ordinal)).ToArray();
+        Assert.Equal(48, nodes.Length);
+        var buildRequested = typeof(EntityCardViewModel).GetField("fieldEditorsBuildRequested",
+            BindingFlags.Instance | BindingFlags.NonPublic)!;
+        Assert.All(nodes, node =>
+        {
+            Assert.Equal(0, buildRequested.GetValue(node.EntityCardNode.Card));
+            Assert.Empty(node.EntityCardNode.Card.FieldEditors);
+        });
+        nodes[0].EntityCardNode.Card.EnsureFieldEditorsBuilt();
+        await nodes[0].EntityCardNode.Card.FieldEditorsBuildTask;
+        Assert.Equal(1, buildRequested.GetValue(nodes[0].EntityCardNode.Card));
+        Assert.All(nodes.Skip(1), node => Assert.Equal(0, buildRequested.GetValue(node.EntityCardNode.Card)));
+        await tab.DisposeAsync();
+    }
+
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task OpenEntityShortcutHandler_ViewEntity_OpensPopulatedViewTab_AndDefinitionAction()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var selected = viewModel.SelectedTopLevelView;
+        var sessions = Assert.Single(viewModel.TopLevelViews, view => view.Title == "Sessions");
+        var handler = new OpenEntityShortcutHandler();
+
+        Assert.True(await handler.Handle(viewModel, Shortcut.Open, sessions.ViewEntity!));
+        var tab = Assert.IsType<ViewWorkspaceTabViewModel>(
+            Assert.Single(viewModel.SelectedWorkspacePane.Tabs,
+                item => item.Id == sessions.Id));
+        Assert.NotEmpty(tab.Population.Entities);
+        Assert.Same(selected, viewModel.SelectedTopLevelView);
+
+        await handler.Handle(viewModel, Shortcut.Open, sessions.ViewEntity!);
+        Assert.Single(viewModel.SelectedWorkspacePane.Tabs, item => item.Id == sessions.Id);
+
+        tab.EditDefinitionCommand.Execute(null);
+        await Dispatcher.UIThread.InvokeAsync(() => { });
+        var definitionTab = Assert.IsType<EntityWorkspaceTabViewModel>(
+            Assert.Single(viewModel.SelectedWorkspacePane.Tabs,
+                item => item.Id == $"view-definition-{sessions.Id}"));
+        Assert.Same(sessions.ViewEntity, definitionTab.Entity);
+        var definitionCard = definitionTab.EntityCardNode!.Card;
+        Assert.Equal("raw", definitionCard.CardViewName);
+        Assert.Contains("\"sub-views\"", definitionCard.RawJsonText);
+        Assert.True(definitionCard.ToggleEditModeCommand.CanExecute(null));
+        definitionCard.ToggleEditModeCommand.Execute(null);
+        Assert.True(definitionCard.IsEditMode);
+        Assert.False(definitionCard.IsRawJsonReadOnly);
+        definitionCard.DiscardEditModeCommand.Execute(null);
+        Assert.Null(await handler.TryCreateTabForRestoreAsync(
+            viewModel, sessions.ViewEntity!,
+            $"view-definition-{sessions.Id}", "Edit definition", "full"));
+    }
+
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task OpenViewTab_RestoreAndClose_RestoresPopulationAndDisposesSubscriptions()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var sessions = Assert.Single(viewModel.TopLevelViews, view => view.Title == "Sessions");
+        var handler = new OpenEntityShortcutHandler();
+        var restored = Assert.IsType<ViewWorkspaceTabViewModel>(
+            await handler.TryCreateTabForRestoreAsync(viewModel, sessions.ViewEntity!,
+                "saved-view-tab", "My sessions", "full"));
+        Assert.Equal("saved-view-tab", restored.Id);
+        Assert.Equal("My sessions", restored.Title);
+        Assert.Contains(restored.Population.Entities, node => node.EntityType == "agent-manifest");
+
+        await viewModel.OpenTabAsync(restored);
+        await handler.Handle(viewModel, Shortcut.Open, sessions.ViewEntity!);
+        Assert.Same(restored, Assert.Single(viewModel.SelectedWorkspacePane.Tabs,
+            tab => tab is ViewWorkspaceTabViewModel viewTab
+                && viewTab.Entity?.EntityId == sessions.ViewEntity!.EntityId));
+
+        viewModel.CloseTab(restored);
+        await restored.DisposeAsync();
+        Assert.True(restored.Population.CancellationToken.IsCancellationRequested);
+    }
+
+    [AvaloniaFact(Timeout = 45_000)]
+    public async Task OpenViewTab_DockDescriptorRestore_RepopulatesView()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var sessions = Assert.Single(viewModel.TopLevelViews, view => view.Title == "Sessions");
+        await viewModel.OpenViewTabAsync(sessions.ViewEntity!);
+        var pane = viewModel.SelectedWorkspacePane;
+        var dock = FindDocumentDockIn(pane.ContentLayout!);
+        await WaitForWorkspaceTabAsync(dock!, sessions.Id);
+
+        var serializer = new DockSerializer(
+            typeof(System.Collections.ObjectModel.ObservableCollection<>),
+            new WorkspaceDockTypeInfoResolver());
+        var dockLayoutJson = serializer.Serialize(pane.ContentLayout!);
+        var broker = GetEntityBroker(viewModel);
+        var workspaceId = new EntityId("16220002-0000-4000-8000-000000000001");
+        await UpsertEntityAndLoadAsync(broker, workspaceId, $$"""
+            {
+              "entity-id": "16220002-0000-4000-8000-000000000001",
+              "entity-types": ["entity", "workspace"],
+              "display-name": { "default": "View Tab Restore Workspace" },
+              "dock-layout": {{dockLayoutJson}},
+              "regions": []
+            }
+            """);
+        await viewModel.OpenWorkspaceAsync(new GetEntityRequest { EntityId = workspaceId });
+        var restoredPane = Assert.Single(viewModel.WorkspacePanes,
+            candidate => candidate.Id == workspaceId.ToString());
+        await WaitForPanePopulatedAsync(restoredPane);
+        var restored = Assert.IsType<ViewWorkspaceTabViewModel>(
+            Assert.Single(restoredPane.Tabs, tab => tab.Id == sessions.Id));
+        Assert.Contains(restored.Population.Entities, node => node.EntityType == "agent-manifest");
+        Assert.NotSame(pane.Tabs.First(tab => tab.Id == sessions.Id), restored);
+    }
+
     [AvaloniaFact(Timeout = 15_000)]
     public async Task ViewEntityViewModel_TraversedEntitiesCollapsed_WhenDispositionIsCollapsed()
     {
diff --git a/Phantom.Workspaces.Tests/MainWindowViewModelTests.cs b/Phantom.Workspaces.Tests/MainWindowViewModelTests.cs
index 3634c7a2..0262f31c 100644
--- a/Phantom.Workspaces.Tests/MainWindowViewModelTests.cs
+++ b/Phantom.Workspaces.Tests/MainWindowViewModelTests.cs
@@ -629,6 +629,122 @@ public async Task ViewPopulation_EntityChange_PreservesSelectionAndExpansion()
         Assert.Same(workspaceBVm, Assert.Single(entities, vm => vm.EntityId == workspaceB.ToString()));
     }
 
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task OpenViewTab_WhenQueryMembershipChanges_UpdatesTabAndPreservesSelection()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var broker = GetEntityBroker(viewModel);
+        var workspaceA = new EntityId("16220001-0000-4000-8000-000000000001");
+        var workspaceB = new EntityId("16220001-0000-4000-8000-000000000002");
+        var workspaceC = new EntityId("16220001-0000-4000-8000-000000000003");
+        var workspaceD = new EntityId("16220001-0000-4000-8000-000000000004");
+        await UpsertWorkspaceAsync(broker, workspaceA, "issue1622-a", "Issue1622 A");
+        await UpsertWorkspaceAsync(broker, workspaceB, "issue1622-b", "Issue1622 B");
+        var workspaces = Assert.Single(viewModel.TopLevelViews, view => view.Title == "Workspaces");
+        var originalSelection = viewModel.SelectedTopLevelView;
+        await viewModel.OpenViewTabAsync(workspaces.ViewEntity!);
+
+        var tab = Assert.IsType<ViewWorkspaceTabViewModel>(
+            Assert.Single(viewModel.SelectedWorkspacePane.Tabs, item => item.Id == workspaces.Id));
+        var entityA = Assert.Single(tab.Population.Entities, vm => vm.EntityId == workspaceA.ToString());
+        entityA.EntityCardNode.Card.IsSelected = true;
+        entityA.IsExpanded = false;
+        await UpsertWorkspaceAsync(broker, workspaceC, "issue1622-c", "Issue1622 C");
+        await WaitForEntityInCollectionAsync(tab.Population.Entities, workspaceC.ToString());
+        await UpsertWorkspaceAsync(broker, workspaceD, "issue1622-d", "Issue1622 D");
+        await WaitForEntityInCollectionAsync(tab.Population.Entities, workspaceD.ToString());
+
+        Assert.Same(entityA, Assert.Single(tab.Population.Entities, vm => vm.EntityId == workspaceA.ToString()));
+        Assert.True(entityA.EntityCardNode.Card.IsSelected);
+        Assert.False(entityA.IsExpanded);
+        Assert.Same(originalSelection, viewModel.SelectedTopLevelView);
+
+        viewModel.CloseTab(tab);
+        await tab.DisposeAsync();
+        Assert.True(tab.Population.CancellationToken.IsCancellationRequested);
+    }
+
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task OpenViewTab_ExpansionState_IsIndependentOfLeftView()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var workspaceId = new EntityId("16220003-0000-4000-8000-000000000001");
+        await UpsertWorkspaceAsync(GetEntityBroker(viewModel), workspaceId, "issue1622-expansion", "Expansion");
+        await SelectWorkspacesViewAsync(viewModel);
+        var workspaces = viewModel.SelectedTopLevelView;
+        var leftNode = Assert.Single(viewModel.CurrentViewPopulation.Entities,
+            node => node.EntityId == workspaceId.ToString());
+        leftNode.IsExpanded = true;
+        await viewModel.OpenViewTabAsync(workspaces.ViewEntity!);
+        var tab = Assert.IsType<ViewWorkspaceTabViewModel>(
+            Assert.Single(viewModel.SelectedWorkspacePane.Tabs, item => item.Id == workspaces.Id));
+        var tabNode = Assert.Single(tab.Population.Entities, node => node.EntityId == workspaceId.ToString());
+
+        tabNode.IsExpanded = true;
+        tabNode.IsExpanded = false;
+        await InvokeApplySelectedViewAsync(viewModel);
+        Assert.True(Assert.Single(viewModel.CurrentViewPopulation.Entities,
+            node => node.EntityId == workspaceId.ToString()).IsExpanded);
+        Assert.False(tabNode.IsExpanded);
+
+        viewModel.CurrentViewPopulation.Entities
+            .Single(node => node.EntityId == workspaceId.ToString()).IsExpanded = false;
+        await UpsertWorkspaceAsync(GetEntityBroker(viewModel),
+            new EntityId("16220003-0000-4000-8000-000000000002"), "issue1622-expansion-2", "Expansion 2");
+        Assert.False(tabNode.IsExpanded);
+        Assert.True(tab.Population.ExpandedEntityIds.TryGetValue(workspaceId.ToString(), out var tabExpanded));
+        Assert.False(tabExpanded);
+    }
+
+    [AvaloniaFact(Timeout = 30_000)]
+    public async Task OpenViewTab_Close_DetachesEntityAndQueryObservers_WithoutStoppingLeftView()
+    {
+        await using var viewModel = CreateTestMainWindowViewModel();
+        await viewModel.InitializeAsync();
+        var broker = GetEntityBroker(viewModel);
+        var workspaceA = new EntityId("16220004-0000-4000-8000-000000000001");
+        var workspaceB = new EntityId("16220004-0000-4000-8000-000000000002");
+        var workspaceC = new EntityId("16220004-0000-4000-8000-000000000003");
+        await UpsertWorkspaceAsync(broker, workspaceA, "issue1622-listener-a", "Listener A");
+        await SelectWorkspacesViewAsync(viewModel);
+        var left = viewModel.CurrentViewPopulation;
+        var workspaces = viewModel.SelectedTopLevelView;
+        await viewModel.OpenViewTabAsync(workspaces.ViewEntity!);
+        var tab = Assert.IsType<ViewWorkspaceTabViewModel>(
+            Assert.Single(viewModel.SelectedWorkspacePane.Tabs, item => item.Id == workspaces.Id));
+        var tabNode = Assert.Single(tab.Population.Entities, node => node.EntityId == workspaceA.ToString());
+        var entity = tabNode.Entity;
+        var listenersWithTab = CountEntityListeners(entity);
+        Assert.True(tab.Population.QueryObserverCount > 0);
+        Assert.True(left.QueryObserverCount > 0);
+
+        await UpsertWorkspaceAsync(broker, workspaceB, "issue1622-listener-b", "Listener B");
+        await WaitForEntityInCollectionAsync(tab.Population.Entities, workspaceB.ToString());
+        await tab.Population.ReconcileGate.WaitAsync(TestContext.Current.CancellationToken);
+        tab.Population.ReconcileGate.Release();
+        Assert.Equal(listenersWithTab, CountEntityListeners(entity));
+
+        viewModel.CloseTab(tab);
+        await tab.DisposeAsync();
+        Assert.True(tab.Population.CancellationToken.IsCancellationRequested);
+        Assert.Equal(0, tab.Population.QueryObserverCount);
+        Assert.True(left.QueryObserverCount > 0);
+        Assert.True(CountEntityListeners(entity) < listenersWithTab);
+        await UpsertWorkspaceAsync(broker, workspaceC, "issue1622-listener-c", "Listener C");
+        await WaitForEntityInCollectionAsync(left.Entities, workspaceC.ToString());
+        Assert.DoesNotContain(tab.Population.Entities, node => node.EntityId == workspaceC.ToString());
+    }
+
+    private static int CountEntityListeners(SubscribedEntityViewModel entity)
+    {
+        var field = typeof(ViewModelBase).GetField("PropertyChanged",
+            BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(field);
+        return (field!.GetValue(entity) as MulticastDelegate)?.GetInvocationList().Length ?? 0;
+    }
+
     [AvaloniaFact]
     public async Task ViewPopulation_NoMembershipChange_DoesNotMutateCollectionStructure()
     {
diff --git a/Phantom.Workspaces.Tests/PersistedSplitSessionRealCliAcceptanceTests.cs b/Phantom.Workspaces.Tests/PersistedSplitSessionRealCliAcceptanceTests.cs
index cdc8a3ed..fee7ace7 100644
--- a/Phantom.Workspaces.Tests/PersistedSplitSessionRealCliAcceptanceTests.cs
+++ b/Phantom.Workspaces.Tests/PersistedSplitSessionRealCliAcceptanceTests.cs
@@ -112,6 +112,11 @@ await AssertPersistedTurnAsync(
                 "daemon-shade-first-result",
                 ct);
 
+            // The owner advances its queue revision while consuming the first turn.
+            // Wait for that snapshot to reach the remote client before submitting a
+            // second compare-and-swap queue command.
+            await WaitForQueueRevisionAsync(sourceChat, ownerChat, ct);
+
             var secondProjected = WaitForAssistantAsync(
                 sourceChat,
                 "daemon-shade-restored-result");
@@ -213,6 +218,33 @@ private static async Task<AgentInputQueueCommandResult> EnqueueAtSourceAsync(
             },
             cancellationToken);
 
+    private static async Task WaitForQueueRevisionAsync(
+        RemoteAgentChat remote,
+        AgentChat owner,
+        CancellationToken cancellationToken)
+    {
+        var ownerQueues = ((IAgentChat)owner).InputQueues;
+        var completion = new TaskCompletionSource(
+            TaskCreationOptions.RunContinuationsAsynchronously);
+        remote.InputQueues.Changed += OnChanged;
+        try
+        {
+            OnChanged(null, EventArgs.Empty);
+            await completion.Task.WaitAsync(cancellationToken);
+            Assert.Equal(ownerQueues.Snapshot.Revision, remote.InputQueues.Snapshot.Revision);
+        }
+        finally
+        {
+            remote.InputQueues.Changed -= OnChanged;
+        }
+
+        void OnChanged(object? sender, EventArgs args)
+        {
+            if (remote.InputQueues.Snapshot.Revision >= ownerQueues.Snapshot.Revision)
+                completion.TrySetResult();
+        }
+    }
+
     private static void EnqueueSessionToolCall(
         ConversationClient conversation,
         string callId)
diff --git a/Phantom.Workspaces.Tests/RunVsCodeTunnelToolTests.cs b/Phantom.Workspaces.Tests/RunVsCodeTunnelToolTests.cs
index 7ae8e602..b62a4ba8 100644
--- a/Phantom.Workspaces.Tests/RunVsCodeTunnelToolTests.cs
+++ b/Phantom.Workspaces.Tests/RunVsCodeTunnelToolTests.cs
@@ -1,4 +1,3 @@
-using System.Collections.Concurrent;
 using System.Text.Json;
 using Microsoft.Extensions.Logging;
 using Phantom.Workspaces.Tools;
@@ -95,48 +94,50 @@ private WorkspaceToolExecutionContext Context(
     }
 
     /// <summary>
-    /// A synchronous, manually-driven "wait between polls" seam. Each call to the delegate blocks
-    /// until <see cref="ReleaseOnePoll"/> is invoked from the test — no timing dependencies.
+    /// A manually-driven "wait between polls" seam. Tests observe the pending wait before
+    /// releasing it, so they cannot release a poll that the runner will never enter.
     /// </summary>
     private sealed class ManualPollGate
     {
-        private readonly ConcurrentQueue<TaskCompletionSource> pending = new();
-        private readonly ConcurrentQueue<TaskCompletionSource> releases = new();
         private readonly object gate = new();
+        private TaskCompletionSource? pending;
+        private TaskCompletionSource pollArrived = new(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        public int PollCount { get; private set; }
+        public Task WaitForPollAsync()
+        {
+            lock (this.gate)
+            {
+                return this.pending is not null
+                    ? Task.CompletedTask
+                    : this.pollArrived.Task.WaitAsync(TimeSpan.FromSeconds(30));
+            }
+        }
 
         public Task WaitAsync(CancellationToken cancellationToken)
         {
             lock (this.gate)
             {
-                this.PollCount++;
-                if (this.releases.TryDequeue(out var release))
+                var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                if (this.pending is not null)
                 {
-                    release.SetResult();
-                    return Task.CompletedTask;
+                    throw new InvalidOperationException("The previous poll has not been released.");
                 }
 
-                var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
-                this.pending.Enqueue(tcs);
+                this.pending = tcs;
+                this.pollArrived.TrySetResult();
                 cancellationToken.Register(() => tcs.TrySetCanceled(cancellationToken));
                 return tcs.Task;
             }
         }
 
-        public Task ReleaseOnePoll()
+        public void ReleaseOnePoll()
         {
             lock (this.gate)
             {
-                if (this.pending.TryDequeue(out var tcs))
-                {
-                    tcs.SetResult();
-                    return Task.CompletedTask;
-                }
-
-                var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
-                this.releases.Enqueue(release);
-                return release.Task;
+                var tcs = this.pending ?? throw new InvalidOperationException("No poll is pending.");
+                this.pending = null;
+                this.pollArrived = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                tcs.SetResult();
             }
         }
     }
@@ -240,16 +241,17 @@ public async Task RunVsCodeTunnelTool_ChildAliveAndStatusRunning_BlocksUntilCond
         var runTask = tool.ExecuteAsync(this.Context());
 
         // First poll: status "running" then wait for tick.
-        await gate.ReleaseOnePoll();
+        await gate.WaitForPollAsync();
+        gate.ReleaseOnePoll();
         // Second poll: status "running" then wait for tick.
-        await gate.ReleaseOnePoll();
+        await gate.WaitForPollAsync();
 
         Assert.False(runTask.IsCompleted);
         Assert.True(statusCount >= 2);
 
         // Break the conjunction so ExecuteAsync can return.
         child.SimulateExit(0, "child died");
-        await gate.ReleaseOnePoll();
+        gate.ReleaseOnePoll();
 
         await runTask;
     }
@@ -546,13 +548,13 @@ public async Task RunVsCodeTunnelTool_WaitsGracePeriodBeforeFirstStatusCheck()
 
         // Release the grace period; the first status probe may now happen.
         graceGate.SetResult();
-        await pollGate.ReleaseOnePoll();
+        await pollGate.WaitForPollAsync();
 
         Assert.True(statusCount >= 1);
 
         // Let ExecuteAsync return.
         child.SimulateExit(0, "done");
-        await pollGate.ReleaseOnePoll();
+        pollGate.ReleaseOnePoll();
         await runTask;
     }
 
@@ -590,14 +592,14 @@ public async Task RunVsCodeTunnelTool_TunnelUpAfterGracePeriod_ReportsRunning()
         var runTask = tool.ExecuteAsync(this.Context());
 
         graceGate.SetResult();
-        await pollGate.ReleaseOnePoll();
+        await pollGate.WaitForPollAsync();
 
         // Tunnel reported running after the grace period, so the tool keeps blocking rather than
         // returning a spurious "not running" failure.
         Assert.False(runTask.IsCompleted);
 
         child.SimulateExit(0, "done");
-        await pollGate.ReleaseOnePoll();
+        pollGate.ReleaseOnePoll();
         await runTask;
     }
 
@@ -811,15 +813,16 @@ public async Task RunVsCodeTunnelTool_StatusReportsConnected_TreatsTunnelAsUpAnd
 
         // A Connected status makes the tool treat the tunnel as up: it keeps blocking and does NOT
         // kill the child or emit the failure message.
-        await gate.ReleaseOnePoll();
-        await gate.ReleaseOnePoll();
+        await gate.WaitForPollAsync();
+        gate.ReleaseOnePoll();
+        await gate.WaitForPollAsync();
 
         Assert.False(runTask.IsCompleted);
         Assert.False(child.WasKilled);
 
         // Let ExecuteAsync return by having the child exit.
         child.SimulateExit(0, "done");
-        await gate.ReleaseOnePoll();
+        gate.ReleaseOnePoll();
         await runTask;
     }
 
@@ -870,8 +873,9 @@ public async Task RunVsCodeTunnelTool_ObtainsStatusOnlyViaSharedComponent_DoesNo
 
         var runTask = tool.ExecuteAsync(this.Context());
 
-        await gate.ReleaseOnePoll();
-        await gate.ReleaseOnePoll();
+        await gate.WaitForPollAsync();
+        gate.ReleaseOnePoll();
+        await gate.WaitForPollAsync();
 
         // The runner obtained status solely through the shared resolver and performed no
         // independent `code tunnel status` invocation.
@@ -879,7 +883,7 @@ public async Task RunVsCodeTunnelTool_ObtainsStatusOnlyViaSharedComponent_DoesNo
         Assert.DoesNotContain(cliCalls, c => c.Arguments.Contains("status"));
 
         child.SimulateExit(0, "done");
-        await gate.ReleaseOnePoll();
+        gate.ReleaseOnePoll();
         await runTask;
     }
 }
diff --git a/Phantom.Workspaces.Tests/UrlOpenerTests.cs b/Phantom.Workspaces.Tests/UrlOpenerTests.cs
index 92fe36ee..5e54951f 100644
--- a/Phantom.Workspaces.Tests/UrlOpenerTests.cs
+++ b/Phantom.Workspaces.Tests/UrlOpenerTests.cs
@@ -43,6 +43,49 @@ private static (UrlOpener Opener, FakeTabService Tabs, List<string> ExternalUrls
         return (opener, tabs, external);
     }
 
+    [Fact]
+    public async Task CreateDefault_LauncherReturnsTrue_DoesNotUseShellFallback()
+    {
+        var tabs = new FakeTabService();
+        var launched = new List<Uri>();
+        var shellUrls = new List<string>();
+        var opener = UrlOpener.CreateDefault(tabs, () => null,
+            launchUri: uri => { launched.Add(uri); return Task.FromResult(true); },
+            shellLauncher: url => { shellUrls.Add(url); return Task.CompletedTask; });
+
+        await opener.OpenAsync(new OpenUrlRequest("mailto:someone@example.com"), TestContext.Current.CancellationToken);
+
+        Assert.Equal("mailto:someone@example.com", Assert.Single(launched).OriginalString);
+        Assert.Empty(shellUrls);
+        Assert.Empty(tabs.OpenedTabs);
+        Assert.Empty(tabs.TryFocusUrls);
+    }
+
+    [Fact]
+    public async Task CreateDefault_LauncherReturnsFalse_FallsBackToShell()
+    {
+        var urls = new List<string>();
+        var opener = UrlOpener.CreateDefault(new FakeTabService(), () => null,
+            launchUri: _ => Task.FromResult(false),
+            shellLauncher: url => { urls.Add(url); return Task.CompletedTask; });
+
+        await opener.OpenAsync(new OpenUrlRequest("mailto:someone@example.com"), TestContext.Current.CancellationToken);
+
+        Assert.Equal(new[] { "mailto:someone@example.com" }, urls);
+    }
+
+    [Fact]
+    public async Task CreateDefault_ShellLauncherFails_PropagatesFailure()
+    {
+        var opener = UrlOpener.CreateDefault(new FakeTabService(), () => null,
+            launchUri: null,
+            shellLauncher: _ => throw new InvalidOperationException("No handler available"));
+
+        var error = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => opener.OpenAsync(new OpenUrlRequest("tel:+15551234567"), TestContext.Current.CancellationToken));
+        Assert.Equal("No handler available", error.Message);
+    }
+
     [Fact]
     public async Task OpenAsync_Auto_HttpUrl_OpensEmbeddedWebViewModelTab()
     {
diff --git a/Phantom.Workspaces/Controls/EntityCardControl.axaml b/Phantom.Workspaces/Controls/EntityCardControl.axaml
index 0ab74e0a..3cdb6fb0 100644
--- a/Phantom.Workspaces/Controls/EntityCardControl.axaml
+++ b/Phantom.Workspaces/Controls/EntityCardControl.axaml
@@ -8,6 +8,7 @@
         <converters:StatusBrushKeyConverter x:Key="StatusBrushKeyConverter" />
     </UserControl.Resources>
     <StackPanel Classes="workspace-entity-card-content"
+                Background="Transparent"
                 Classes.workspace-entity-deleted="{Binding IsDeleted}"
                 IsEnabled="{Binding IsInteractive}"
                 Tapped="OnEntityCardTapped">
@@ -52,6 +53,7 @@
                             <ItemsControl.ItemTemplate>
                                 <DataTemplate>
                                     <Button Content="{Binding Glyph}"
+                                            ContentTemplate="{StaticResource CopyableCardButtonContentTemplate}"
                                             ToolTip.Tip="{Binding Tooltip}"
                                              Classes="entity-card-action-button entity-card-interest-button"
                                              Classes.highlighted="{Binding IsActive}"
@@ -74,13 +76,14 @@
                                     <Border Classes="status-badge"
                                             Background="{Binding BrushKey, Converter={StaticResource StatusBrushKeyConverter}}"
                                             ToolTip.Tip="{Binding Tooltip}">
-                                        <TextBlock Text="{Binding StatusValue}"
-                                                   Classes="status-badge-text" />
+                                        <sharedControls:SafeSelectableTextBlock Text="{Binding StatusValue}"
+                                                                                 Classes="status-badge-text" />
                                     </Border>
                                 </DataTemplate>
                             </ItemsControl.ItemTemplate>
                         </ItemsControl>
                         <Button Content="{Binding EditModeGlyph}"
+                                ContentTemplate="{StaticResource CopyableCardButtonContentTemplate}"
                                 ToolTip.Tip="Toggle edit mode"
                                 Classes="entity-card-action-button"
                                 IsVisible="{Binding ShowEditIndicator}"
@@ -97,6 +100,7 @@
                             <ItemsControl.ItemTemplate>
                                 <DataTemplate>
                                     <Button Content="{Binding Shortcut.Label}"
+                                            ContentTemplate="{StaticResource CopyableCardButtonContentTemplate}"
                                             ToolTip.Tip="{Binding Shortcut.HoverText}"
                                             IsEnabled="{Binding IsEnabled}"
                                             Classes="entity-card-action-button"
@@ -107,16 +111,19 @@
                             </ItemsControl.ItemTemplate>
                         </ItemsControl>
                         <Button Content="{Binding JsonButtonText}"
+                                ContentTemplate="{StaticResource CopyableCardButtonContentTemplate}"
                                 Classes="entity-card-action-button"
                                 IsVisible="{Binding ShowJsonButton}"
                                 Command="{Binding ToggleJsonViewCommand}"
                                 Tapped="OnInteractiveChildTapped" />
                         <Button Content="💾"
+                                ContentTemplate="{StaticResource CopyableCardButtonContentTemplate}"
                                   Classes="entity-card-action-button"
                                 IsVisible="{Binding ShowEditActions}"
                                 Command="{Binding SaveEditModeCommand}"
                                 Tapped="OnInteractiveChildTapped" />
                         <Button Content="✖"
+                                ContentTemplate="{StaticResource CopyableCardButtonContentTemplate}"
                                  Classes="entity-card-action-button"
                                  IsVisible="{Binding ShowEditActions}"
                                  Command="{Binding DiscardEditModeCommand}"
@@ -125,7 +132,7 @@
                 </DockPanel>
                 <ItemsControl ItemsSource="{Binding FieldEditors}"
                               Classes="workspace-field-editor-list"
-                              IsVisible="{Binding ExternalCard, Converter={x:Static ObjectConverters.IsNull}}" />
+                              IsVisible="{Binding ShowFieldEditors}" />
                 <ContentControl Content="{Binding ExternalCard}"
                                 IsVisible="{Binding ExternalCard, Converter={x:Static ObjectConverters.IsNotNull}}" />
                 <TextBox Text="{Binding RawJsonText, Mode=TwoWay}"
@@ -139,7 +146,3 @@
                            Classes.workspace-validation-error="{Binding Validation.HasError}" />
     </StackPanel>
 </UserControl>
-
-
-
-
diff --git a/Phantom.Workspaces/Controls/EntityCardControl.axaml.cs b/Phantom.Workspaces/Controls/EntityCardControl.axaml.cs
index a65ab228..6bbfb460 100644
--- a/Phantom.Workspaces/Controls/EntityCardControl.axaml.cs
+++ b/Phantom.Workspaces/Controls/EntityCardControl.axaml.cs
@@ -2,6 +2,7 @@
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.VisualTree;
+using Phantom.Workspaces.Gui.Shared.Controls;
 using Phantom.Workspaces.ViewModels;
 
 namespace Phantom.Workspaces.Controls;
@@ -37,6 +38,17 @@ internal void OnEntityCardTapped(object? sender, TappedEventArgs e)
             return;
         }
 
+        // A tap on selectable content is for positioning the selection/caret, not opening
+        // another card (which would detach the focused control and discard its selection).
+        for (var visual = e.Source as Avalonia.Visual; visual is not null && visual != this; visual = visual.GetVisualParent())
+        {
+            if (visual is SelectableTextBlock or TextBox or Button or Expander)
+            {
+                e.Handled = true;
+                return;
+            }
+        }
+
         ActivateCard();
         e.Handled = true;
     }
diff --git a/Phantom.Workspaces/Controls/EntityTreePanel.cs b/Phantom.Workspaces/Controls/EntityTreePanel.cs
new file mode 100644
index 00000000..acdde607
--- /dev/null
+++ b/Phantom.Workspaces/Controls/EntityTreePanel.cs
@@ -0,0 +1,221 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using System.Runtime.CompilerServices;
+
+namespace Phantom.Workspaces.Controls;
+
+/// <summary>Opt-in panel selection for entity trees, based on all object nodes, not just roots.</summary>
+public static class EntityTreePanel
+{
+    private static readonly ConditionalWeakTable<TreeView, TransitionState> Transitions = new();
+
+    private sealed class TransitionState
+    {
+        public int Generation;
+        public Action? Cancel;
+    }
+
+    public static readonly AttachedProperty<int> NodeCountProperty =
+        AvaloniaProperty.RegisterAttached<TreeView, int>("NodeCount", typeof(EntityTreePanel), -1);
+
+    static EntityTreePanel()
+    {
+        NodeCountProperty.Changed.AddClassHandler<TreeView>((tree, _) => UpdatePanel(tree));
+    }
+
+    public static int GetNodeCount(TreeView tree) => tree.GetValue(NodeCountProperty);
+
+    public static void SetNodeCount(TreeView tree, int count) => tree.SetValue(NodeCountProperty, count);
+
+    private static void UpdatePanel(TreeView tree)
+    {
+        bool small = GetNodeCount(tree) < 100;
+        if (tree.Classes.Contains("entity-card-tree-small") == small)
+        {
+            return;
+        }
+
+        var transition = Transitions.GetOrCreateValue(tree);
+        transition.Cancel?.Invoke();
+        int generation = ++transition.Generation;
+        bool restored = false;
+        var scroll = tree.GetVisualDescendants().OfType<ScrollViewer>().FirstOrDefault();
+        var offset = scroll?.Offset;
+        var expanded = tree.GetVisualDescendants().OfType<TreeViewItem>()
+            .Where(item => item.IsExpanded).Select(item => item.DataContext).ToHashSet();
+        var anchor = scroll is null ? null : tree.GetVisualDescendants().OfType<TreeViewItem>()
+            .Select(item => (Item: item, Position: item.TranslatePoint(default, scroll!)))
+            .Where(entry => entry.Position is { } position &&
+                position.Y <= 0 && position.Y + entry.Item.Bounds.Height > 0)
+            .OrderByDescending(entry => entry.Position!.Value.Y)
+            .FirstOrDefault().Item;
+        var anchorItem = anchor?.DataContext;
+        var anchorY = anchor?.TranslatePoint(default, scroll!)?.Y;
+        var focused = tree.GetVisualDescendants().OfType<Control>()
+            .FirstOrDefault(control => control.IsFocused);
+        var focusedContainer = focused as TreeViewItem ??
+            focused?.GetVisualAncestors().OfType<TreeViewItem>().FirstOrDefault();
+        var focusedItem = focusedContainer?.DataContext;
+        var focusedDataContext = focused?.DataContext;
+        var focusPath = new List<int>();
+        for (Visual? current = focused; current is not null && current != focusedContainer;
+             current = current.GetVisualParent())
+        {
+            if (current.GetVisualParent() is { } parent)
+            {
+                focusPath.Add(parent.GetVisualChildren().ToList().IndexOf(current));
+            }
+        }
+        focusPath.Reverse();
+
+        bool FocusReplacement(TreeViewItem container)
+        {
+            InputElement? target = null;
+            if (focusedDataContext is not null &&
+                !ReferenceEquals(focusedDataContext, focusedItem))
+            {
+                target = container.GetVisualDescendants().OfType<Control>()
+                    .FirstOrDefault(control =>
+                        control.GetType() == focused?.GetType() &&
+                        ReferenceEquals(control.DataContext, focusedDataContext));
+            }
+            if (target is null)
+            {
+                Visual? replacement = container;
+                foreach (int index in focusPath)
+                {
+                    var children = replacement?.GetVisualChildren().ToList();
+                    replacement = children is not null && index >= 0 && index < children.Count
+                        ? children[index] : null;
+                }
+                target = replacement as InputElement ?? container;
+            }
+            target.Focus();
+            return target.IsFocused;
+        }
+
+        tree.Classes.Set("entity-card-tree-small", small);
+        if (scroll is null)
+        {
+            return;
+        }
+
+        void Restore(object? sender, EventArgs args)
+        {
+            if (restored || transition.Generation != generation)
+            {
+                Cancel();
+                return;
+            }
+
+            if (tree.ItemsPanelRoot is null ||
+                (tree.ItemsPanelRoot is VirtualizingStackPanel) == small)
+            {
+                return;
+            }
+
+            Cancel();
+            restored = true;
+            foreach (var container in tree.GetVisualDescendants().OfType<TreeViewItem>())
+            {
+                if (expanded.Contains(container.DataContext))
+                {
+                    container.IsExpanded = true;
+                }
+            }
+
+            // The desktop can complete a panel layout before a Loaded callback runs. Correct the
+            // realized anchor and focus now so a live threshold change cannot visibly jump.
+            bool focusRestored = false;
+            if (focusedItem is not null && focused?.IsAttachedToVisualTree() != true)
+            {
+                var replacement = tree.GetVisualDescendants().OfType<TreeViewItem>()
+                    .FirstOrDefault(item => ReferenceEquals(item.DataContext, focusedItem));
+                if (replacement is not null)
+                {
+                    focusRestored = FocusReplacement(replacement);
+                    tree.UpdateLayout();
+                }
+            }
+            if (anchorItem is not null && anchorY is { } oldY)
+            {
+                var currentAnchor = tree.GetVisualDescendants().OfType<TreeViewItem>()
+                    .FirstOrDefault(item => ReferenceEquals(item.DataContext, anchorItem));
+                if (currentAnchor?.TranslatePoint(default, scroll)?.Y is { } currentY)
+                {
+                    scroll.Offset = new Vector(scroll.Offset.X,
+                        Math.Max(0, scroll.Offset.Y + currentY - oldY));
+                }
+            }
+
+            Dispatcher.UIThread.Post(() =>
+            {
+                if (transition.Generation != generation || !tree.IsAttachedToVisualTree())
+                {
+                    return;
+                }
+
+                if (anchorItem is not null && tree.ContainerFromItem(anchorItem) is null)
+                {
+                    tree.ScrollIntoView(anchorItem);
+                    tree.UpdateLayout();
+                }
+
+                bool focusRequiresScroll = false;
+                if (!focusRestored && focusedItem is not null && focused?.IsAttachedToVisualTree() != true)
+                {
+                    var container = tree.GetVisualDescendants().OfType<TreeViewItem>()
+                        .FirstOrDefault(candidate => ReferenceEquals(candidate.DataContext, focusedItem));
+                    if (container is null)
+                    {
+                        tree.ScrollIntoView(focusedItem);
+                        tree.UpdateLayout();
+                        container = tree.GetVisualDescendants().OfType<TreeViewItem>()
+                            .FirstOrDefault(candidate => ReferenceEquals(candidate.DataContext, focusedItem));
+                        focusRequiresScroll = container is not null;
+                    }
+
+                    if (container is not null)
+                    {
+                        FocusReplacement(container);
+                    }
+                }
+
+                if (!focusRequiresScroll && offset is { } oldOffset)
+                {
+                    if (anchorItem is not null && anchorY is { } y)
+                    {
+                        var newAnchor = tree.GetVisualDescendants().OfType<TreeViewItem>()
+                            .FirstOrDefault(candidate => ReferenceEquals(candidate.DataContext, anchorItem));
+                        var newY = newAnchor?.TranslatePoint(default, scroll)?.Y;
+                        scroll.Offset = new Vector(oldOffset.X,
+                            newY is { } actualY
+                                ? Math.Max(0, scroll.Offset.Y + actualY - y)
+                                : oldOffset.Y);
+                    }
+                    else
+                    {
+                        scroll.Offset = oldOffset;
+                    }
+                }
+            }, DispatcherPriority.Loaded);
+        }
+
+        void Cancel()
+        {
+            tree.LayoutUpdated -= Restore;
+            if (transition.Generation == generation)
+            {
+                transition.Cancel = null;
+            }
+        }
+
+        transition.Cancel = Cancel;
+        tree.LayoutUpdated += Restore;
+        // A panel replacement may finish layout synchronously before the handler is attached.
+        Dispatcher.UIThread.Post(() => Restore(tree, EventArgs.Empty), DispatcherPriority.Loaded);
+    }
+}
diff --git a/Phantom.Workspaces/MainWindow.axaml b/Phantom.Workspaces/MainWindow.axaml
index c71cd86a..3b59cbe6 100644
--- a/Phantom.Workspaces/MainWindow.axaml
+++ b/Phantom.Workspaces/MainWindow.axaml
@@ -223,6 +223,7 @@
                      scroll plus below-minimum horizontal scroll), and wraps content to the viewport. -->
                 <TreeView Grid.Row="1"
                           Classes="entity-card-tree entity-card-tree-entity entity-card-tree-sticky"
+                          controls:EntityTreePanel.NodeCount="{Binding CurrentViewPopulation.Entities.Count}"
                           HorizontalAlignment="Stretch"
                           ItemsSource="{Binding CurrentViewPopulation.RootEntities}">
                     <TreeView.Styles>
@@ -286,4 +287,3 @@
 </Window>
 
 
-
diff --git a/Phantom.Workspaces/Phantom.Workspaces.csproj b/Phantom.Workspaces/Phantom.Workspaces.csproj
index 0eccd3d2..5cc30fd2 100644
--- a/Phantom.Workspaces/Phantom.Workspaces.csproj
+++ b/Phantom.Workspaces/Phantom.Workspaces.csproj
@@ -99,9 +99,10 @@
     <Error Condition="!Exists('$(PublishDir)runtimes\$(RuntimeIdentifier)\native\phantom-copilot-wrapper.exe')"
            Text="The Copilot MXC wrapper was not published as a loose file." />
   </Target>
+  <Import Project="..\scripts\CopilotWrapperPrerequisiteLease.targets" />
   <Target Name="ValidatePreparedCopilotPayload"
           BeforeTargets="PublishCopilotWrapperLoose;PublishCopilotRuntimeLoose;PublishMxcRuntimeLoose"
-          Condition="'$(UsePreparedCopilotPayloadForTests)' != '' Or '$(PreparedCopilotPayloadDirectory)' != '' Or '$(PreparedCopilotPayloadFingerprint)' != '' Or '$(PreparedCopilotPayloadConfiguration)' != '' Or '$(PreparedCopilotPayloadRuntimeIdentifier)' != '' Or '$(PreparedCopilotPayloadManifestSha256)' != '' Or '$(PreparedCopilotWrapperSha256)' != '' Or '$(PreparedCopilotCliSha256)' != '' Or '$(PreparedCopilotSdkWrapperSha256)' != '' Or '$(PreparedCopilotRuntimeSha256)' != '' Or '$(PreparedCopilotNodeSha256)' != '' Or '$(PreparedCopilotLicenseSha256)' != '' Or '$(PreparedMxcFfiSha256)' != '' Or '$(PreparedPlmSha256)' != '' Or '$(PreparedMxcLicenseSha256)' != '' Or '$(SimulateMissingCopilotWrapperChildOutputForTests)' != '' Or '$(UsePreparedCopilotPayload)' != '' Or '$(RequirePreparedCopilotWrapper)' != '' Or '$(CopilotWrapperPreparedExecutable)' != '' Or '$(CopilotWrapperPreparedConfiguration)' != '' Or '$(CopilotWrapperPreparedRuntimeIdentifier)' != ''">
+          Condition="'$(UsePreparedCopilotPayloadForTests)' != '' Or '$(PreparedCopilotPayloadCacheRoot)' != '' Or '$(PreparedCopilotPayloadDirectory)' != '' Or '$(PreparedCopilotPayloadFingerprint)' != '' Or '$(PreparedCopilotPayloadConfiguration)' != '' Or '$(PreparedCopilotPayloadRuntimeIdentifier)' != '' Or '$(PreparedCopilotPayloadManifestSha256)' != '' Or '$(PreparedCopilotWrapperSha256)' != '' Or '$(PreparedCopilotCliSha256)' != '' Or '$(PreparedCopilotSdkWrapperSha256)' != '' Or '$(PreparedCopilotRuntimeSha256)' != '' Or '$(PreparedCopilotNodeSha256)' != '' Or '$(PreparedCopilotLicenseSha256)' != '' Or '$(PreparedMxcFfiSha256)' != '' Or '$(PreparedPlmSha256)' != '' Or '$(PreparedMxcLicenseSha256)' != '' Or '$(SimulateMissingCopilotWrapperChildOutputForTests)' != '' Or '$(UsePreparedCopilotPayload)' != '' Or '$(RequirePreparedCopilotWrapper)' != '' Or '$(CopilotWrapperPreparedExecutable)' != '' Or '$(CopilotWrapperPreparedConfiguration)' != '' Or '$(CopilotWrapperPreparedRuntimeIdentifier)' != ''">
     <Error Condition="'$(UsePreparedCopilotPayload)' != '' Or '$(RequirePreparedCopilotWrapper)' != '' Or '$(CopilotWrapperPreparedExecutable)' != '' Or '$(CopilotWrapperPreparedConfiguration)' != '' Or '$(CopilotWrapperPreparedRuntimeIdentifier)' != ''"
            Text="Legacy prepared Copilot properties are unsafe and are not supported." />
     <Error Condition="'$(UsePreparedCopilotPayloadForTests)' != 'true'"
@@ -110,6 +111,13 @@
            Text="SimulateMissingCopilotWrapperChildOutputForTests only accepts true in prepared test mode." />
     <Error Condition="'$(NoBuild)' != 'true'"
            Text="Prepared Copilot payload inputs may only be used by a build-free target invocation with NoBuild=true." />
+    <PropertyGroup>
+      <_PreparedCopilotPayloadExpectedCacheRoot Condition="'$(PreparedCopilotPayloadCacheRoot)' == ''">$([System.IO.Path]::GetFullPath('$(MSBuildProjectDirectory)\..\Phantom.Workspaces.Install.Tests\obj\mxcw'))</_PreparedCopilotPayloadExpectedCacheRoot>
+      <_PreparedCopilotPayloadExpectedCacheRoot Condition="'$(PreparedCopilotPayloadCacheRoot)' != ''">$(PreparedCopilotPayloadCacheRoot)</_PreparedCopilotPayloadExpectedCacheRoot>
+    </PropertyGroup>
+    <HoldCopilotWrapperPrerequisiteLease
+        CacheRoot="$(_PreparedCopilotPayloadExpectedCacheRoot)"
+        ProjectDirectory="$(MSBuildProjectDirectory)\..\Phantom.Workspaces.Install.Tests" />
     <Error Condition="'$(PreparedCopilotPayloadDirectory)' == '' Or !$([System.IO.Path]::IsPathFullyQualified('$(PreparedCopilotPayloadDirectory)')) Or !Exists('$(PreparedCopilotPayloadDirectory)')"
            Text="The prepared Copilot payload directory does not exist at '$(PreparedCopilotPayloadDirectory)'." />
     <Error Condition="'$(PreparedCopilotPayloadConfiguration)' != '$(Configuration)'"
@@ -122,7 +130,6 @@
       <_PreparedCopilotPayloadCacheDirectory>$([System.IO.Path]::GetDirectoryName('$(_PreparedCopilotPayloadCanonicalDirectory)'))</_PreparedCopilotPayloadCacheDirectory>
       <_PreparedCopilotPayloadCacheRoot>$([System.IO.Path]::GetDirectoryName('$(_PreparedCopilotPayloadCacheDirectory)'))</_PreparedCopilotPayloadCacheRoot>
       <_PreparedCopilotPayloadCacheName>$([System.IO.Path]::GetFileName('$(_PreparedCopilotPayloadCacheDirectory)'))</_PreparedCopilotPayloadCacheName>
-      <_PreparedCopilotPayloadExpectedCacheRoot>$([System.IO.Path]::GetFullPath('$(MSBuildProjectDirectory)\..\Phantom.Workspaces.Install.Tests\obj\mxcw'))</_PreparedCopilotPayloadExpectedCacheRoot>
       <_PreparedCopilotPayloadFingerprintFile>$(_PreparedCopilotPayloadCacheDirectory)\prerequisite.fingerprint</_PreparedCopilotPayloadFingerprintFile>
       <_PreparedCopilotPayloadManifestFile>$(_PreparedCopilotPayloadCacheDirectory)\prerequisite.json</_PreparedCopilotPayloadManifestFile>
       <_PreparedCopilotPayloadFingerprintPrefix Condition="$([System.String]::Copy('$(PreparedCopilotPayloadFingerprint)').Length) &gt;= 16">$([System.String]::Copy('$(PreparedCopilotPayloadFingerprint)').Substring(0, 16))</_PreparedCopilotPayloadFingerprintPrefix>
diff --git a/Phantom.Workspaces/Services/UrlOpener.cs b/Phantom.Workspaces/Services/UrlOpener.cs
index f18b1c3a..93175805 100644
--- a/Phantom.Workspaces/Services/UrlOpener.cs
+++ b/Phantom.Workspaces/Services/UrlOpener.cs
@@ -39,28 +39,44 @@ public UrlOpener(IWorkspaceTabService tabService, Func<string, Task> externalLau
     /// <summary>
     /// Convenience factory for production use: wraps <c>TopLevel.Launcher.LaunchUriAsync</c>
     /// (obtained via <paramref name="topLevelAccessor"/>) with a <c>Process.Start</c>
-    /// shell-execute fallback.
+    /// shell-execute fallback when the launcher reports failure. Fallback failures propagate
+    /// to the caller.
     /// </summary>
     public static UrlOpener CreateDefault(
         IWorkspaceTabService tabService,
         Func<Avalonia.Controls.TopLevel?> topLevelAccessor)
+        => CreateDefault(tabService, topLevelAccessor, launchUri: null, shellLauncher: null);
+
+    internal static UrlOpener CreateDefault(
+        IWorkspaceTabService tabService,
+        Func<Avalonia.Controls.TopLevel?> topLevelAccessor,
+        Func<Uri, Task<bool>>? launchUri,
+        Func<string, Task>? shellLauncher)
     {
         return new UrlOpener(tabService, async url =>
         {
             var top = topLevelAccessor();
-            if (top?.Launcher is { } launcher && Uri.TryCreate(url, UriKind.Absolute, out var launchUri))
+            if (Uri.TryCreate(url, UriKind.Absolute, out var uri)
+                && (launchUri is not null || top?.Launcher is not null))
             {
-                await launcher.LaunchUriAsync(launchUri).ConfigureAwait(false);
-                return;
+                var launched = launchUri is not null
+                    ? await launchUri(uri).ConfigureAwait(false)
+                    : await top!.Launcher.LaunchUriAsync(uri).ConfigureAwait(false);
+                if (launched)
+                {
+                    return;
+                }
             }
 
-            try
+            if (shellLauncher is not null)
             {
-                Process.Start(new ProcessStartInfo { FileName = url, UseShellExecute = true });
+                await shellLauncher(url).ConfigureAwait(false);
+                return;
             }
-            catch
+
+            if (Process.Start(new ProcessStartInfo { FileName = url, UseShellExecute = true }) is null)
             {
-                // Best-effort: leave the failure to the user; nothing else we can do.
+                throw new InvalidOperationException($"No application could open the URL: {url}");
             }
         });
     }
diff --git a/Phantom.Workspaces/Templates/EntityBrowserWorkspaceTabView.axaml b/Phantom.Workspaces/Templates/EntityBrowserWorkspaceTabView.axaml
index 892b860b..e1d9a024 100644
--- a/Phantom.Workspaces/Templates/EntityBrowserWorkspaceTabView.axaml
+++ b/Phantom.Workspaces/Templates/EntityBrowserWorkspaceTabView.axaml
@@ -2,6 +2,7 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:vm="using:Phantom.Workspaces.ViewModels"
              xmlns:controls="using:Phantom.Workspaces.Gui.Shared.Controls"
+             xmlns:appControls="using:Phantom.Workspaces.Controls"
              x:Class="Phantom.Workspaces.Templates.EntityBrowserWorkspaceTabView"
              x:DataType="vm:EntityBrowserWorkspaceTabViewModel">
     <Grid RowDefinitions="Auto,*">
@@ -36,7 +37,7 @@
         <TreeView Grid.Row="1"
                   x:Name="BrowserTreeView"
                   Classes="entity-card-tree entity-card-tree-entity entity-card-tree-sticky"
+                  appControls:EntityTreePanel.NodeCount="{Binding EntityList.NodeCount}"
                   ItemsSource="{Binding EntityList.Items}" />
     </Grid>
 </UserControl>
-
diff --git a/Phantom.Workspaces/Templates/WorkspaceDataTemplates.axaml b/Phantom.Workspaces/Templates/WorkspaceDataTemplates.axaml
index f2af0f99..acce0b76 100644
--- a/Phantom.Workspaces/Templates/WorkspaceDataTemplates.axaml
+++ b/Phantom.Workspaces/Templates/WorkspaceDataTemplates.axaml
@@ -28,6 +28,39 @@
         </StackPanel>
     </DataTemplate>
 
+    <DataTemplate DataType="vm:ViewWorkspaceTabViewModel">
+        <Grid RowDefinitions="Auto,*">
+            <Border Grid.Row="0" Padding="12,8" BorderThickness="0,0,0,1" BorderBrush="Gray">
+                <DockPanel LastChildFill="True">
+                    <Button DockPanel.Dock="Right"
+                            Content="View definition / Edit definition"
+                            Command="{Binding EditDefinitionCommand}" />
+                    <TextBlock DockPanel.Dock="Left" Text="{Binding Definition.Title}" VerticalAlignment="Center" />
+                    <CheckBox DockPanel.Dock="Right" Content="Hide unmatched"
+                              Margin="8,0" IsChecked="{Binding HideUnmatched}" />
+                    <TextBox PlaceholderText="Find in view"
+                             Text="{Binding SearchText, Mode=TwoWay}"
+                             Margin="12,0" />
+                </DockPanel>
+            </Border>
+            <TreeView Grid.Row="1"
+                      Classes="entity-card-tree entity-card-tree-entity"
+                      ItemsSource="{Binding Population.RootEntities}">
+                <TreeView.Styles>
+                    <Style Selector="TreeViewItem" x:DataType="vm:ViewEntityViewModel">
+                        <Setter Property="IsVisible" Value="{Binding IsVisible}"/>
+                    </Style>
+                </TreeView.Styles>
+                <TreeView.ItemTemplate>
+                    <TreeDataTemplate x:DataType="vm:ViewEntityViewModel"
+                                      ItemsSource="{Binding Children}">
+                        <ContentControl Content="{Binding EntityCardNode}" />
+                    </TreeDataTemplate>
+                </TreeView.ItemTemplate>
+            </TreeView>
+        </Grid>
+    </DataTemplate>
+
     <!-- Issue #1066: the single-entity view reuses the same entity-card shell chrome as tree
          cards, hosted in a top-margined, horizontally centered ScrollViewer capped to ~1/3 of the
          pane width, and shares the #1064 two-regime scroll handling (content wraps to the capped
@@ -156,12 +189,12 @@
               RowDefinitions="Auto,Auto">
             <controls:SafeSelectableTextBlock Text="{Binding FieldName}" Classes="muted workspace-field-label" />
             <!-- Read mode: navigable link to the referenced entity (resolved display name). -->
-            <Button Grid.Column="1" Grid.Row="0"
-                    Content="{Binding ResolvedDisplayName}"
+            <controls:CopyableLinkTextBlock Grid.Column="1" Grid.Row="0"
+                    Text="{Binding ResolvedDisplayName}"
                     ToolTip.Tip="{Binding TooltipText}"
                     Command="{Binding OpenCommand}"
-                    IsEnabled="{Binding CanOpen}"
                     Classes="workspace-entity-reference-link"
+                    Classes.available="{Binding CanOpen}"
                     HorizontalAlignment="Left"
                     IsVisible="{Binding IsReadMode}" />
             <!-- Edit mode: search box plus candidate results. -->
@@ -178,6 +211,7 @@
                         <Button Command="{Binding SelectCommand}"
                                 ToolTip.Tip="{Binding Names}"
                                 Content="{Binding DisplayName}"
+                                ContentTemplate="{StaticResource CopyableCardButtonContentTemplate}"
                                 HorizontalAlignment="Stretch"
                                 HorizontalContentAlignment="Left"
                                 Classes="workspace-entity-reference-candidate" />
@@ -196,11 +230,11 @@
                           ItemsSource="{Binding Items}">
                 <ItemsControl.ItemTemplate>
                     <DataTemplate>
-                        <Button Content="{Binding DisplayName}"
+                        <controls:CopyableLinkTextBlock Text="{Binding DisplayName}"
                                 ToolTip.Tip="{Binding TooltipText}"
                                 Command="{Binding OpenCommand}"
-                                IsEnabled="{Binding CanOpen}"
                                 Classes="workspace-entity-reference-link"
+                                Classes.available="{Binding CanOpen}"
                                 HorizontalAlignment="Left" />
                     </DataTemplate>
                 </ItemsControl.ItemTemplate>
@@ -301,6 +335,11 @@
 
     <DataTemplate DataType="vm:PlainMimeAttachmentFieldEditorViewModel">
         <Expander Header="{Binding FieldName}" Classes="workspace-field-expander">
+            <Expander.HeaderTemplate>
+                <DataTemplate>
+                    <controls:SafeSelectableTextBlock Text="{Binding}" />
+                </DataTemplate>
+            </Expander.HeaderTemplate>
             <StackPanel Classes="workspace-mime-content">
                 <Grid Classes="workspace-field-row"
                       ColumnDefinitions="Auto,*">
@@ -354,6 +393,11 @@
             <Expander Header="{Binding FieldName}"
                       Classes="workspace-field-expander"
                       IsVisible="{Binding ShowChrome}">
+                <Expander.HeaderTemplate>
+                    <DataTemplate>
+                        <controls:SafeSelectableTextBlock Text="{Binding}" />
+                    </DataTemplate>
+                </Expander.HeaderTemplate>
                 <StackPanel Classes="workspace-mime-content">
                     <Grid Classes="workspace-field-row"
                           ColumnDefinitions="Auto,*">
@@ -438,12 +482,22 @@
 
     <DataTemplate DataType="vm:ArrayFieldEditorViewModel">
         <Expander Header="{Binding FieldName}" Classes="workspace-field-expander">
+            <Expander.HeaderTemplate>
+                <DataTemplate>
+                    <controls:SafeSelectableTextBlock Text="{Binding}" />
+                </DataTemplate>
+            </Expander.HeaderTemplate>
             <ItemsControl ItemsSource="{Binding Items}" Classes="workspace-field-items" />
         </Expander>
     </DataTemplate>
 
     <DataTemplate DataType="vm:ObjectFieldEditorViewModel">
         <Expander Header="{Binding FieldName}" Classes="workspace-field-expander">
+            <Expander.HeaderTemplate>
+                <DataTemplate>
+                    <controls:SafeSelectableTextBlock Text="{Binding}" />
+                </DataTemplate>
+            </Expander.HeaderTemplate>
             <ItemsControl ItemsSource="{Binding Fields}" Classes="workspace-field-items" />
         </Expander>
     </DataTemplate>
@@ -493,18 +547,23 @@
         <ItemsControl ItemsSource="{Binding Urls}">
             <ItemsControl.ItemTemplate>
                 <DataTemplate DataType="vm:ExternalUrlViewModel">
-                    <StackPanel Orientation="Horizontal" Spacing="4">
+                    <Grid ColumnDefinitions="Auto,*" RowDefinitions="Auto,Auto">
                         <controls:SafeSelectableTextBlock Text="{Binding Key}"
                                    IsVisible="{Binding ShowKey}"
                                    Classes="muted workspace-field-label" />
-                        <Button Content="{Binding Url}"
+                        <controls:CopyableLinkTextBlock Grid.Column="1"
+                                Text="{Binding Url}"
                                 Classes="workspace-url-link"
+                                Classes.available="{Binding IsSupported}"
                                 Command="{Binding OpenCommand}"
                                 HorizontalAlignment="Left" />
-                    </StackPanel>
+                        <controls:SafeSelectableTextBlock Grid.Row="1" Grid.Column="1"
+                                                          Text="{Binding ErrorMessage}"
+                                                          IsVisible="{Binding HasError}"
+                                                          Classes="muted" />
+                    </Grid>
                 </DataTemplate>
             </ItemsControl.ItemTemplate>
         </ItemsControl>
     </DataTemplate>
 </DataTemplates>
-
diff --git a/Phantom.Workspaces/ViewModels/BadgesViewModel.cs b/Phantom.Workspaces/ViewModels/BadgesViewModel.cs
index 0590e9ac..ce2b9b52 100644
--- a/Phantom.Workspaces/ViewModels/BadgesViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/BadgesViewModel.cs
@@ -20,6 +20,14 @@ public BadgesViewModel(
 
     public ObservableCollection<BadgeModel> Badges { get; }
 
+    internal void Detach()
+    {
+        if (this.badgesModel.Badges is INotifyCollectionChanged notifyCollectionChanged)
+        {
+            notifyCollectionChanged.CollectionChanged -= this.OnBadgesChanged;
+        }
+    }
+
     private void OnBadgesChanged(
         object? sender,
         NotifyCollectionChangedEventArgs e)
diff --git a/Phantom.Workspaces/ViewModels/EntityCardViewModel.cs b/Phantom.Workspaces/ViewModels/EntityCardViewModel.cs
index fee01cf9..bb0dce49 100644
--- a/Phantom.Workspaces/ViewModels/EntityCardViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/EntityCardViewModel.cs
@@ -9,6 +9,7 @@
 using System.Windows.Input;
 using Avalonia.Threading;
 using Phantom.Workspaces.Data;
+using Phantom.Workspaces.Services;
 
 namespace Phantom.Workspaces.ViewModels;
 
@@ -29,7 +30,9 @@ public sealed class EntityCardViewModel : ViewModelBase
 
     private readonly SubscribedEntityViewModel? entity;
     private readonly FieldEditorFactory? fieldEditorFactory;
-    private readonly string cardViewName;
+    private readonly Func<IUrlOpener?>? urlOpenerProvider;
+    private readonly bool autoResolveCardView;
+    private string cardViewName;
     private readonly string displayName;
     private readonly string entityType;
     private readonly JsonValidationViewModel validation;
@@ -46,6 +49,7 @@ public sealed class EntityCardViewModel : ViewModelBase
     private ShortcutManager? shortcutManager;
     private IReadOnlyList<EntityShortcutViewModel> shortcuts = Array.Empty<EntityShortcutViewModel>();
     private CancellationTokenSource? shortcutResolutionCts;
+    private int disposed;
     // Issue #1177: field editors are built lazily on first realization instead of eagerly in the
     // constructor. This flag guards EnsureFieldEditorsBuilt so the build is scheduled at most once,
     // and it also gates the snapshot-change rebuild so unrealized cards do not re-launch schema work
@@ -60,16 +64,40 @@ public sealed class EntityCardViewModel : ViewModelBase
     // browser can defer its own FieldTypeResolver-based schema work until the card is realized.
     private Func<CancellationToken, Task<IReadOnlyCollection<EntityFieldEditorViewModel>>>? lazyFieldEditorBuilder;
 
+    public override async ValueTask DisposeAsync()
+    {
+        if (Interlocked.Exchange(ref this.disposed, 1) != 0)
+        {
+            return;
+        }
+
+        if (this.entity is not null)
+        {
+            this.entity.PropertyChanged -= this.OnEntityPropertyChanged;
+        }
+
+        this.shortcutResolutionCts?.Cancel();
+        await base.DisposeAsync();
+        this.shortcutResolutionCts?.Dispose();
+        this.shortcutResolutionCts = null;
+    }
+
     public EntityCardViewModel(
         SubscribedEntityViewModel entity,
         IReadOnlyCollection<EntityFieldEditorViewModel>? fieldEditors = null,
         string? cardViewName = null,
         IEntitySchemaComposer? schemaComposer = null,
-        FieldEditorFactory? fieldEditorFactory = null)
+        FieldEditorFactory? fieldEditorFactory = null,
+        Func<IUrlOpener?>? urlOpenerProvider = null,
+        bool autoResolveCardView = false)
     {
         this.entity = entity;
         this.fieldEditorFactory = fieldEditorFactory;
-        this.cardViewName = cardViewName ?? EntityCardViewResolver.RawViewName;
+        this.urlOpenerProvider = urlOpenerProvider;
+        this.autoResolveCardView = autoResolveCardView;
+        this.cardViewName = autoResolveCardView
+            ? new EntityCardViewResolver().ResolveViewName(entity)
+            : cardViewName ?? EntityCardViewResolver.RawViewName;
         this.displayName = entity.DisplayName;
         this.entityType = entity.EntityType;
         this.fieldEditors = fieldEditors ?? Array.Empty<EntityFieldEditorViewModel>();
@@ -90,7 +118,10 @@ public EntityCardViewModel(
             _ => this.IsEditMode);
         this.ToggleJsonViewCommand = entity.ToggleRawJsonVisibilityCommand;
         this.DeleteEntityCommand = entity.DeleteEntityCommand;
-        this.externalCard = this.cardViewName == "external" ? ExternalEntityCardViewModel.Create(entity) : null;
+        this.externalCard = this.HasExternalPresentation
+            ? ExternalEntityCardViewModel.Create(entity, () => this.urlOpenerProvider?.Invoke()
+                ?? this.shortcutMainWindowViewModel?.ApplicationServices.UrlOpener)
+            : null;
         // Issue #1177: do NOT eagerly build field editors here. Realizing the card control triggers
         // EnsureFieldEditorsBuilt via EntityCardControl.OnAttachedToVisualTree, so off-screen cards
         // in a virtualized tree pay no schema/type-resolution cost.
@@ -175,6 +206,10 @@ public EntityCardViewModel(
 
     public string CardViewName => this.cardViewName;
 
+    public bool ShowFieldEditors => this.cardViewName != "external";
+
+    private bool HasExternalPresentation => this.cardViewName is "external" or "external-note";
+
     public ExternalEntityCardViewModel? ExternalCard => this.externalCard;
 
     public IReadOnlyCollection<EntityFieldEditorViewModel> FieldEditors => this.fieldEditors;
@@ -581,15 +616,18 @@ private async Task BuildFieldEditorsAsync(CancellationToken ct = default)
             return;
         }
 
-        // Issue #1164: pass every non-abstract entity type so the factory can compose per-type
-        // presentations (e.g. a tool+note entity contributes the note's content field via the note
-        // entity-type-view, not just the primary "tool" type).
-        var entityTypeNames = this.entity.NonAbstractEntityTypeNames;
+        // The mixed card shows the note's curated content alongside the URL card, not fields
+        // contributed by any other types on the entity.
+        var entityTypeNames = this.cardViewName == "external-note"
+            ? (IReadOnlyList<string>)["note"]
+            : this.entity.NonAbstractEntityTypeNames;
         var built = await this.fieldEditorFactory
             .BuildFieldEditorsAsync(entityData, entityTypeNames)
             .ConfigureAwait(true);
 
-        this.SetFieldEditors(built);
+        this.SetFieldEditors(this.cardViewName == "external-note"
+            ? built.Where(editor => editor.FieldName == "content").ToArray()
+            : built);
     }
 
     private void SetFieldEditorEditMode(
@@ -750,6 +788,19 @@ private void OnEntityPropertyChanged(
 
         if (string.Equals(e.PropertyName, nameof(SubscribedEntityViewModel.Snapshot), StringComparison.Ordinal))
         {
+            if ((this.autoResolveCardView || this.cardViewName != EntityCardViewResolver.RawViewName)
+                && this.entity is not null)
+            {
+                var resolvedViewName = new EntityCardViewResolver().ResolveViewName(this.entity);
+                if (this.cardViewName != resolvedViewName)
+                {
+                    this.cardViewName = resolvedViewName;
+                    this.RaisePropertyChanged(nameof(this.CardViewName));
+                    this.RaisePropertyChanged(nameof(this.ShowFieldEditors));
+                    this.SetFieldEditors(Array.Empty<EntityFieldEditorViewModel>());
+                }
+            }
+
             this.RaisePropertyChanged(nameof(this.DisplayName));
             this.RaisePropertyChanged(nameof(this.EntityType));
             this.RaisePropertyChanged(nameof(this.EntityTypeLabels));
@@ -770,9 +821,13 @@ private void OnEntityPropertyChanged(
                 }
             }
 
-            if (this.cardViewName == "external" && this.entity is not null)
+            if (this.entity is not null)
             {
-                this.externalCard = ExternalEntityCardViewModel.Create(this.entity);
+                this.externalCard = this.HasExternalPresentation
+                    ? ExternalEntityCardViewModel.Create(
+                        this.entity, () => this.urlOpenerProvider?.Invoke()
+                            ?? this.shortcutMainWindowViewModel?.ApplicationServices.UrlOpener)
+                    : null;
                 this.RaisePropertyChanged(nameof(this.ExternalCard));
             }
 
diff --git a/Phantom.Workspaces/ViewModels/EntityCardViewResolver.cs b/Phantom.Workspaces/ViewModels/EntityCardViewResolver.cs
index d0e60dd3..ced36de7 100644
--- a/Phantom.Workspaces/ViewModels/EntityCardViewResolver.cs
+++ b/Phantom.Workspaces/ViewModels/EntityCardViewResolver.cs
@@ -8,8 +8,17 @@ public string ResolveViewName(
         SubscribedEntityViewModel entity,
         string? requestedViewName = null)
     {
-        if (!string.Equals(requestedViewName, RawViewName, System.StringComparison.Ordinal)
-            && entity.IsEntityType("external"))
+        if (string.Equals(requestedViewName, RawViewName, System.StringComparison.Ordinal))
+        {
+            return RawViewName;
+        }
+
+        if (entity.IsEntityType("external") && entity.IsEntityType("note"))
+        {
+            return "external-note";
+        }
+
+        if (entity.IsEntityType("external"))
         {
             return "external";
         }
diff --git a/Phantom.Workspaces/ViewModels/EntityListNodeViewModel.cs b/Phantom.Workspaces/ViewModels/EntityListNodeViewModel.cs
index 22d796fe..d26cf73b 100644
--- a/Phantom.Workspaces/ViewModels/EntityListNodeViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/EntityListNodeViewModel.cs
@@ -32,9 +32,12 @@ public EntityListNodeViewModel(
         IReadOnlyCollection<EntityFieldEditorViewModel>? fieldEditors = null,
         string? cardViewName = null,
         IEntitySchemaComposer? schemaComposer = null,
-        FieldEditorFactory? fieldEditorFactory = null)
+        FieldEditorFactory? fieldEditorFactory = null,
+        bool autoResolveCardView = false)
     {
-        this.Card = new EntityCardViewModel(entity, fieldEditors, cardViewName, schemaComposer, fieldEditorFactory);
+        this.Card = new EntityCardViewModel(
+            entity, fieldEditors, cardViewName, schemaComposer, fieldEditorFactory,
+            autoResolveCardView: autoResolveCardView);
         this.NameComponents = nameComponents;
         this.SortKey = sortKey;
         this.ToggleExpandCommand = new RelayCommand(
diff --git a/Phantom.Workspaces/ViewModels/EntityListViewModel.cs b/Phantom.Workspaces/ViewModels/EntityListViewModel.cs
index 75fda976..892e8d43 100644
--- a/Phantom.Workspaces/ViewModels/EntityListViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/EntityListViewModel.cs
@@ -8,6 +8,13 @@ public sealed class EntityListViewModel : ViewModelBase
 {
     public ObservableCollection<EntityListItemViewModel> Items { get; } = [];
 
+    public EntityListViewModel()
+    {
+        this.Items.CollectionChanged += (_, _) => this.RaisePropertyChanged(nameof(this.NodeCount));
+    }
+
+    public int NodeCount => this.Items.Count;
+
     /// <summary>
     /// Enumerates every node in tree order (matching the flat <see cref="Items"/> ordering by
     /// <c>Order</c>), yielding each node exactly once for find-cycling.
diff --git a/Phantom.Workspaces/ViewModels/EntityWorkspaceTabViewModel.cs b/Phantom.Workspaces/ViewModels/EntityWorkspaceTabViewModel.cs
index 9f5c2975..391cd0b1 100644
--- a/Phantom.Workspaces/ViewModels/EntityWorkspaceTabViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/EntityWorkspaceTabViewModel.cs
@@ -2,13 +2,13 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
+using System.Threading.Tasks;
 using Phantom.Workspaces.Data;
 
 namespace Phantom.Workspaces.ViewModels;
 
 public sealed class EntityWorkspaceTabViewModel : WorkspaceTabViewModel
 {
-    private readonly EntityCardViewResolver entityCardViewResolver = new();
     private readonly FieldEditorFactory? fieldEditorFactory;
     private readonly MainWindowViewModel? mainWindowViewModel;
     private EntityListNodeViewModel? entityCardNode;
@@ -42,8 +42,8 @@ public EntityListNodeViewModel? EntityCardNode
                 this.Entity,
                 nameComponents,
                 JsonSerializer.Serialize(nameComponents),
-                cardViewName: this.entityCardViewResolver.ResolveViewName(this.Entity),
-                fieldEditorFactory: this.fieldEditorFactory);
+                fieldEditorFactory: this.fieldEditorFactory,
+                autoResolveCardView: true);
 
             // The card resolves its own shortcuts when given a shortcut context, so the single-entity
             // view shows action buttons without going through ViewEntityViewModel.InitializeAsync.
@@ -60,6 +60,15 @@ public EntityListNodeViewModel? EntityCardNode
         }
     }
 
+    public override async ValueTask DisposeAsync()
+    {
+        if (this.entityCardNode is not null)
+        {
+            await this.entityCardNode.Card.DisposeAsync();
+        }
+        await base.DisposeAsync();
+    }
+
     private static IReadOnlyList<string> ResolveNameComponents(
         SubscribedEntityViewModel entity)
     {
diff --git a/Phantom.Workspaces/ViewModels/ExternalEntityCardViewModel.cs b/Phantom.Workspaces/ViewModels/ExternalEntityCardViewModel.cs
index ed854c4f..fa1510c5 100644
--- a/Phantom.Workspaces/ViewModels/ExternalEntityCardViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/ExternalEntityCardViewModel.cs
@@ -1,28 +1,32 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
+using System.Threading.Tasks;
+using Phantom.Workspaces.Services;
 
 namespace Phantom.Workspaces.ViewModels;
 
-public sealed class ExternalUrlViewModel
+public sealed class ExternalUrlViewModel : ViewModelBase
 {
-    public ExternalUrlViewModel(string key, string url, bool showKey)
+    private readonly Func<IUrlOpener?>? urlOpenerProvider;
+    private string? errorMessage;
+
+    public ExternalUrlViewModel(string key, string url, bool showKey, Func<IUrlOpener?>? urlOpenerProvider = null)
     {
         this.Key = key;
         this.Url = url;
         this.ShowKey = showKey;
-        this.OpenCommand = new RelayCommand(_ =>
+        this.urlOpenerProvider = urlOpenerProvider;
+        this.IsSupported = IsSupportedUrl(url);
+        if (!this.IsSupported)
         {
-            try
-            {
-                Process.Start(new ProcessStartInfo { FileName = url, UseShellExecute = true });
-            }
-            catch (Exception)
-            {
-                // Best-effort: if the URL cannot be opened, silently ignore.
-            }
-        });
+            this.ErrorMessage = "Invalid or unsupported URL.";
+        }
+
+        this.OpenCommand = new AsyncRelayCommand(
+            _ => this.OpenAsync(),
+            _ => this.IsSupported,
+            allowConcurrentExecutions: false);
     }
 
     public string Key { get; }
@@ -31,7 +35,59 @@ public ExternalUrlViewModel(string key, string url, bool showKey)
 
     public bool ShowKey { get; }
 
-    public RelayCommand OpenCommand { get; }
+    public bool IsSupported { get; }
+
+    public AsyncRelayCommand OpenCommand { get; }
+
+    public string? ErrorMessage
+    {
+        get => this.errorMessage;
+        private set
+        {
+            if (this.SetProperty(ref this.errorMessage, value))
+            {
+                this.RaisePropertyChanged(nameof(this.HasError));
+            }
+        }
+    }
+
+    public bool HasError => this.ErrorMessage is not null;
+
+    private static bool IsSupportedUrl(string url)
+    {
+        if (string.IsNullOrWhiteSpace(url) || !Uri.TryCreate(url, UriKind.Absolute, out var uri)
+            || !uri.IsWellFormedOriginalString())
+        {
+            return false;
+        }
+
+        return uri.Scheme switch
+        {
+            "http" or "https" => !string.IsNullOrEmpty(uri.Host) && string.IsNullOrEmpty(uri.UserInfo),
+            "mailto" or "tel" => !string.IsNullOrWhiteSpace(url[(uri.Scheme.Length + 1)..]),
+            _ => false,
+        };
+    }
+
+    private async Task OpenAsync()
+    {
+        try
+        {
+            var opener = this.urlOpenerProvider?.Invoke();
+            if (opener is null)
+            {
+                this.ErrorMessage = "URL opener is unavailable.";
+                return;
+            }
+
+            await opener.OpenAsync(new OpenUrlRequest(this.Url));
+            this.ErrorMessage = null;
+        }
+        catch (Exception ex)
+        {
+            this.ErrorMessage = $"Failed to open URL: {ex.Message}";
+        }
+    }
 }
 
 public sealed class ExternalEntityCardViewModel : ViewModelBase
@@ -46,12 +102,14 @@ private ExternalEntityCardViewModel(IReadOnlyList<ExternalUrlViewModel> urls)
     /// <summary>
     /// Builds an <see cref="ExternalEntityCardViewModel"/> from the URL map carried by an external entity.
     /// </summary>
-    public static ExternalEntityCardViewModel Create(SubscribedEntityViewModel entity)
+    public static ExternalEntityCardViewModel Create(
+        SubscribedEntityViewModel entity,
+        Func<IUrlOpener?>? urlOpenerProvider = null)
     {
         var urlMap = OpenExternalEntityShortcutHandler.ParseUrls(entity);
         bool suppressKey = urlMap.Count == 1 && urlMap.ContainsKey("default");
         var urls = urlMap
-            .Select(kvp => new ExternalUrlViewModel(kvp.Key, kvp.Value, showKey: !suppressKey))
+            .Select(kvp => new ExternalUrlViewModel(kvp.Key, kvp.Value, showKey: !suppressKey, urlOpenerProvider))
             .ToArray();
         return new ExternalEntityCardViewModel(urls);
     }
diff --git a/Phantom.Workspaces/ViewModels/MainWindowViewModel.cs b/Phantom.Workspaces/ViewModels/MainWindowViewModel.cs
index e8b6b577..5db5b8b3 100644
--- a/Phantom.Workspaces/ViewModels/MainWindowViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/MainWindowViewModel.cs
@@ -421,6 +421,7 @@ public bool ShowHiddenItems
                 _ = this.UpdateSelectedViewIncrementallyAsync(
                     changedEntityIds: null,
                     hasQueryMembershipChanges: true);
+                _ = this.RefreshViewTabsAsync(changedEntityIds: null, hasQueryMembershipChanges: true);
             }
         }
     }
@@ -1441,13 +1442,13 @@ private static ViewDefinitionViewModel CreateTopLevelView(
 
     private async Task ApplySelectedViewAsync()
     {
-        var next = new ViewPopulationViewModel();
+        var next = new ViewPopulationViewModel(this.expandedEntityIds);
         var previous = this.currentPopulation;
         this.CurrentViewPopulation = next;
 
         await previous.DisposeAsync();
 
-        await this.PopulateViewAsync(next);
+        await this.PopulateViewAsync(next, this.selectedTopLevelView ?? EmptyView);
     }
 
     /// <summary>
@@ -1460,8 +1461,7 @@ private async Task RebindPopulationAsync(ViewPopulationViewModel population)
     {
         // A population that is no longer current (already replaced by a navigation) must not resurrect
         // itself; only the displayed population rebinds.
-        if (!ReferenceEquals(this.currentPopulation, population)
-            || population.CancellationToken.IsCancellationRequested)
+        if (population.CancellationToken.IsCancellationRequested)
         {
             return;
         }
@@ -1469,13 +1469,22 @@ private async Task RebindPopulationAsync(ViewPopulationViewModel population)
         await this.UpdateSelectedViewIncrementallyAsync(
             changedEntityIds: null,
             hasQueryMembershipChanges: true,
-            targetPopulation: population);
+            targetPopulation: population,
+            view: this.GetViewForPopulation(population));
     }
 
+    private ViewDefinitionViewModel? GetViewForPopulation(ViewPopulationViewModel population) =>
+        ReferenceEquals(this.currentPopulation, population)
+            ? this.selectedTopLevelView
+            : this.WorkspacePanes.SelectMany(static pane => pane.Tabs)
+                .OfType<ViewWorkspaceTabViewModel>()
+                .FirstOrDefault(tab => ReferenceEquals(tab.Population, population))?.Definition;
+
     private async Task UpdateSelectedViewIncrementallyAsync(
         IReadOnlyCollection<EntityId>? changedEntityIds,
         bool hasQueryMembershipChanges,
-        ViewPopulationViewModel? targetPopulation = null)
+        ViewPopulationViewModel? targetPopulation = null,
+        ViewDefinitionViewModel? view = null)
     {
         // The broker raises Changed on a thread-pool thread (its refresh pipeline awaits with
         // ConfigureAwait(false)), so this reconcile can otherwise mutate view models and the broker's
@@ -1489,22 +1498,61 @@ await Dispatcher.UIThread.InvokeAsync(
                 () => this.UpdateSelectedViewIncrementallyAsync(
                     changedEntityIds,
                     hasQueryMembershipChanges,
-                    targetPopulation));
+                    targetPopulation,
+                    view));
             return;
         }
 
-        if ((this.selectedTopLevelView ?? EmptyView).IsEntityBrowser)
+        var population = targetPopulation ?? this.currentPopulation;
+        view ??= this.GetViewForPopulation(population);
+        if (view is null || view.IsEntityBrowser)
         {
             return;
         }
 
-        var population = targetPopulation ?? this.currentPopulation;
-        if (!ReferenceEquals(this.currentPopulation, population)
-            || population.CancellationToken.IsCancellationRequested)
+        try
+        {
+            await population.ReconcileGate.WaitAsync(population.CancellationToken);
+        }
+        catch (OperationCanceledException)
         {
             return;
         }
 
+        try
+        {
+            await this.ReconcileViewPopulationAsync(
+                population, view, changedEntityIds, hasQueryMembershipChanges);
+        }
+        finally
+        {
+            population.ReconcileGate.Release();
+        }
+    }
+
+    private async Task ReconcileViewPopulationAsync(
+        ViewPopulationViewModel population,
+        ViewDefinitionViewModel view,
+        IReadOnlyCollection<EntityId>? changedEntityIds,
+        bool hasQueryMembershipChanges)
+    {
+        if (population.CancellationToken.IsCancellationRequested
+            || (!ReferenceEquals(this.currentPopulation, population)
+                && this.GetViewForPopulation(population) is null))
+        {
+            return;
+        }
+
+        if (view.ViewEntity is { } viewEntity
+            && changedEntityIds?.Contains(viewEntity.EntityId) == true)
+        {
+            var latest = this.entityBroker?.GetEntity(viewEntity.EntityId);
+            if (latest is not null && !ReferenceEquals(latest, viewEntity))
+            {
+                viewEntity.UpdateSnapshot(latest.Snapshot);
+            }
+            hasQueryMembershipChanges = true;
+        }
         if (!hasQueryMembershipChanges)
         {
             this.RefreshPopulationEntityData(
@@ -1513,17 +1561,20 @@ await Dispatcher.UIThread.InvokeAsync(
             return;
         }
 
-        var candidate = new ViewPopulationViewModel();
-        await this.PopulateViewAsync(candidate);
+        var candidate = new ViewPopulationViewModel(population.ExpandedEntityIds);
+        await this.PopulateViewAsync(candidate, view,
+            () => this.RebindPopulationAsync(population), population);
 
-        if (!ReferenceEquals(this.currentPopulation, population)
-            || population.CancellationToken.IsCancellationRequested)
+        if (population.CancellationToken.IsCancellationRequested
+            || (!ReferenceEquals(this.currentPopulation, population)
+                && this.GetViewForPopulation(population) is null))
         {
             await candidate.DisposeAsync();
             return;
         }
 
-        this.ReconcilePopulationInPlace(population, candidate);
+        await this.ReconcilePopulationInPlaceAsync(population, candidate);
+        population.AdoptSubscriptions(candidate);
         await candidate.DisposeAsync();
     }
 
@@ -1557,10 +1608,11 @@ private void RefreshPopulationEntityData(
         }
     }
 
-    private void ReconcilePopulationInPlace(
+    private async Task ReconcilePopulationInPlaceAsync(
         ViewPopulationViewModel population,
         ViewPopulationViewModel candidate)
     {
+        var previousEntities = population.Entities.ToArray();
         var existingByEntityId = population.Entities
             .GroupBy(static entity => entity.EntityId, StringComparer.Ordinal)
             .ToDictionary(static group => group.Key, static group => group.First(), StringComparer.Ordinal);
@@ -1576,6 +1628,11 @@ private void ReconcilePopulationInPlace(
 
         ObservableCollectionReconciler.Merge(population.RootEntities, desiredRoots, static entity => entity.EntityId);
         ObservableCollectionReconciler.Merge(population.Entities, desiredEntities, static entity => entity.EntityId);
+        foreach (var removed in previousEntities.Concat(candidate.Entities).Except(desiredEntities))
+        {
+            await removed.DisposeAsync();
+        }
+        candidate.Entities.Clear();
         population.ReapplyFindAfterAssembly();
     }
 
@@ -1630,15 +1687,20 @@ private ViewEntityViewModel ResolveOrReuseViewEntity(
 
         this.ProjectEntityBadges(existing.Entity);
         existing.RefreshFromEntity();
+        this.RegisterCardNode(existing.Entity, existing.EntityCardNode);
         return existing;
     }
 
-    private async Task PopulateViewAsync(ViewPopulationViewModel next)
+    private async Task PopulateViewAsync(
+        ViewPopulationViewModel next,
+        ViewDefinitionViewModel selectedView,
+        Func<Task>? onResultsChanged = null,
+        ViewPopulationViewModel? subscriptionOwner = null)
     {
-        var selectedView = this.selectedTopLevelView ?? EmptyView;
+        var isLeftView = ReferenceEquals(next, this.currentPopulation);
         if (string.Equals(selectedView.Id, EmptyView.Id, StringComparison.Ordinal))
         {
-            this.StickyParentContextText = string.Empty;
+            if (isLeftView) this.StickyParentContextText = string.Empty;
             return;
         }
 
@@ -1647,7 +1709,7 @@ private async Task PopulateViewAsync(ViewPopulationViewModel next)
         if (selectedView.IsEntityBrowser)
         {
             await this.OpenEntityBrowserTabAsync();
-            this.StickyParentContextText = string.Empty;
+            if (isLeftView) this.StickyParentContextText = string.Empty;
             return;
         }
 
@@ -1655,13 +1717,13 @@ private async Task PopulateViewAsync(ViewPopulationViewModel next)
 
         if (selectedView.ViewEntity is not SubscribedEntityViewModel selectedViewEntity)
         {
-            this.StickyParentContextText = selectedView.Title;
+            if (isLeftView) this.StickyParentContextText = selectedView.Title;
             return;
         }
 
         if (selectedViewEntity.Snapshot.Data is not JsonElement selectedViewData)
         {
-            this.StickyParentContextText = selectedView.Title;
+            if (isLeftView) this.StickyParentContextText = selectedView.Title;
             return;
         }
 
@@ -1670,7 +1732,12 @@ private async Task PopulateViewAsync(ViewPopulationViewModel next)
 
         if (associatedNoteEntity is not null)
         {
-            var viewEntity = await this.CreateViewEntityViewModelAsync(associatedNoteEntity, indentLevel: 0, isParentContext: true);
+            var viewEntity = await this.CreateViewEntityViewModelAsync(next, associatedNoteEntity, indentLevel: 0, isParentContext: true);
+            if (next.CancellationToken.IsCancellationRequested)
+            {
+                await viewEntity.DisposeAsync();
+                return;
+            }
             next.Entities.Add(viewEntity);
             next.RootEntities.Add(viewEntity);
         }
@@ -1689,7 +1756,12 @@ private async Task PopulateViewAsync(ViewPopulationViewModel next)
                 if (this.EntityBroker.TryGetReferencedEntity(subView, "view-entity-id", out var subViewEntity)
                     && subViewEntity is not null)
                 {
-                    var viewEntity = await this.CreateViewEntityViewModelAsync(subViewEntity, indentLevel: 0);
+                    var viewEntity = await this.CreateViewEntityViewModelAsync(next, subViewEntity, indentLevel: 0);
+                    if (next.CancellationToken.IsCancellationRequested)
+                    {
+                        await viewEntity.DisposeAsync();
+                        return;
+                    }
                     next.Entities.Add(viewEntity);
                     next.RootEntities.Add(viewEntity);
                     continue;
@@ -1706,7 +1778,9 @@ private async Task PopulateViewAsync(ViewPopulationViewModel next)
 
                 if (TryReadSubViewQueryRequest(subView, this.interestCatalog, out var queryRequest))
                 {
-                    var queryEntities = await this.LoadQuerySubViewEntitiesAsync(next, queryRequest);
+                    var queryEntities = await this.LoadQuerySubViewEntitiesAsync(
+                        next, queryRequest, onResultsChanged ?? (() => this.RebindPopulationAsync(next)),
+                        subscriptionOwner);
                     if (next.CancellationToken.IsCancellationRequested) return;
                     await this.AddSubViewEntitiesWithHierarchyAsync(next, queryEntities);
                     if (next.CancellationToken.IsCancellationRequested) return;
@@ -1716,7 +1790,7 @@ private async Task PopulateViewAsync(ViewPopulationViewModel next)
 
         if (next.CancellationToken.IsCancellationRequested) return;
 
-        this.StickyParentContextText = $"Parent Context: {selectedView.Title}";
+        if (isLeftView) this.StickyParentContextText = $"Parent Context: {selectedView.Title}";
     }
 
     private async Task LoadSubViewEntitiesAsync(
@@ -1762,7 +1836,9 @@ private async Task<IReadOnlyList<SubscribedEntityViewModel>> LoadGetSubViewEntit
 
     private async Task<IReadOnlyList<SubscribedEntityViewModel>> LoadQuerySubViewEntitiesAsync(
         ViewPopulationViewModel population,
-        QueryRequest queryRequest)
+        QueryRequest queryRequest,
+        Func<Task> onResultsChanged,
+        ViewPopulationViewModel? subscriptionOwner)
     {
         // Exclude not-interesting targets at the query level (via a join) unless the user opts to show
         // hidden items.
@@ -1774,7 +1850,7 @@ private async Task<IReadOnlyList<SubscribedEntityViewModel>> LoadQuerySubViewEnt
         // every view (query, get, or get-entity) always requests every interest relationship type. No
         // additional WithInterestRelationships call is needed here.
         var subscribedQuery = await this.EntityBroker.SubscribeQueryAsync(effectiveQuery);
-        population.AddQuerySubscription(subscribedQuery, () => this.RebindPopulationAsync(population));
+        population.AddQuerySubscription(subscribedQuery, onResultsChanged, subscriptionOwner);
 
         if (subscribedQuery.Results.Count == 0)
         {
@@ -1922,6 +1998,15 @@ public void RegisterCardNode(SubscribedEntityViewModel entity, EntityListNodeVie
         this.cardNodesByEntity.AddOrUpdate(entity, cardNode);
     }
 
+    internal void UnregisterCardNode(SubscribedEntityViewModel entity, EntityListNodeViewModel cardNode)
+    {
+        if (this.cardNodesByEntity.TryGetValue(entity, out var registered)
+            && ReferenceEquals(registered, cardNode))
+        {
+            this.cardNodesByEntity.Remove(entity);
+        }
+    }
+
     /// <summary>Finds the card node currently rendering the supplied entity, if any.</summary>
     public EntityListNodeViewModel? FindCardNode(SubscribedEntityViewModel entity)
     {
@@ -1952,19 +2037,13 @@ private async Task OnActivateEntityClickAsync(
     /// entity, by the current user) when none exists.
     /// </summary>
     private async Task<ViewEntityViewModel> CreateViewEntityViewModelAsync(
+        ViewPopulationViewModel population,
         SubscribedEntityViewModel entity,
         int indentLevel,
         bool isExpanded = true,
         bool isParentContext = false)
     {
         this.ProjectEntityBadges(entity);
-        entity.PropertyChanged += (_, e) =>
-        {
-            if (string.Equals(e.PropertyName, nameof(SubscribedEntityViewModel.Snapshot), StringComparison.Ordinal))
-            {
-                this.ProjectEntityBadges(entity);
-            }
-        };
 
         // Project the entity's annotated status fields into colored status badges. Discovery is
         // asynchronous (each field's status annotation is resolved through the schema), so the badges
@@ -1976,7 +2055,7 @@ private async Task<ViewEntityViewModel> CreateViewEntityViewModelAsync(
             this,
             this.shortcutManager,
             indentLevel,
-            isExpanded: this.expandedEntityIds.TryGetValue(entity.EntityId.ToString(), out var storedExpanded) ? storedExpanded : isExpanded,
+            isExpanded: population.ExpandedEntityIds.TryGetValue(entity.EntityId.ToString(), out var storedExpanded) ? storedExpanded : isExpanded,
             isParentContext: isParentContext,
             fieldEditorFactory: this.fieldEditorFactory);
         await vm.InitializeAsync();
@@ -1988,14 +2067,14 @@ private async Task<ViewEntityViewModel> CreateViewEntityViewModelAsync(
             if (string.Equals(e.PropertyName, nameof(ViewEntityViewModel.IsExpanded), StringComparison.Ordinal)
                 && sender is ViewEntityViewModel toggled)
             {
-                this.expandedEntityIds[entityIdStr] = toggled.IsExpanded;
+                population.ExpandedEntityIds[entityIdStr] = toggled.IsExpanded;
             }
         };
 
         return vm;
     }
 
-    private void ProjectEntityBadges(SubscribedEntityViewModel entity)
+    internal void ProjectEntityBadges(SubscribedEntityViewModel entity)
     {
         if (this.interestCatalog is not { } interestCatalog
             || this.entityTypeCatalog is not { } entityTypeCatalog
@@ -2045,6 +2124,7 @@ private async Task AddSubViewEntitiesWithHierarchyAsync(
         var hierarchy = await new ViewHierarchyAssembler(this.EntityBroker).AssembleAsync(rootEntities);
         foreach (var node in hierarchy)
         {
+            if (population.CancellationToken.IsCancellationRequested) return;
             await this.AddHierarchyNodeAsync(population, node, indentLevel: 0);
         }
 
@@ -2057,10 +2137,16 @@ private async Task AddHierarchyNodeAsync(
         int indentLevel,
         ViewEntityViewModel? parent = null)
     {
+        if (population.CancellationToken.IsCancellationRequested) return;
         ViewEntityViewModel? vm = null;
         if (!node.IsAncestorGroup)
         {
-            vm = await this.CreateViewEntityViewModelAsync(node.Entity!, indentLevel, isExpanded: node.IsExpanded);
+            vm = await this.CreateViewEntityViewModelAsync(population, node.Entity!, indentLevel, isExpanded: node.IsExpanded);
+            if (population.CancellationToken.IsCancellationRequested)
+            {
+                await vm.DisposeAsync();
+                return;
+            }
             if (node.Children.Count > 0)
             {
                 vm.HasTraversedChildren = true;
@@ -2134,6 +2220,26 @@ private void OnEntityBrokerChanged(
             _ = this.UpdateSelectedViewIncrementallyAsync(
                 e.ChangedEntityIds,
                 e.HasQueryMembershipChanges);
+            _ = this.RefreshViewTabsAsync(e.ChangedEntityIds, e.HasQueryMembershipChanges);
+        }
+    }
+
+    private async Task RefreshViewTabsAsync(
+        IReadOnlyCollection<EntityId>? changedEntityIds,
+        bool hasQueryMembershipChanges)
+    {
+        if (!Dispatcher.UIThread.CheckAccess())
+        {
+            await Dispatcher.UIThread.InvokeAsync(
+                () => this.RefreshViewTabsAsync(changedEntityIds, hasQueryMembershipChanges));
+            return;
+        }
+
+        foreach (var tab in this.WorkspacePanes.SelectMany(static pane => pane.Tabs)
+            .OfType<ViewWorkspaceTabViewModel>().ToArray())
+        {
+            _ = this.UpdateSelectedViewIncrementallyAsync(
+                changedEntityIds, hasQueryMembershipChanges, tab.Population, tab.Definition);
         }
     }
 
@@ -2601,6 +2707,12 @@ internal async Task OpenEntityTabAsync(
             return;
         }
 
+        if (subscribedEntity.IsEntityType("view"))
+        {
+            await this.OpenViewTabAsync(subscribedEntity, focus);
+            return;
+        }
+
         await this.OpenTabAsync(
             new EntityWorkspaceTabViewModel(this.EntityBroker, this.entityTypeViewCatalog, this)
             {
@@ -2611,6 +2723,61 @@ await this.OpenTabAsync(
             focus: focus);
     }
 
+    internal async Task<ViewWorkspaceTabViewModel> CreateViewTabAsync(
+        SubscribedEntityViewModel entity,
+        string? tabId = null,
+        string? title = null,
+        string? dockRegion = null)
+    {
+        var definition = CreateTopLevelView(entity);
+        var tab = new ViewWorkspaceTabViewModel(this, definition)
+        {
+            Id = tabId ?? entity.EntityId.ToString(),
+            Title = title ?? definition.Title,
+            Entity = entity,
+            DockRegion = dockRegion ?? "full",
+        };
+        await this.PopulateViewAsync(
+            tab.Population, definition, () => this.RebindPopulationAsync(tab.Population));
+        return tab;
+    }
+
+    internal async Task OpenViewTabAsync(SubscribedEntityViewModel entity, bool focus = true)
+    {
+        var existing = this.WorkspacePanes.SelectMany(static pane => pane.Tabs)
+            .OfType<ViewWorkspaceTabViewModel>()
+            .FirstOrDefault(tab => tab.Entity?.EntityId == entity.EntityId);
+        if (existing is not null)
+        {
+            await this.OpenTabAsync(existing, focus: focus, workspacePaneId: existing.WorkspacePaneId);
+            return;
+        }
+
+        var legacyRawTab = this.WorkspacePanes.SelectMany(static pane => pane.Tabs)
+            .OfType<EntityWorkspaceTabViewModel>()
+            .FirstOrDefault(tab => tab.Entity?.EntityId == entity.EntityId
+                && tab.Id == entity.EntityId.ToString());
+        if (legacyRawTab is not null)
+        {
+            this.CloseTab(legacyRawTab);
+        }
+
+        await this.OpenTabAsync(await this.CreateViewTabAsync(entity), focus: focus);
+    }
+
+    internal async Task OpenViewDefinitionAsync(ViewWorkspaceTabViewModel viewTab)
+    {
+        await this.OpenTabAsync(
+            new EntityWorkspaceTabViewModel(this.EntityBroker, this.entityTypeViewCatalog, this)
+            {
+                Id = $"view-definition-{viewTab.Entity!.EntityId}",
+                Title = $"Edit definition: {viewTab.Title}",
+                Entity = viewTab.Entity,
+            },
+            insertAfterTabId: viewTab.Id,
+            workspacePaneId: viewTab.WorkspacePaneId);
+    }
+
     public async Task OpenTabAsync(WorkspaceTabViewModel tab, string? insertAfterTabId = null, bool focus = true, string? workspacePaneId = null)
     {
         // Ensure we have a real workspace loaded (not the placeholder)
@@ -3556,6 +3723,13 @@ internal static IReadOnlyList<JsonElement> CollectTabDeclarations(JsonElement wo
                             !string.IsNullOrEmpty(entityDesc.Title) ? entityDesc.Title :
                             !string.IsNullOrEmpty(entity.DisplayName) ? entity.DisplayName :
                             entity.EntityId.Value.ToString();
+                        if (entity.IsEntityType("view")
+                            && !tabId.StartsWith("view-definition-", StringComparison.Ordinal))
+                        {
+                            var viewTab = await this.CreateViewTabAsync(entity, tabId, restoredTitle);
+                            viewTab.IsTitleExplicit = entityDesc.IsTitleExplicit;
+                            return viewTab;
+                        }
                         return new EntityWorkspaceTabViewModel(this.EntityBroker, this.entityTypeViewCatalog, this)
                         {
                             Id = tabId,
diff --git a/Phantom.Workspaces/ViewModels/OpenEntityShortcutHandler.cs b/Phantom.Workspaces/ViewModels/OpenEntityShortcutHandler.cs
index 5460276e..4f252306 100644
--- a/Phantom.Workspaces/ViewModels/OpenEntityShortcutHandler.cs
+++ b/Phantom.Workspaces/ViewModels/OpenEntityShortcutHandler.cs
@@ -29,6 +29,12 @@ await mainWindowViewModel.OpenWorkspaceAsync(
             return true;
         }
 
+        if (entityViewModel.IsEntityType("view"))
+        {
+            await mainWindowViewModel.OpenViewTabAsync(entityViewModel);
+            return true;
+        }
+
         await mainWindowViewModel.OpenEntityTabAsync(
             new GetEntityRequest
             {
@@ -36,6 +42,21 @@ await mainWindowViewModel.OpenEntityTabAsync(
             });
         return true;
     }
-}
 
+    public override async Task<WorkspaceTabViewModel?> TryCreateTabForRestoreAsync(
+        MainWindowViewModel mainWindowViewModel,
+        SubscribedEntityViewModel entityViewModel,
+        string? tabId,
+        string? title,
+        string? dockRegion)
+    {
+        if (!entityViewModel.IsEntityType("view")
+            || tabId?.StartsWith("view-definition-", StringComparison.Ordinal) == true)
+        {
+            return null;
+        }
 
+        return await mainWindowViewModel.CreateViewTabAsync(
+            entityViewModel, tabId, title, dockRegion);
+    }
+}
diff --git a/Phantom.Workspaces/ViewModels/StatusBadgesViewModel.cs b/Phantom.Workspaces/ViewModels/StatusBadgesViewModel.cs
index 2eb8870b..6d045d9a 100644
--- a/Phantom.Workspaces/ViewModels/StatusBadgesViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/StatusBadgesViewModel.cs
@@ -25,6 +25,14 @@ public StatusBadgesViewModel(
 
     public ObservableCollection<StatusBadgeModel> Badges { get; }
 
+    internal void Detach()
+    {
+        if (this.statusBadgesModel.Badges is INotifyCollectionChanged notifyCollectionChanged)
+        {
+            notifyCollectionChanged.CollectionChanged -= this.OnBadgesChanged;
+        }
+    }
+
     private void OnBadgesChanged(
         object? sender,
         NotifyCollectionChangedEventArgs e)
diff --git a/Phantom.Workspaces/ViewModels/ViewEntityViewModel.cs b/Phantom.Workspaces/ViewModels/ViewEntityViewModel.cs
index ae5209f6..6107c459 100644
--- a/Phantom.Workspaces/ViewModels/ViewEntityViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/ViewEntityViewModel.cs
@@ -12,6 +12,7 @@ namespace Phantom.Workspaces.ViewModels;
 public sealed class ViewEntityViewModel : ViewModelBase
 {
     private readonly EntityListNodeViewModel entityCardNode;
+    private readonly MainWindowViewModel owner;
     private bool hasTraversedChildren;
     private bool isExpanded = true;
     private IBrush? childRailBrush;
@@ -26,6 +27,7 @@ public ViewEntityViewModel(
         bool isParentContext = false,
         FieldEditorFactory? fieldEditorFactory = null)
     {
+        this.owner = mainWindowViewModel;
         this.Entity = entity;
         this.Badges = new BadgesViewModel(entity.Badges);
         this.StatusBadges = new StatusBadgesViewModel(entity.StatusBadges);
@@ -56,6 +58,21 @@ public async Task InitializeAsync()
         this.RaisePropertyChanged(nameof(this.HasShortcuts));
     }
 
+    internal void DetachEntityUpdates()
+    {
+        this.Entity.PropertyChanged -= this.OnEntityPropertyChanged;
+        this.Badges.Detach();
+        this.StatusBadges.Detach();
+    }
+
+    public override async ValueTask DisposeAsync()
+    {
+        this.DetachEntityUpdates();
+        this.owner.UnregisterCardNode(this.Entity, this.entityCardNode);
+        await this.entityCardNode.Card.DisposeAsync();
+        await base.DisposeAsync();
+    }
+
     public SubscribedEntityViewModel Entity { get; }
 
     public string EntityId => this.Entity.EntityId.ToString();
@@ -199,6 +216,10 @@ private void OnEntityPropertyChanged(
             || string.Equals(e.PropertyName, nameof(SubscribedEntityViewModel.DisplayName), System.StringComparison.Ordinal)
             || string.Equals(e.PropertyName, nameof(SubscribedEntityViewModel.EntityType), System.StringComparison.Ordinal))
         {
+            if (string.Equals(e.PropertyName, nameof(SubscribedEntityViewModel.Snapshot), System.StringComparison.Ordinal))
+            {
+                this.owner.ProjectEntityBadges(this.Entity);
+            }
             this.RefreshFromEntity();
         }
     }
diff --git a/Phantom.Workspaces/ViewModels/ViewPopulationViewModel.cs b/Phantom.Workspaces/ViewModels/ViewPopulationViewModel.cs
index ec0e3da2..5b0d4889 100644
--- a/Phantom.Workspaces/ViewModels/ViewPopulationViewModel.cs
+++ b/Phantom.Workspaces/ViewModels/ViewPopulationViewModel.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Avalonia.Threading;
@@ -9,19 +10,28 @@
 namespace Phantom.Workspaces.ViewModels;
 
 /// <summary>
-/// Holds all mutable state for one population run of the selected top-level view.
-/// A new instance is created each time <c>ApplySelectedViewAsync</c> starts;
-/// disposing the old instance cancels any in-flight work and releases broker subscriptions.
+/// Holds mutable state and subscriptions for one view host (left navigation or a view tab).
+/// Disposing the host's population cancels in-flight work and detaches live query observers.
 /// </summary>
 public sealed class ViewPopulationViewModel : IAsyncDisposable
 {
     private readonly CancellationTokenSource _cts = new();
+    internal SemaphoreSlim ReconcileGate { get; } = new(1, 1);
     private readonly List<SubscribedGet> _getSubscriptions = [];
     private readonly List<(SubscribedQuery Query, NotifyCollectionChangedEventHandler Handler)> _querySubscriptions = [];
 
     private string? findQuery;
     private bool hideUnmatched;
 
+    public ViewPopulationViewModel(Dictionary<string, bool>? expandedEntityIds = null)
+    {
+        this.ExpandedEntityIds = expandedEntityIds ?? new Dictionary<string, bool>(StringComparer.Ordinal);
+    }
+
+    internal Dictionary<string, bool> ExpandedEntityIds { get; }
+
+    internal int QueryObserverCount => _querySubscriptions.Count;
+
     public ObservableCollection<ViewEntityViewModel> Entities { get; } = [];
 
     public ObservableCollection<ViewEntityViewModel> RootEntities { get; } = [];
@@ -60,7 +70,7 @@ internal void ReapplyFindAfterAssembly() =>
 
     private void NormalizeSelectionIfHidden()
     {
-        foreach (var entity in this.Entities)
+        foreach (var entity in this.Entities.ToArray())
         {
             if (!entity.IsVisible && entity.EntityCardNode.Card.IsSelected)
             {
@@ -79,18 +89,21 @@ internal void AddGetSubscription(SubscribedGet subscription) =>
     /// marshaled to the UI thread and posted (rather than run inline) to rebuild the view after the
     /// broker's own collection mutation has completed.
     /// </summary>
-    internal void AddQuerySubscription(SubscribedQuery subscription, Func<Task> onResultsChanged)
+    internal void AddQuerySubscription(
+        SubscribedQuery subscription, Func<Task> onResultsChanged,
+        ViewPopulationViewModel? lifetimeOwner = null)
     {
+        var owner = lifetimeOwner ?? this;
         void Handler(object? sender, NotifyCollectionChangedEventArgs e)
         {
-            if (_cts.IsCancellationRequested)
+            if (owner._cts.IsCancellationRequested)
             {
                 return;
             }
 
             Dispatcher.UIThread.Post(() =>
             {
-                if (_cts.IsCancellationRequested)
+                if (owner._cts.IsCancellationRequested)
                 {
                     return;
                 }
@@ -120,11 +133,32 @@ internal void PrepareForIncrementalReconcile()
         _getSubscriptions.Clear();
     }
 
+    internal void AdoptSubscriptions(ViewPopulationViewModel candidate)
+    {
+        this.PrepareForIncrementalReconcile();
+        _getSubscriptions.AddRange(candidate._getSubscriptions);
+        _querySubscriptions.AddRange(candidate._querySubscriptions);
+        candidate._getSubscriptions.Clear();
+        candidate._querySubscriptions.Clear();
+    }
+
     public async ValueTask DisposeAsync()
     {
         await _cts.CancelAsync();
-        DetachQuerySubscriptions();
-        _getSubscriptions.Clear();
+        await this.ReconcileGate.WaitAsync();
+        try
+        {
+            DetachQuerySubscriptions();
+            _getSubscriptions.Clear();
+            foreach (var entity in this.Entities.ToArray())
+            {
+                await entity.DisposeAsync();
+            }
+        }
+        finally
+        {
+            this.ReconcileGate.Release();
+        }
     }
 
     private void DetachQuerySubscriptions()
diff --git a/Phantom.Workspaces/ViewModels/ViewWorkspaceTabViewModel.cs b/Phantom.Workspaces/ViewModels/ViewWorkspaceTabViewModel.cs
new file mode 100644
index 00000000..33caa4ae
--- /dev/null
+++ b/Phantom.Workspaces/ViewModels/ViewWorkspaceTabViewModel.cs
@@ -0,0 +1,51 @@
+using System.Threading.Tasks;
+
+namespace Phantom.Workspaces.ViewModels;
+
+public sealed class ViewWorkspaceTabViewModel : WorkspaceTabViewModel
+{
+    private string? searchText;
+    private bool hideUnmatched;
+
+    public ViewWorkspaceTabViewModel(MainWindowViewModel owner, ViewDefinitionViewModel definition)
+    {
+        this.Definition = definition;
+        this.EditDefinitionCommand = new RelayCommand(async _ => await owner.OpenViewDefinitionAsync(this));
+    }
+
+    public ViewDefinitionViewModel Definition { get; }
+
+    public ViewPopulationViewModel Population { get; } = new();
+
+    public RelayCommand EditDefinitionCommand { get; }
+
+    public string? SearchText
+    {
+        get => this.searchText;
+        set
+        {
+            if (this.SetProperty(ref this.searchText, value))
+            {
+                this.Population.ApplyFind(value, this.hideUnmatched);
+            }
+        }
+    }
+
+    public bool HideUnmatched
+    {
+        get => this.hideUnmatched;
+        set
+        {
+            if (this.SetProperty(ref this.hideUnmatched, value))
+            {
+                this.Population.ApplyFind(this.searchText, value);
+            }
+        }
+    }
+
+    public override async ValueTask DisposeAsync()
+    {
+        await this.Population.DisposeAsync();
+        await base.DisposeAsync();
+    }
+}
diff --git a/docs/design/build-and-installation.md b/docs/design/build-and-installation.md
index 0c49c4e2..ddc0f12b 100644
--- a/docs/design/build-and-installation.md
+++ b/docs/design/build-and-installation.md
@@ -555,6 +555,20 @@ environments, and release outputs) the build/installation design requires. Items
   integration suite. Scheduled (e.g. nightly), on-demand, and **gated before release**. A
   self-hosted Docker-capable Windows runner is only needed if a test ever requires *Windows*
   containers specifically.
+  - The Windows job downloads the standalone Copilot CLI version matching `GitHub.Copilot.SDK`
+    (and verifies the release archive's SHA-256), then sets `COPILOT_CLI_PATH` for real BYOK
+    tests. The SDK-staged `copilot.exe` is a server-only runtime, not the interactive CLI.
+    When upgrading the SDK, update the pinned CLI version and archive hash together. The
+    Windows test run uses the approved harness's `-maxcpucount:1` MSBuild serialization so
+    resource-heavy CLI, process, and browser tests do not compete across test hosts.
+  - The Linux job needs a working Docker daemon. The MongoDB broker creates both the data
+    directory and its `configdb` bind-mount source before `docker create`; unlike Docker
+    Desktop on Windows, Linux Docker rejects a missing `--mount` source. Hosted CI pre-pulls
+    Atlas Local before starting the test host and uses a 10-minute per-test inactivity
+    watchdog for cold replica-set/search startup. The image's non-root user also needs write
+    access to the bind mounts: CI sets `TMPDIR` to a dedicated workspace-local directory with
+    an inherited ACL for that image's UID, including the per-test replica-set directories.
+    Local test-harness defaults are unchanged.
   - **Targeting on Linux:** the full suite also contains **Windows-only** tests (Avalonia GUI,
     the `StartupTaskService`/scheduled-task and junction/symlink integration tests). The
     `ubuntu-latest` job therefore runs the **cross-platform data-layer Docker tests** (e.g. via
diff --git a/scripts/CopilotWrapperPrerequisiteCache.ps1 b/scripts/CopilotWrapperPrerequisiteCache.ps1
new file mode 100644
index 00000000..db8c2532
--- /dev/null
+++ b/scripts/CopilotWrapperPrerequisiteCache.ps1
@@ -0,0 +1,117 @@
+function Assert-PrerequisiteOwnedPath {
+    param([string] $Path, [string] $ProjectDirectory)
+
+    $project = [IO.Path]::TrimEndingDirectorySeparator([IO.Path]::GetFullPath($ProjectDirectory))
+    $path = [IO.Path]::TrimEndingDirectorySeparator([IO.Path]::GetFullPath($Path))
+    if (-not $path.StartsWith("$project\", [StringComparison]::OrdinalIgnoreCase))
+    {
+        throw "Copilot wrapper prerequisite path is outside the Install.Tests project: '$path'."
+    }
+    $current = $project
+    foreach ($part in $path.Substring($project.Length + 1).Split('\'))
+    {
+        $current = Join-Path $current $part
+        $item = Get-Item -LiteralPath $current -Force -ErrorAction SilentlyContinue
+        if ($item -and ($item.Attributes -band [IO.FileAttributes]::ReparsePoint))
+        {
+            throw "Copilot wrapper prerequisite path contains a reparse point: '$current'."
+        }
+    }
+    return $path
+}
+
+function Assert-PrerequisiteLayout {
+    param(
+        [string] $ProjectDirectory,
+        [string] $BaseIntermediateOutputPath,
+        [string] $CacheRoot,
+        [string] $PathOutputFile,
+        [string] $CopiedPathFile
+    )
+
+    $project = [IO.Path]::GetFullPath($ProjectDirectory)
+    $base = if ([IO.Path]::IsPathFullyQualified($BaseIntermediateOutputPath)) {
+        [IO.Path]::GetFullPath($BaseIntermediateOutputPath)
+    } else {
+        [IO.Path]::GetFullPath($BaseIntermediateOutputPath, $project)
+    }
+    $base = Assert-PrerequisiteOwnedPath $base $project
+    if ($base -eq [IO.Path]::TrimEndingDirectorySeparator($project))
+    {
+        throw 'The intermediate output path cannot be the project directory.'
+    }
+    $expectedRoot = [IO.Path]::GetFullPath('mxcw', $base)
+    $root = Assert-PrerequisiteOwnedPath $CacheRoot $project
+    if ($root -ne $expectedRoot)
+    {
+        throw "Copilot wrapper prerequisite cache root '$root' is not the evaluated '$expectedRoot'."
+    }
+    $pointer = Assert-PrerequisiteOwnedPath $PathOutputFile $project
+    if ([IO.Path]::GetFileName($pointer) -ne 'copilot-wrapper-prerequisite.path' -or
+        -not $pointer.StartsWith("$base\", [StringComparison]::OrdinalIgnoreCase) -or
+        $pointer.StartsWith("$root\", [StringComparison]::OrdinalIgnoreCase))
+    {
+        throw "Unsafe Copilot wrapper prerequisite pointer path '$pointer'."
+    }
+    if ($CopiedPathFile)
+    {
+        $copy = Assert-PrerequisiteOwnedPath $CopiedPathFile $project
+        if ([IO.Path]::GetFileName($copy) -ne 'copilot-wrapper-prerequisite.path')
+        {
+            throw "Unsafe Copilot wrapper prerequisite output pointer '$copy'."
+        }
+        if ($copy.StartsWith("$root\", [StringComparison]::OrdinalIgnoreCase))
+        {
+            throw "Copilot wrapper prerequisite output pointer cannot be inside the cache root: '$copy'."
+        }
+    }
+    return $root
+}
+
+function Open-PrerequisiteRootLease {
+    param(
+        [string] $ProjectDirectory,
+        [string] $CacheRoot,
+        [switch] $Shared
+    )
+
+    $lockPath = Join-Path (Split-Path -Parent $CacheRoot) 'mxcw.lock'
+    Assert-PrerequisiteOwnedPath $lockPath $ProjectDirectory | Out-Null
+    New-Item -ItemType Directory -Path (Split-Path -Parent $lockPath) -Force | Out-Null
+    try
+    {
+        if ($Shared)
+        {
+            return [IO.File]::Open($lockPath, [IO.FileMode]::OpenOrCreate,
+                [IO.FileAccess]::Read, [IO.FileShare]::Read)
+        }
+        return [IO.File]::Open($lockPath, [IO.FileMode]::OpenOrCreate,
+            [IO.FileAccess]::ReadWrite, [IO.FileShare]::None)
+    }
+    catch [IO.IOException]
+    {
+        throw "Copilot wrapper prerequisite cache is in use; Clean cannot remove it: $($_.Exception.Message)"
+    }
+}
+
+function Assert-PrerequisiteTreeSafe {
+    param([string] $Directory)
+
+    foreach ($item in Get-ChildItem -LiteralPath $Directory -Force)
+    {
+        if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint)
+        {
+            throw "Copilot wrapper prerequisite cache contains a reparse point: '$($item.FullName)'."
+        }
+        if ($item.PSIsContainer)
+        {
+            Assert-PrerequisiteTreeSafe $item.FullName
+        }
+        else
+        {
+            $handle = [IO.File]::Open($item.FullName, [IO.FileMode]::Open,
+                [IO.FileAccess]::Read, [IO.FileShare]::None)
+            $handle.Dispose()
+        }
+    }
+}
diff --git a/scripts/CopilotWrapperPrerequisiteLease.targets b/scripts/CopilotWrapperPrerequisiteLease.targets
new file mode 100644
index 00000000..615df98c
--- /dev/null
+++ b/scripts/CopilotWrapperPrerequisiteLease.targets
@@ -0,0 +1,59 @@
+<Project>
+  <UsingTask TaskName="HoldCopilotWrapperPrerequisiteLease"
+             TaskFactory="RoslynCodeTaskFactory"
+             AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+    <ParameterGroup>
+      <CacheRoot ParameterType="System.String" Required="true" />
+      <ProjectDirectory ParameterType="System.String" Required="true" />
+    </ParameterGroup>
+    <Task>
+      <Using Namespace="System" />
+      <Using Namespace="System.IO" />
+      <Code Type="Fragment" Language="cs"><![CDATA[
+        var project = Path.GetFullPath(ProjectDirectory).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        var root = Path.GetFullPath(CacheRoot).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        if (!Path.IsPathRooted(CacheRoot) ||
+            !StringComparer.OrdinalIgnoreCase.Equals(root, CacheRoot) ||
+            !root.StartsWith(project + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) ||
+            !StringComparer.OrdinalIgnoreCase.Equals(Path.GetFileName(root), "mxcw") ||
+            StringComparer.OrdinalIgnoreCase.Equals(Path.GetDirectoryName(root), project))
+            throw new InvalidOperationException("Prepared Copilot cache root must be canonical and owned by Install.Tests.");
+
+        var current = project;
+        var relativeBase = Path.GetDirectoryName(root).Substring(project.Length + 1);
+        foreach (var part in relativeBase.Split(Path.DirectorySeparatorChar))
+        {
+            current = Path.Combine(current, part);
+            if ((File.Exists(current) || Directory.Exists(current)) &&
+                (File.GetAttributes(current) & FileAttributes.ReparsePoint) != 0)
+                throw new InvalidOperationException("Prepared Copilot cache path contains a reparse point: " + current);
+        }
+        if (Directory.Exists(root) &&
+            (File.GetAttributes(root) & FileAttributes.ReparsePoint) != 0)
+            throw new InvalidOperationException("Prepared Copilot cache root is a reparse point: " + root);
+
+        var baseDirectory = Path.GetDirectoryName(root);
+        Directory.CreateDirectory(baseDirectory);
+        var lockPath = Path.Combine(baseDirectory, "mxcw.lock");
+        if (File.Exists(lockPath) && (File.GetAttributes(lockPath) & FileAttributes.ReparsePoint) != 0)
+            throw new InvalidOperationException("Prepared Copilot cache lease is a reparse point: " + lockPath);
+        var engine = (Microsoft.Build.Framework.IBuildEngine4)BuildEngine;
+        var key = "CopilotWrapperPrerequisiteLease:" + lockPath.ToUpperInvariant();
+        if (engine.GetRegisteredTaskObject(key, Microsoft.Build.Framework.RegisteredTaskObjectLifetime.Build) == null)
+        {
+            // Build lifetime covers VSTest startup; the test host holds its own lease after loading.
+            var lease = new FileStream(lockPath, FileMode.OpenOrCreate, FileAccess.Read, FileShare.Read);
+            try
+            {
+                engine.RegisterTaskObject(key, lease, Microsoft.Build.Framework.RegisteredTaskObjectLifetime.Build, false);
+            }
+            catch
+            {
+                lease.Dispose();
+                throw;
+            }
+        }
+      ]]></Code>
+    </Task>
+  </UsingTask>
+</Project>
diff --git a/scripts/clean-copilot-wrapper-test-prerequisite.ps1 b/scripts/clean-copilot-wrapper-test-prerequisite.ps1
new file mode 100644
index 00000000..f2cf7134
--- /dev/null
+++ b/scripts/clean-copilot-wrapper-test-prerequisite.ps1
@@ -0,0 +1,57 @@
+param(
+    [Parameter(Mandatory)][string] $ProjectDirectory,
+    [Parameter(Mandatory)][string] $BaseIntermediateOutputPath,
+    [Parameter(Mandatory)][string] $CacheRoot,
+    [Parameter(Mandatory)][string] $PathOutputFile,
+    [Parameter(Mandatory)][string] $CopiedPathFile
+)
+
+$ErrorActionPreference = 'Stop'
+. (Join-Path $PSScriptRoot 'CopilotWrapperPrerequisiteCache.ps1')
+$root = Assert-PrerequisiteLayout `
+    $ProjectDirectory $BaseIntermediateOutputPath $CacheRoot $PathOutputFile $CopiedPathFile
+$lease = Open-PrerequisiteRootLease $ProjectDirectory $root
+try
+{
+    # Preflight every deletion before removing even the first pointer or entry.
+    foreach ($pointer in @($PathOutputFile, $CopiedPathFile))
+    {
+        Assert-PrerequisiteOwnedPath $pointer $ProjectDirectory | Out-Null
+        $item = Get-Item -LiteralPath $pointer -Force -ErrorAction SilentlyContinue
+        if ($item -and (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -or
+            $item.PSIsContainer))
+        {
+            throw "Unsafe Copilot wrapper prerequisite pointer: '$pointer'."
+        }
+        if ($item)
+        {
+            $handle = [IO.File]::Open($pointer, [IO.FileMode]::Open,
+                [IO.FileAccess]::Read, [IO.FileShare]::None)
+            $handle.Dispose()
+        }
+    }
+    if (Test-Path -LiteralPath $root)
+    {
+        Assert-PrerequisiteTreeSafe $root
+        foreach ($item in Get-ChildItem -LiteralPath $root -Force)
+        {
+            if (-not $item.PSIsContainer -or
+                $item.Name -notmatch '^(?:[0-9a-f]{16}|[0-9a-f]{16}\.staging-[0-9]+)$')
+            {
+                throw "Unexpected entry in Copilot wrapper prerequisite cache: '$($item.FullName)'."
+            }
+        }
+        Remove-Item -LiteralPath $root -Recurse -Force -ErrorAction Stop
+    }
+    foreach ($pointer in @($PathOutputFile, $CopiedPathFile))
+    {
+        if (Test-Path -LiteralPath $pointer)
+        {
+            Remove-Item -LiteralPath $pointer -Force -ErrorAction Stop
+        }
+    }
+}
+finally
+{
+    $lease.Dispose()
+}
diff --git a/scripts/prepare-copilot-wrapper-test-prerequisite.ps1 b/scripts/prepare-copilot-wrapper-test-prerequisite.ps1
index 46f02c1b..446b0ff8 100644
--- a/scripts/prepare-copilot-wrapper-test-prerequisite.ps1
+++ b/scripts/prepare-copilot-wrapper-test-prerequisite.ps1
@@ -4,7 +4,11 @@ param(
     [Parameter(Mandatory)]
     [string] $CacheRoot,
     [Parameter(Mandatory)]
-    [string] $PathOutputFile
+    [string] $PathOutputFile,
+    [Parameter(Mandatory)]
+    [string] $ProjectDirectory,
+    [Parameter(Mandatory)]
+    [string] $BaseIntermediateOutputPath
 )
 
 $ErrorActionPreference = 'Stop'
@@ -20,6 +24,9 @@ $nativeFeatures = @('dotnetsdk')
 $RepositoryRoot = [IO.Path]::GetFullPath($RepositoryRoot)
 $CacheRoot = [IO.Path]::GetFullPath($CacheRoot)
 $PathOutputFile = [IO.Path]::GetFullPath($PathOutputFile)
+. (Join-Path $PSScriptRoot 'CopilotWrapperPrerequisiteCache.ps1')
+Assert-PrerequisiteLayout `
+    $ProjectDirectory $BaseIntermediateOutputPath $CacheRoot $PathOutputFile '' | Out-Null
 
 function Add-HashText {
     param(
@@ -354,9 +361,13 @@ finally
     $hasher.Dispose()
 }
 
+$rootLease = Open-PrerequisiteRootLease $ProjectDirectory $CacheRoot -Shared
+$rootIdentity = [Convert]::ToHexString(
+    [Security.Cryptography.SHA256]::HashData(
+        [Text.Encoding]::UTF8.GetBytes($CacheRoot.ToUpperInvariant())))
 $mutex = [System.Threading.Mutex]::new(
     $false,
-    "Local\Phantom.Workspaces.CopilotWrapperPrerequisite.$sourceFingerprint")
+    "Local\Phantom.Workspaces.CopilotWrapperPrerequisite.$rootIdentity")
 $ownsMutex = $false
 $stagingDirectory = $null
 $productionIntermediateDirectory = $null
@@ -372,6 +383,10 @@ try
     }
 
     $cacheDirectory = $null
+    if (Test-Path -LiteralPath $CacheRoot)
+    {
+        Assert-PrerequisiteTreeSafe $CacheRoot
+    }
     if (Test-Path -LiteralPath $PathOutputFile -PathType Leaf)
     {
         $candidateCacheDirectory = (
@@ -402,13 +417,13 @@ try
         $stagingDirectory = Join-Path `
             $CacheRoot `
             "$($sourceFingerprint.Substring(0, 16)).staging-$PID"
-        $cargoTargetDirectory = Join-Path $stagingDirectory 'cargo'
-        $dotnetArtifactsDirectory = Join-Path $stagingDirectory 'dotnet'
-        $publishDirectory = Join-Path $stagingDirectory 'publish'
-        $releaseAssetsDirectory = Join-Path $stagingDirectory 'release-assets'
         $productionIntermediateDirectory = Join-Path `
             $RepositoryRoot `
             "artifacts\cw-$PID-$([Guid]::NewGuid().ToString('N').Substring(0, 8))"
+        $cargoTargetDirectory = Join-Path $productionIntermediateDirectory 'cargo'
+        $dotnetArtifactsDirectory = Join-Path $productionIntermediateDirectory 'dotnet'
+        $publishDirectory = Join-Path $productionIntermediateDirectory 'publish'
+        $releaseAssetsDirectory = Join-Path $productionIntermediateDirectory 'release-assets'
         $preparedDirectory = Join-Path $stagingDirectory 'prepared'
         New-Item -ItemType Directory -Path $preparedDirectory -Force | Out-Null
 
@@ -872,4 +887,5 @@ finally
         $mutex.ReleaseMutex()
     }
     $mutex.Dispose()
+    $rootLease.Dispose()
 }
diff --git a/scripts/run-tests.ps1 b/scripts/run-tests.ps1
index 0c5b6883..965d9a0a 100644
--- a/scripts/run-tests.ps1
+++ b/scripts/run-tests.ps1
@@ -3,6 +3,8 @@ param(
     [string] $TestResultsPath = (Join-Path $PSScriptRoot 'test-results.log'),
     [Parameter()]
     [string[]] $TestNames,
+    [Parameter()]
+    [string] $TestProject,
     # The split-process child attachment scenarios allow 180s for authenticated GUI startup.
     # Blame must outlast that explicit deadline so a slow run reports the real test failure.
     [Parameter()]
@@ -24,7 +26,7 @@ param(
 $ErrorActionPreference = 'Stop'
 
 $repoRoot = Resolve-Path (Join-Path $PSScriptRoot '..')
-$solutionPath = Join-Path $repoRoot 'Phantom.Workspaces.slnx'
+$testTargetPath = if ($TestProject) { (Resolve-Path $TestProject).Path } else { Join-Path $repoRoot 'Phantom.Workspaces.slnx' }
 
 Set-Content -Path $TestResultsPath -Value '' -Encoding utf8
 
@@ -34,7 +36,7 @@ Get-ChildItem -Path $repoRoot -Filter '*.dmp' -Recurse -ErrorAction SilentlyCont
 
 $dotnetArgs = @(
     'test',
-    $solutionPath,
+    $testTargetPath,
     '--no-restore',
     '--nologo',
     # Serialize the whole solution test run onto a single MSBuild node (issue #1101). `dotnet test`
@@ -129,7 +131,7 @@ if ($filterClauses.Count -gt 0)
 # is set the projects are already built, so no restore is needed.
 if (-not $NoBuild)
 {
-    $restoreOutput = & dotnet restore $solutionPath --nologo 2>&1
+    $restoreOutput = & dotnet restore $testTargetPath --nologo 2>&1
     if ($LASTEXITCODE -ne 0)
     {
         $restoreOutput | ForEach-Object { $_.ToString() } | Set-Content -Path $TestResultsPath -Encoding utf8
@@ -140,8 +142,10 @@ if (-not $NoBuild)
 }
 
 $runStart = Get-Date
-$rawOutput = & dotnet @dotnetArgs 2>&1
+# Preserve progress in the uploaded log even if CI terminates a long-running test host.
+& dotnet @dotnetArgs 2>&1 | Tee-Object -FilePath $TestResultsPath | Out-Null
 $dotnetExitCode = $LASTEXITCODE
+$rawOutput = Get-Content -Path $TestResultsPath
 
 # Write full dotnet output to log before TRX parsing
 $cleanOutput = $rawOutput | ForEach-Object {