diff --git a/PolyPilot.Tests/EventsJsonlParsingTests.cs b/PolyPilot.Tests/EventsJsonlParsingTests.cs
index ed96e80012..077b630eed 100644
--- a/PolyPilot.Tests/EventsJsonlParsingTests.cs
+++ b/PolyPilot.Tests/EventsJsonlParsingTests.cs
@@ -87,23 +87,27 @@ public void TitleCleaning_RemovesNewlines()
     [Fact]
     public void IsSessionStillProcessing_ActiveEventTypes()
     {
+        // Terminal events are the only ones that indicate processing is complete.
+        // Everything else (including intermediate events like assistant.turn_end,
+        // assistant.message, tool.execution_end) means the session is still active.
+        var terminalEvents = new[] { "session.idle", "session.error", "session.shutdown" };
+
+        // These should indicate the session is still processing (not terminal)
         var activeEvents = new[]
         {
             "assistant.turn_start", "tool.execution_start",
             "tool.execution_progress", "assistant.message_delta",
             "assistant.reasoning", "assistant.reasoning_delta",
-            "assistant.intent"
+            "assistant.intent", "assistant.turn_end",
+            "assistant.message", "session.start"
         };
-
-        // These should indicate the session is still processing
         foreach (var eventType in activeEvents)
         {
-            Assert.Contains(eventType, activeEvents);
+            Assert.DoesNotContain(eventType, terminalEvents);
         }
 
-        // These should NOT indicate processing
-        var inactiveEvents = new[] { "session.idle", "assistant.message", "session.start" };
-        foreach (var eventType in inactiveEvents)
+        // These SHOULD indicate processing is complete (terminal) — must not appear in activeEvents
+        foreach (var eventType in terminalEvents)
         {
             Assert.DoesNotContain(eventType, activeEvents);
         }
diff --git a/PolyPilot.Tests/ModelSelectionTests.cs b/PolyPilot.Tests/ModelSelectionTests.cs
index 4f4a8d00e5..038c086b92 100644
--- a/PolyPilot.Tests/ModelSelectionTests.cs
+++ b/PolyPilot.Tests/ModelSelectionTests.cs
@@ -494,11 +494,10 @@ public void ChangeModel_DisplayNameFromDropdown_NormalizesToSlug()
     }
 
     // --- PrettifyModel tests ---
-    // The prettifier is duplicated in ExpandedSessionView.razor and ModelSelector.razor.
-    // We test the logic inline here to catch regressions like the "Opus-4.5" bug.
+    // Now centralized in ModelHelper.PrettifyModel. Tests use the real method.
 
     /// <summary>
-    /// Mirror of the PrettifyModel logic from ExpandedSessionView.razor / ModelSelector.razor.
+    /// Mirror of the PrettifyModel logic for tests that don't pass a displayNames dictionary.
     /// </summary>
     private static string PrettifyModel(string modelId)
     {
@@ -578,4 +577,76 @@ public void RoundTrip_NormalizeAndPrettify_AreConsistent(string slug)
         var backToSlug = ModelHelper.NormalizeToSlug(pretty);
         Assert.Equal(slug, backToSlug);
     }
+
+    [Fact]
+    public void PrettifyModel_UsesDisplayNamesWhenAvailable()
+    {
+        var displayNames = new Dictionary<string, string>
+        {
+            ["claude-opus-4.6-1m"] = "Claude Opus 4.6 (1M Context)(Internal Only)",
+            ["claude-opus-4.6"] = "Claude Opus 4.6",
+        };
+        Assert.Equal("Claude Opus 4.6 (1M Context)(Internal Only)",
+            ModelHelper.PrettifyModel("claude-opus-4.6-1m", displayNames));
+        Assert.Equal("Claude Opus 4.6",
+            ModelHelper.PrettifyModel("claude-opus-4.6", displayNames));
+        // Falls back to algorithmic when not in dictionary
+        Assert.Equal("Claude Sonnet 4.5",
+            ModelHelper.PrettifyModel("claude-sonnet-4.5", displayNames));
+    }
+
+    // --- 1M Context model tests (regression for Issue: model doesn't stay selected) ---
+
+    [Fact]
+    public void NormalizeToSlug_1mContext_PreservesSuffix()
+    {
+        // The core bug: "Claude Opus 4.6 (1M Context)(Internal Only)" was
+        // being normalized to "claude-opus-4.6" instead of "claude-opus-4.6-1m"
+        var displayName = "Claude Opus 4.6 (1M Context)(Internal Only)";
+        var slug = ModelHelper.NormalizeToSlug(displayName);
+        Assert.Equal("claude-opus-4.6-1m", slug);
+    }
+
+    [Theory]
+    [InlineData("Claude Opus 4.6 (1M Context)", "claude-opus-4.6-1m")]
+    [InlineData("Claude Opus 4.6 (1M context)(Internal Only)", "claude-opus-4.6-1m")]
+    [InlineData("claude-opus-4.6-1m", "claude-opus-4.6-1m")]
+    public void NormalizeToSlug_1mVariants_AllResolveCorrectly(string input, string expected)
+    {
+        Assert.Equal(expected, ModelHelper.NormalizeToSlug(input));
+    }
+
+    [Fact]
+    public void NormalizeToSlug_MultipleParentheses_ParsedCorrectly()
+    {
+        // Handles multiple parenthetical groups independently
+        var input = "Claude Opus 4.6 (1M Context)(Internal Only)";
+        var slug = ModelHelper.NormalizeToSlug(input);
+        // "1M Context" → "-1m", "Internal Only" → ignored
+        Assert.Equal("claude-opus-4.6-1m", slug);
+        Assert.NotEqual("claude-opus-4.6", slug); // The old broken behavior
+    }
+
+    [Fact]
+    public void FallbackModels_Includes1mModel()
+    {
+        Assert.Contains("claude-opus-4.6-1m", ModelHelper.FallbackModels);
+    }
+
+    [Fact]
+    public void SessionsListPayload_IncludesModelFields()
+    {
+        var payload = new SessionsListPayload
+        {
+            AvailableModels = new List<string> { "claude-opus-4.6", "claude-opus-4.6-1m" },
+            ModelDisplayNames = new Dictionary<string, string>
+            {
+                ["claude-opus-4.6-1m"] = "Claude Opus 4.6 (1M Context)(Internal Only)"
+            }
+        };
+        Assert.NotNull(payload.AvailableModels);
+        Assert.Equal(2, payload.AvailableModels.Count);
+        Assert.Contains("claude-opus-4.6-1m", payload.AvailableModels);
+        Assert.True(payload.ModelDisplayNames!.ContainsKey("claude-opus-4.6-1m"));
+    }
 }
diff --git a/PolyPilot.Tests/PolyPilot.Tests.csproj b/PolyPilot.Tests/PolyPilot.Tests.csproj
index 052f81c420..0bda4e79b0 100644
--- a/PolyPilot.Tests/PolyPilot.Tests.csproj
+++ b/PolyPilot.Tests/PolyPilot.Tests.csproj
@@ -36,6 +36,7 @@
     <Compile Include="../PolyPilot/Models/SessionOrganization.cs" Link="Shared/SessionOrganization.cs" />
     <Compile Include="../PolyPilot/Models/FiestaModels.cs" Link="Shared/FiestaModels.cs" />
     <Compile Include="../PolyPilot/Models/ModelHelper.cs" Link="Shared/ModelHelper.cs" />
+    <Compile Include="../PolyPilot/Models/RoutingHelper.cs" Link="Shared/RoutingHelper.cs" />
     <Compile Include="../PolyPilot/Models/CommandHistory.cs" Link="Shared/CommandHistory.cs" />
     <Compile Include="../PolyPilot/Models/RepositoryInfo.cs" Link="Shared/RepositoryInfo.cs" />
     <Compile Include="../PolyPilot/Models/RenderThrottle.cs" Link="Shared/RenderThrottle.cs" />
diff --git a/PolyPilot.Tests/RoutingHelperTests.cs b/PolyPilot.Tests/RoutingHelperTests.cs
new file mode 100644
index 0000000000..4e890b6fc7
--- /dev/null
+++ b/PolyPilot.Tests/RoutingHelperTests.cs
@@ -0,0 +1,179 @@
+using PolyPilot.Models;
+
+namespace PolyPilot.Tests;
+
+/// <summary>
+/// Tests for RoutingHelper.ExtractForwardedContent — the natural-language routing
+/// extraction that enables "please tell @Session that X" → forwards "X" to @Session.
+/// </summary>
+public class RoutingHelperTests
+{
+    // ── Helper: call both args the same way we do in Dashboard.razor ─────────
+    private static string Extract(string strippedMessage, string originalPrompt)
+        => RoutingHelper.ExtractForwardedContent(strippedMessage, originalPrompt);
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Passthrough — messages that need no transformation
+    // ─────────────────────────────────────────────────────────────────────────
+
+    [Theory]
+    [InlineData("hello world", "hello world")]
+    [InlineData("please fix this bug", "please fix this bug")]
+    [InlineData("the tests are now passing", "the tests are now passing")]
+    public void PlainContent_ReturnsUnchanged(string stripped, string original)
+        => Assert.Equal(stripped, Extract(stripped, original));
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // "please tell @Session that X" → X
+    // ─────────────────────────────────────────────────────────────────────────
+
+    [Fact]
+    public void PleaseTell_ThatContent_ExtractsContent()
+    {
+        // "please tell @Bob that the tests pass" after @-strip → "please tell that the tests pass"
+        var result = Extract("please tell that the tests pass", "please tell @Bob that the tests pass");
+        Assert.Equal("the tests pass", result);
+    }
+
+    [Fact]
+    public void PleaseForward_ColonContent_ExtractsContent()
+    {
+        // "please forward to @Bob: hello world" after @-strip → "please forward to : hello world"
+        // after colon-cleanup → "hello world"
+        var stripped = "please forward to : hello world";
+        var result = Extract(stripped, "please forward to @Bob: hello world");
+        Assert.Equal("hello world", result);
+    }
+
+    [Fact]
+    public void CanYouSend_ThatContent_ExtractsContent()
+    {
+        var stripped = "can you send that the meeting is at 3pm";
+        var result = Extract(stripped, "can you send @Bob that the meeting is at 3pm");
+        Assert.Equal("the meeting is at 3pm", result);
+    }
+
+    [Fact]
+    public void CouldYouTell_ThatContent_ExtractsContent()
+    {
+        var stripped = "could you tell that everything is working";
+        var result = Extract(stripped, "could you tell @Session that everything is working");
+        Assert.Equal("everything is working", result);
+    }
+
+    [Fact]
+    public void PleaseSend_MessageContent_ExtractsContent()
+    {
+        var stripped = "please send a message to : hello there";
+        var result = Extract(stripped, "please send a message to @Session: hello there");
+        Assert.Equal("hello there", result);
+    }
+
+    [Fact]
+    public void PleaseAsk_SayingContent_ExtractsContent()
+    {
+        var stripped = "please ask saying can you fix the bug";
+        var result = Extract(stripped, "please ask @Session saying can you fix the bug");
+        Assert.Equal("can you fix the bug", result);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Fallback: empty content after stripping → return original minus @tokens
+    // ─────────────────────────────────────────────────────────────────────────
+
+    [Fact]
+    public void PleasePassThisInfoTo_NoContent_FallsBackToOriginal()
+    {
+        // After stripping @Session: "please pass this info to"
+        // No extractable content → fallback to original minus @mention
+        var stripped = "please pass this info to";
+        var original = "please pass this info to @Session";
+        var result = Extract(stripped, original);
+        // Fallback preserves the original routing instruction (target gets context)
+        Assert.Equal("please pass this info to", result);
+    }
+
+    [Fact]
+    public void PleaseForwardThis_NoContent_FallsBackToOriginal()
+    {
+        var stripped = "please forward this";
+        var original = "please forward this @Bob";
+        var result = Extract(stripped, original);
+        Assert.Equal("please forward this", result);
+    }
+
+    [Fact]
+    public void TellAbout_NoExplicitContent_FallsBackToOriginal()
+    {
+        // "tell @Session about it" → stripped: "tell about it"
+        // After routing prefix strip: "about it" → connector "about" strip → "it"
+        // "it" is too short (< 3 chars) → fallback to "tell about it"
+        var stripped = "tell about it";
+        var original = "tell @Session about it";
+        var result = Extract(stripped, original);
+        // "it" is only 2 chars so fallback fires → "tell about it"
+        Assert.Equal("tell about it", result);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Message BEFORE the @mention — already handled by @-strip, no change needed
+    // ─────────────────────────────────────────────────────────────────────────
+
+    [Fact]
+    public void ContentBeforeMention_PassesThrough()
+    {
+        // "check this out @Session" → stripped: "check this out"
+        // No routing prefix → return as-is
+        var stripped = "check this out";
+        var result = Extract(stripped, "check this out @Session");
+        Assert.Equal("check this out", result);
+    }
+
+    [Fact]
+    public void HeyMention_Content_PassesThrough()
+    {
+        // "@Session please fix this bug" → stripped: "please fix this bug"
+        var stripped = "please fix this bug";
+        var result = Extract(stripped, "@Session please fix this bug");
+        Assert.Equal("please fix this bug", result);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Regression: plain routing phrases don't eat normal sentences
+    // ─────────────────────────────────────────────────────────────────────────
+
+    [Fact]
+    public void MessageStartingWithForward_NotARoutingInstruction_IsKept()
+    {
+        // "forward slash commands are important" should NOT be stripped
+        // because "slash" doesn't match the routing prefix pattern
+        var stripped = "forward slash commands are important";
+        var result = Extract(stripped, "forward slash commands are important @Session");
+        // "forward slash" doesn't match (next word after "forward" isn't recognized)
+        // so stripped → "forward slash commands are important"
+        Assert.Equal("forward slash commands are important", result);
+    }
+
+    [Fact]
+    public void MessageStartingWithAsk_Question_IsKept()
+    {
+        // "ask me anything" after strip → "ask me anything" — "me" doesn't trigger routing
+        var stripped = "ask me anything";
+        var result = Extract(stripped, "ask me anything @Session");
+        // "ask me" doesn't match the routing suffix (no "to/:" after) so it passes through
+        // (or gets partially stripped but enough remains)
+        Assert.True(result.Length >= 3, $"Result should be non-trivial, got: '{result}'");
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Whitespace handling
+    // ─────────────────────────────────────────────────────────────────────────
+
+    [Fact]
+    public void ExtraWhitespace_IsCollapsed()
+    {
+        var stripped = "please  tell  that   hello   world";
+        var result = Extract(stripped, "please tell @Bob that   hello   world");
+        Assert.Equal("hello world", result);
+    }
+}
diff --git a/PolyPilot.Tests/StateChangeCoalescerTests.cs b/PolyPilot.Tests/StateChangeCoalescerTests.cs
index 5f41e44e54..336afd0895 100644
--- a/PolyPilot.Tests/StateChangeCoalescerTests.cs
+++ b/PolyPilot.Tests/StateChangeCoalescerTests.cs
@@ -70,22 +70,35 @@ public async Task SeparateBursts_FireSeparately()
     {
         var svc = CreateService();
         int fireCount = 0;
-        svc.OnStateChanged += () => Interlocked.Increment(ref fireCount);
 
-        // First burst
+        // First burst — wait via TCS so we don't depend on wall-clock timing.
+        // Under heavy parallel test load, fixed delays like 800ms can be shorter
+        // than the threadpool-delayed timer callback, causing the pending CAS flag
+        // to remain set when burst 2 starts — burst 2 then silently merges into burst 1
+        // and only one notification fires instead of two.
+        var tcs1 = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        svc.OnStateChanged += () =>
+        {
+            Interlocked.Increment(ref fireCount);
+            tcs1.TrySetResult();
+        };
+
         for (int i = 0; i < 10; i++)
             svc.NotifyStateChangedCoalesced();
-        // Wait well beyond the coalesce window (150ms) to ensure the timer fires,
-        // even under heavy CI/GC load. Previous 300ms was flaky under load.
-        await Task.Delay(800);
+        // Wait for first burst to actually fire (with generous 5s timeout)
+        await Task.WhenAny(tcs1.Task, Task.Delay(5000));
+        Assert.True(tcs1.Task.IsCompleted, "First burst should have fired within 5s");
 
-        // Second burst after timer has fired
+        // Second burst after first has fired
+        var tcs2 = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        svc.OnStateChanged += () => tcs2.TrySetResult();
         for (int i = 0; i < 10; i++)
             svc.NotifyStateChangedCoalesced();
-        await Task.Delay(800);
+        await Task.WhenAny(tcs2.Task, Task.Delay(5000));
+        Assert.True(tcs2.Task.IsCompleted, "Second burst should have fired within 5s");
 
-        // Each burst should produce ~1 notification
-        Assert.InRange(fireCount, 2, 4);
+        // Each burst produced at least one notification — total should be 2 or slightly more
+        Assert.InRange(fireCount, 2, 6);
     }
 
     [Fact]
diff --git a/PolyPilot.Tests/StuckSessionRecoveryTests.cs b/PolyPilot.Tests/StuckSessionRecoveryTests.cs
index bd82d41907..eab468943a 100644
--- a/PolyPilot.Tests/StuckSessionRecoveryTests.cs
+++ b/PolyPilot.Tests/StuckSessionRecoveryTests.cs
@@ -303,6 +303,10 @@ public void StalenessThreshold_UsesWatchdogToolExecutionTimeout()
     [InlineData("assistant.reasoning")]
     [InlineData("assistant.reasoning_delta")]
     [InlineData("assistant.intent")]
+    [InlineData("assistant.turn_end")]       // between tool rounds — still processing
+    [InlineData("assistant.message")]        // mid-turn text — still processing
+    [InlineData("tool.execution_end")]       // tool just completed — still processing
+    [InlineData("session.start")]            // session just started — still processing
     public void IsSessionStillProcessing_AllActiveEventTypes_ReturnTrue(string eventType)
     {
         var svc = CreateService();
@@ -326,11 +330,9 @@ public void IsSessionStillProcessing_AllActiveEventTypes_ReturnTrue(string event
 
     [Theory]
     [InlineData("session.idle")]
-    [InlineData("assistant.message")]
-    [InlineData("session.start")]
-    [InlineData("assistant.turn_end")]
-    [InlineData("tool.execution_end")]
-    public void IsSessionStillProcessing_InactiveEventTypes_ReturnFalse(string eventType)
+    [InlineData("session.error")]
+    [InlineData("session.shutdown")]
+    public void IsSessionStillProcessing_TerminalEventTypes_ReturnFalse(string eventType)
     {
         var svc = CreateService();
         var tmpDir = Path.Combine(Path.GetTempPath(), "polypilot-test-" + Guid.NewGuid().ToString("N"));
@@ -343,7 +345,7 @@ public void IsSessionStillProcessing_InactiveEventTypes_ReturnFalse(string event
         {
             File.WriteAllText(eventsFile, $$$"""{"type":"{{{eventType}}}","data":{}}""");
             var result = svc.IsSessionStillProcessing(sessionId, tmpDir);
-            Assert.False(result, $"Inactive event type '{eventType}' should not report still processing");
+            Assert.False(result, $"Terminal event type '{eventType}' should not report still processing");
         }
         finally
         {
diff --git a/PolyPilot.Tests/TestStubs.cs b/PolyPilot.Tests/TestStubs.cs
index 7a24317f2e..1ec4443518 100644
--- a/PolyPilot.Tests/TestStubs.cs
+++ b/PolyPilot.Tests/TestStubs.cs
@@ -73,6 +73,7 @@ internal class StubWsBridgeClient : IWsBridgeClient
     public string? GitHubLogin { get; set; }
     public string? ServerMachineName { get; set; }
     public List<string> AvailableModels { get; set; } = new();
+    public Dictionary<string, string> ModelDisplayNames { get; set; } = new();
 
     public event Action? OnStateChanged;
     public event Action<string, string>? OnContentReceived;
diff --git a/PolyPilot/Components/ExpandedSessionView.razor b/PolyPilot/Components/ExpandedSessionView.razor
index 019330b80e..1d3b9c2c17 100644
--- a/PolyPilot/Components/ExpandedSessionView.razor
+++ b/PolyPilot/Components/ExpandedSessionView.razor
@@ -339,6 +339,7 @@
     [Parameter] public string InputMode { get; set; } = "chat";
     [Parameter] public string CurrentModel { get; set; } = "";
     [Parameter] public IReadOnlyList<string> AvailableModels { get; set; } = Array.Empty<string>();
+    [Parameter] public IReadOnlyDictionary<string, string>? ModelDisplayNames { get; set; }
     [Parameter] public List<PendingImage>? PendingImages { get; set; }
     [Parameter] public string? UserAvatarUrl { get; set; }
     [Parameter] public string? RepoUrl { get; set; }
@@ -350,6 +351,7 @@
     [Parameter] public int MessageWindowSize { get; set; } = 25;
     [Parameter] public bool FiestaActive { get; set; }
     [Parameter] public IReadOnlyList<FiestaLinkedWorker> FiestaWorkers { get; set; } = Array.Empty<FiestaLinkedWorker>();
+    [Parameter] public IReadOnlyList<string> AllSessionNames { get; set; } = Array.Empty<string>();
 
     [Parameter] public EventCallback<string> OnSend { get; set; }
     [Parameter] public EventCallback<string> OnStop { get; set; }
@@ -545,19 +547,9 @@
     private void LoadMore() => OnLoadMore.InvokeAsync(Session.Name);
     private void LoadFullHistory() => OnLoadFullHistory.InvokeAsync(Session.Name);
 
-    private static string PrettifyModel(string modelId)
+    private string PrettifyModel(string modelId)
     {
-        var display = modelId
-            .Replace("claude-", "Claude ")
-            .Replace("gpt-", "GPT-")
-            .Replace("gemini-", "Gemini ");
-        // Replace remaining hyphens with spaces (e.g. "opus-4.5" → "opus 4.5")
-        // but preserve hyphens within the GPT- prefix (already handled above)
-        display = display.Replace("-", " ");
-        // Re-insert hyphen for GPT prefix
-        display = display.Replace("GPT ", "GPT-");
-        return string.Join(' ', display.Split(' ', StringSplitOptions.RemoveEmptyEntries).Select(s =>
-            s.Length > 0 ? char.ToUpper(s[0]) + s[1..] : s));
+        return Models.ModelHelper.PrettifyModel(modelId, ModelDisplayNames);
     }
 
     private void OpenSessionFolder(string sessionId)
@@ -741,12 +733,18 @@
     {
         get
         {
-            var tokens = FiestaWorkers
+            var fiestaTokens = FiestaWorkers
                 .SelectMany(w => new[]
                 {
                     NormalizeMentionToken(w.Hostname),
                     NormalizeMentionToken(w.Name)
-                })
+                });
+
+            var sessionTokens = AllSessionNames
+                .Where(n => !string.Equals(n, Session.Name, StringComparison.OrdinalIgnoreCase))
+                .Select(NormalizeMentionToken);
+
+            var tokens = fiestaTokens.Concat(sessionTokens)
                 .Where(t => !string.IsNullOrWhiteSpace(t))
                 .Distinct(StringComparer.OrdinalIgnoreCase)
                 .OrderBy(t => t, StringComparer.OrdinalIgnoreCase);
diff --git a/PolyPilot/Components/Layout/CreateSessionForm.razor b/PolyPilot/Components/Layout/CreateSessionForm.razor
index 2a58b4dcfc..0a4e3fc45e 100644
--- a/PolyPilot/Components/Layout/CreateSessionForm.razor
+++ b/PolyPilot/Components/Layout/CreateSessionForm.razor
@@ -164,7 +164,7 @@ else
                   class="ns-prompt" rows="2"></textarea>
 
         <div class="ns-footer">
-            <ModelSelector Value="@SelectedModel" ValueChanged="OnModelSelected" Models="AvailableModels" CssClass="ns-model" />
+            <ModelSelector Value="@SelectedModel" ValueChanged="OnModelSelected" Models="AvailableModels" DisplayNames="ModelDisplayNames" CssClass="ns-model" />
             <div class="ns-footer-actions">
                 <button class="ns-cancel" @onclick="Collapse">Cancel</button>
                 <button class="ns-create" @onclick="TriggerCreate"
@@ -195,6 +195,7 @@ else
     [Parameter] public bool IsCreating { get; set; }
     [Parameter] public string? CreateError { get; set; }
     [Parameter] public List<string> AvailableModels { get; set; } = new();
+    [Parameter] public IReadOnlyDictionary<string, string>? ModelDisplayNames { get; set; }
     [Parameter] public string SelectedModel { get; set; } = "claude-opus-4.6";
     [Parameter] public EventCallback<string> SelectedModelChanged { get; set; }
 
diff --git a/PolyPilot/Components/Layout/SessionListItem.razor b/PolyPilot/Components/Layout/SessionListItem.razor
index 15389c6f4e..858728c9b0 100644
--- a/PolyPilot/Components/Layout/SessionListItem.razor
+++ b/PolyPilot/Components/Layout/SessionListItem.razor
@@ -194,7 +194,8 @@
                             @foreach (var model in CopilotService.AvailableModels)
                             {
                                 var strengths = ModelCapabilities.GetStrengths(model);
-                                <option value="@model" title="@strengths">@model</option>
+                                var displayName = PolyPilot.Models.ModelHelper.PrettifyModel(model, CopilotService.ModelDisplayNames);
+                                <option value="@model" title="@strengths">@displayName</option>
                             }
                         </select>
                         @{
diff --git a/PolyPilot/Components/Layout/SessionSidebar.razor b/PolyPilot/Components/Layout/SessionSidebar.razor
index 0b7dae6327..ace71019b7 100644
--- a/PolyPilot/Components/Layout/SessionSidebar.razor
+++ b/PolyPilot/Components/Layout/SessionSidebar.razor
@@ -35,6 +35,7 @@ else if (IsFlyoutPanel)
             <CreateSessionForm @ref="createSessionFormRef" @bind-SessionName="newSessionName"
                                @bind-SelectedModel="selectedModel"
                                AvailableModels="availableModels.ToList()"
+                               ModelDisplayNames="CopilotService.ModelDisplayNames"
                                IsCreating="isCreating"
                                CreateError="@createError"
                                OnCreate="HandleCreateSession"
@@ -98,6 +99,7 @@ else
             <CreateSessionForm @ref="createSessionFormRef" @bind-SessionName="newSessionName"
                                @bind-SelectedModel="selectedModel"
                                AvailableModels="availableModels.ToList()"
+                               ModelDisplayNames="CopilotService.ModelDisplayNames"
                                IsCreating="isCreating"
                                CreateError="@createError"
                                OnCreate="HandleCreateSession"
diff --git a/PolyPilot/Components/ModelSelector.razor b/PolyPilot/Components/ModelSelector.razor
index 8b2a83f0f6..644411cd42 100644
--- a/PolyPilot/Components/ModelSelector.razor
+++ b/PolyPilot/Components/ModelSelector.razor
@@ -32,6 +32,7 @@
     [Parameter] public string Value { get; set; } = "";
     [Parameter] public EventCallback<string> ValueChanged { get; set; }
     [Parameter] public IReadOnlyList<string> Models { get; set; } = Array.Empty<string>();
+    [Parameter] public IReadOnlyDictionary<string, string>? DisplayNames { get; set; }
     [Parameter] public string CssClass { get; set; } = "";
 
     private bool isOpen;
@@ -69,18 +70,7 @@
             icon = @"<svg xmlns=""http://www.w3.org/2000/svg"" width=""14"" height=""14"" viewBox=""0 0 24 24"" fill=""none""><circle cx=""12"" cy=""12"" r=""10"" stroke=""currentColor"" stroke-width=""2""/></svg>";
 
         // Prettify display name
-        var display = modelId
-            .Replace("claude-", "Claude ")
-            .Replace("gpt-", "GPT-")
-            .Replace("gemini-", "Gemini ");
-        // Replace remaining hyphens with spaces (e.g. "opus-4.5" → "opus 4.5")
-        display = display.Replace("-", " ");
-        // Re-insert hyphen for GPT prefix
-        display = display.Replace("GPT ", "GPT-");
-
-        // Capitalize segments
-        display = string.Join(' ', display.Split(' ', StringSplitOptions.RemoveEmptyEntries).Select(s =>
-            s.Length > 0 ? char.ToUpper(s[0]) + s[1..] : s));
+        var display = PolyPilot.Models.ModelHelper.PrettifyModel(modelId, DisplayNames);
 
         return new ModelDisplayInfo(display, icon);
     }
diff --git a/PolyPilot/Components/Pages/Dashboard.razor b/PolyPilot/Components/Pages/Dashboard.razor
index 62e0b46095..4f732c2d4e 100644
--- a/PolyPilot/Components/Pages/Dashboard.razor
+++ b/PolyPilot/Components/Pages/Dashboard.razor
@@ -169,6 +169,7 @@
                                      InputMode="@GetInputMode(session.Name)"
                                      CurrentModel="@GetExpandedModel(session)"
                                      AvailableModels="availableModels"
+                                     ModelDisplayNames="CopilotService.ModelDisplayNames"
                                      PendingImages="@(pendingImagesBySession.TryGetValue(session.Name, out var pi2) ? pi2 : null)"
                                      UserAvatarUrl="@CopilotService.GitHubAvatarUrl"
                                      RepoUrl="@CopilotService.GetRepoUrlForSession(session.Name)"
@@ -178,6 +179,7 @@
                                      MessageWindowSize="@(expandedMessageCounts.TryGetValue(session.Name, out var emc) ? emc : 25)"
                                      FiestaActive="@FiestaService.IsFiestaActive(session.Name)"
                                      FiestaWorkers="@GetFiestaWorkersForSession(session.Name)"
+                                     AllSessionNames="@allSessionNames"
                                      OnSend="HandleSend"
                                      OnStop="StopSession"
                                      OnCollapse="CollapseExpanded"
@@ -1246,6 +1248,7 @@
                 return;
 
             sessions = CopilotService.GetAllSessions().ToList();
+            _cachedAllSessionNames = null;
 
             if (!_initialGridSet && sessions.Count > 1)
             {
@@ -1587,6 +1590,54 @@
             return;
         }
 
+        // Cross-session routing: check for @SessionName mentions matching other PolyPilot sessions.
+        // Build a lookup of normalized-token → session name for all sessions except the current one.
+        var crossSessionTargets = RouteToMentionedSessions(sessionName, finalPrompt);
+        Console.WriteLine($"[CROSS-SESSION] source={sessionName} targets={crossSessionTargets.Count}");
+        if (crossSessionTargets.Count > 0)
+        {
+            // Clear pending images — they cannot be forwarded cross-session.
+            if (hasImages) pendingImagesBySession.Remove(sessionName);
+
+            // Add the user message to the current session's history
+            var sourceSession = sessions.FirstOrDefault(s => s.Name == sessionName);
+            sourceSession?.History.Add(ChatMessage.UserMessage(finalPrompt));
+
+            foreach (var (targetName, strippedMessage) in crossSessionTargets)
+            {
+                // Send to target session
+                _ = CopilotService.SendPromptAsync(targetName, strippedMessage).ContinueWith(t =>
+                {
+                    if (t.IsFaulted)
+                    {
+                        var err = t.Exception?.InnerException?.Message ?? t.Exception?.Message ?? "unknown error";
+                        InvokeAsync(() =>
+                        {
+                            var src = sessions.FirstOrDefault(s => s.Name == sessionName);
+                            if (src != null)
+                            {
+                                src.History.Add(ChatMessage.ErrorMessage($"Failed to forward to @{targetName}: {err}"));
+                                src.MessageCount = src.History.Count;
+                            }
+                            _ = SafeRefreshAsync();
+                        });
+                    }
+                });
+
+                // Add a system message in the source session indicating the forward
+                sourceSession?.History.Add(ChatMessage.SystemMessage(
+                    $"📨 Forwarded to @{targetName}: \"{TruncateForDisplay(strippedMessage, 80)}\""));
+            }
+
+            if (sourceSession != null)
+                sourceSession.MessageCount = sourceSession.History.Count;
+
+            _needsScrollToBottom = true;
+            await InvokeAsync(SafeRefreshAsync);
+            return;
+        }
+
+
         var session = sessions.FirstOrDefault(s => s.Name == sessionName);
         if (session?.IsCreating == true)
         {
@@ -3355,17 +3406,95 @@
     private IReadOnlyList<string> availableModels =>
         CopilotService.AvailableModels.Count > 0 ? CopilotService.AvailableModels : ModelHelper.FallbackModels;
 
-    private string GetSessionModel(AgentSessionInfo session)
+    private IReadOnlyList<string>? _cachedAllSessionNames;
+    private IReadOnlyList<string> allSessionNames =>
+        _cachedAllSessionNames ??= CopilotService.GetAllSessionNames().ToList();
+
+    /// <summary>
+    /// Parses @Mention tokens from the prompt and matches them against active session names.
+    /// Returns a list of (targetSessionName, forwardedMessage) for each matched session.
+    /// The forwardedMessage has routing-instruction wrappers removed so the target session
+    /// receives clean, natural content (e.g. "please tell @Bob that X" → forwards "X" to Bob).
+    /// Falls back to the full original prompt (minus @tokens) when no explicit content is found,
+    /// so the target always gets something useful.
+    /// </summary>
+    private List<(string TargetName, string StrippedMessage)> RouteToMentionedSessions(string sourceSessionName, string prompt)
     {
-        // Priority: 1) Usage info (TRUTH) - what the backend is actually using
-        if (usageBySession.TryGetValue(session.Name, out var u) && !string.IsNullOrEmpty(u.Model))
-            return u.Model;
+        var result = new List<(string, string)>();
+        if (string.IsNullOrWhiteSpace(prompt)) return result;
+
+        // Build normalized-token → real session name lookup (excluding source session)
+        static string NormalizeToken(string s) =>
+            new(s.Trim().Where(ch => char.IsLetterOrDigit(ch) || ch == '.' || ch == '_' || ch == '-').ToArray());
+
+        var sessionLookup = CopilotService.GetAllSessionNames()
+            .Where(n => !string.Equals(n, sourceSessionName, StringComparison.OrdinalIgnoreCase))
+            .GroupBy(NormalizeToken, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
+
+        Console.WriteLine($"[CROSS-SESSION] sessionLookup has {sessionLookup.Count} entries");
+        if (sessionLookup.Count == 0) return result;
+
+        // Scan the entire message for @SessionName mentions (not just at start).
+        // Requires @ to be at start-of-string or preceded by whitespace to avoid
+        // matching email addresses (user@host), code annotations (@override), etc.
+        var atMentionRegex = new System.Text.RegularExpressions.Regex(@"(?<!\S)@([\w.\-]+)");
+        var matched = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (System.Text.RegularExpressions.Match m in atMentionRegex.Matches(prompt))
+        {
+            var token = m.Groups[1].Value;
+            if (sessionLookup.TryGetValue(token, out var targetSession))
+                matched.Add(targetSession);
+        }
+
+        if (matched.Count == 0) return result;
+
+        // Strip all matched @SessionName tokens from the message and collapse whitespace.
+        var strippedMessage = atMentionRegex.Replace(prompt, m =>
+            sessionLookup.ContainsKey(m.Groups[1].Value) ? "" : m.Value);
+        strippedMessage = System.Text.RegularExpressions.Regex.Replace(strippedMessage, @"[ \t]{2,}", " ").Trim();
 
-        // Priority: 2) Session model property (initial configuration)
+        // Extract the actual content from natural-language routing instructions.
+        // e.g. "please tell @Bob that X" → "X"
+        //      "can you forward to @Bob: X" → "X"
+        //      "hey @Bob please do X" → "please do X"  (already correct after @-strip)
+        // Falls back to the full stripped message if no routing wrapper is found,
+        // and to the original prompt (without @tokens) if the message becomes empty.
+        var forwardedContent = RoutingHelper.ExtractForwardedContent(strippedMessage, prompt);
+
+        foreach (var target in matched)
+            result.Add((target, forwardedContent));
+
+        return result;
+    }
+
+    /// <summary>
+    /// Cleans routing-instruction wrappers from a message that has already had @mention tokens
+    /// stripped, extracting the actual content the user wants forwarded.
+    ///
+    /// Handles patterns like:
+    ///   "please tell that X"        → "X"
+    ///   "can you send this to: X"   → "X"
+    ///   "please pass this info to"  → (fallback to rawPromptNoMentions)
+    ///   "forward the following to"  → (fallback to rawPromptNoMentions)
+    ///   "X" (no routing wrapper)    → "X"  (unchanged)
+    /// </summary>
+    private static string TruncateForDisplay(string text, int maxLength) =>
+        text.Length <= maxLength ? text : text[..maxLength] + "…";
+
+    private string GetSessionModel(AgentSessionInfo session)
+    {
+        // Priority: 1) Session model property (user's explicit choice, persisted across restarts)
         if (!string.IsNullOrEmpty(session.Model) && session.Model != "resumed")
             return session.Model;
 
-        return availableModels[0];
+        // Priority: 2) Usage info - what the backend reported
+        if (usageBySession.TryGetValue(session.Name, out var u) && !string.IsNullOrEmpty(u.Model))
+            return u.Model;
+
+        // Fallback: default model (never alphabetical first which may be haiku)
+        return CopilotService.DefaultModel;
     }
 
     private string GetExpandedModel(AgentSessionInfo session)
diff --git a/PolyPilot/Models/BridgeMessages.cs b/PolyPilot/Models/BridgeMessages.cs
index 06f2436d7f..42c5bdca7b 100644
--- a/PolyPilot/Models/BridgeMessages.cs
+++ b/PolyPilot/Models/BridgeMessages.cs
@@ -139,8 +139,10 @@ public class SessionsListPayload
     public string? GitHubLogin { get; set; }
     /// <summary>Server's machine name, used by remote clients to open VS Code via Remote - Tunnels.</summary>
     public string? ServerMachineName { get; set; }
-    /// <summary>Available model display names fetched from the SDK on the desktop. Null means not yet fetched.</summary>
+    /// <summary>Available model slugs from the SDK's ListModelsAsync.</summary>
     public List<string>? AvailableModels { get; set; }
+    /// <summary>Maps model slug → display name (e.g., "claude-opus-4.6-1m" → "Claude Opus 4.6 (1M Context)(Internal Only)").</summary>
+    public Dictionary<string, string>? ModelDisplayNames { get; set; }
 }
 
 public class SessionSummary
diff --git a/PolyPilot/Models/ModelHelper.cs b/PolyPilot/Models/ModelHelper.cs
index 0734ce893a..30b3b65a1f 100644
--- a/PolyPilot/Models/ModelHelper.cs
+++ b/PolyPilot/Models/ModelHelper.cs
@@ -13,6 +13,7 @@ public static class ModelHelper
     public static IReadOnlyList<string> FallbackModels { get; } = new[]
     {
         "claude-opus-4.6",
+        "claude-opus-4.6-1m",
         "claude-opus-4.6-fast",
         "claude-opus-4.5",
         "claude-sonnet-4.5",
@@ -89,6 +90,30 @@ public static bool IsDisplayName(string? model)
         return model.Any(char.IsUpper) || model.Contains(' ');
     }
 
+    /// <summary>
+    /// Converts a model slug to a human-friendly display name.
+    /// If displayNames dictionary is provided and contains the slug, uses the SDK's display name.
+    /// Otherwise falls back to algorithmic prettification.
+    /// </summary>
+    public static string PrettifyModel(string modelId, IReadOnlyDictionary<string, string>? displayNames = null)
+    {
+        if (string.IsNullOrEmpty(modelId)) return modelId;
+
+        // If we have an SDK-provided display name, prefer it
+        if (displayNames != null && displayNames.TryGetValue(modelId, out var sdkName))
+            return sdkName;
+
+        // Algorithmic fallback
+        var display = modelId
+            .Replace("claude-", "Claude ")
+            .Replace("gpt-", "GPT-")
+            .Replace("gemini-", "Gemini ");
+        display = display.Replace("-", " ");
+        display = display.Replace("GPT ", "GPT-");
+        return string.Join(' ', display.Split(' ', StringSplitOptions.RemoveEmptyEntries).Select(s =>
+            s.Length > 0 ? char.ToUpper(s[0]) + s[1..] : s));
+    }
+
     internal static string? ExtractLatestModelFromEvents(IEnumerable<string> lines)
     {
         string? latestModel = null;
diff --git a/PolyPilot/Models/RoutingHelper.cs b/PolyPilot/Models/RoutingHelper.cs
new file mode 100644
index 0000000000..1dfc82fa72
--- /dev/null
+++ b/PolyPilot/Models/RoutingHelper.cs
@@ -0,0 +1,81 @@
+using System.Text.RegularExpressions;
+
+namespace PolyPilot.Models;
+
+/// <summary>
+/// Helpers for natural-language cross-session @mention routing.
+/// </summary>
+public static class RoutingHelper
+{
+    private static readonly Regex AtMentionRegex = new(@"(?<!\S)@[\w.\-]+", RegexOptions.Compiled);
+    private static readonly Regex CollapseWhitespace = new(@"\s{2,}", RegexOptions.Compiled);
+
+    // Pattern A — verb + optional filler/noun + explicit "to" or ":" marker.
+    // Requires "to" or ":" at end to avoid false positives (e.g. "forward slash commands").
+    // Word boundaries on "a" and "an" prevent "a" from matching the first char of "about".
+    // Examples: "please forward to :", "send a message to", "please pass this info to"
+    private static readonly Regex RoutingToColonRegex = new(
+        @"^(?:(?:please|can\s+you|could\s+you|would\s+you)\s+)?(?:tell|send|forward|pass(?:\s+(?:along|on))?|relay|share|ask|message|route|give)(?:\s+(?:this|the|a\b|an\b|some|any|them|him|her|along|on))*\s*(?:info(?:rmation)?|message|note|update|news|details|content|context|following)?\s*(?:to\s*|:\s*)",
+        RegexOptions.IgnoreCase | RegexOptions.Compiled);
+
+    // Pattern B — verb directly followed by explicit "that" or "saying" connector.
+    // Examples: "please tell that X", "send saying X"
+    private static readonly Regex RoutingThatSayingRegex = new(
+        @"^(?:(?:please|can\s+you|could\s+you|would\s+you)\s+)?(?:tell|send|forward|pass|relay|share|ask|message|route|give)\s+(?:that|saying)\s+",
+        RegexOptions.IgnoreCase | RegexOptions.Compiled);
+
+    // Strips residual connectors after "to" or ":" stripping: "that ...", "saying ...", ": ..."
+    private static readonly Regex ConnectorRegex = new(
+        @"^(?:that|saying|:)\s*",
+        RegexOptions.IgnoreCase | RegexOptions.Compiled);
+
+    /// <summary>
+    /// Given a message that has already had @mention tokens stripped (strippedMessage),
+    /// extracts the actual content the user wants forwarded by removing routing-instruction
+    /// wrappers. Falls back to the full original prompt (minus @tokens) if stripping leaves
+    /// nothing substantive, so the target session always receives useful context.
+    ///
+    /// Examples:
+    ///   "please tell that the tests pass"      -> "the tests pass"
+    ///   "can you forward to : hello world"     -> "hello world"
+    ///   "please send a message to : hi"        -> "hi"
+    ///   "please pass this info to"             -> "please pass this info to"  (fallback)
+    ///   "forward slash commands are important" -> "forward slash commands are important"
+    ///   "hello world"                          -> "hello world"  (unchanged)
+    /// </summary>
+    public static string ExtractForwardedContent(string strippedMessage, string originalPrompt)
+    {
+        var s = strippedMessage.Trim();
+
+        // Try Pattern A: verb + ... + explicit "to" or ":"
+        var matchA = RoutingToColonRegex.Match(s);
+        if (matchA.Success && matchA.Length > 0)
+        {
+            s = s[matchA.Length..].Trim();
+            // Strip any residual ": " or "that/saying " left after the "to" marker
+            s = ConnectorRegex.Replace(s, "").Trim();
+        }
+        else
+        {
+            // Try Pattern B: verb + "that/saying"
+            var matchB = RoutingThatSayingRegex.Match(s);
+            if (matchB.Success && matchB.Length > 0)
+                s = s[matchB.Length..].Trim();
+        }
+
+        // Collapse whitespace
+        s = CollapseWhitespace.Replace(s, " ").Trim();
+
+        // Fallback: if stripping left nothing substantive (< 3 chars), return the original
+        // prompt with @tokens removed so the target still gets the full routing instruction
+        // as context (e.g. "please pass this info to @Session" -> "please pass this info to")
+        if (s.Length < 3)
+        {
+            var fallback = AtMentionRegex.Replace(originalPrompt, "").Trim();
+            fallback = CollapseWhitespace.Replace(fallback, " ").Trim();
+            return string.IsNullOrWhiteSpace(fallback) ? strippedMessage : fallback;
+        }
+
+        return s;
+    }
+}
diff --git a/PolyPilot/Services/CopilotService.Bridge.cs b/PolyPilot/Services/CopilotService.Bridge.cs
index 068b01f8c9..6f925cdbb8 100644
--- a/PolyPilot/Services/CopilotService.Bridge.cs
+++ b/PolyPilot/Services/CopilotService.Bridge.cs
@@ -48,6 +48,11 @@ private async Task InitializeRemoteAsync(ConnectionSettings settings, Cancellati
         // Wire WsBridgeClient events to our events
         _bridgeClient.OnStateChanged += () =>
         {
+            // Sync model list from bridge when in remote mode
+            if (_bridgeClient.AvailableModels.Count > 0)
+                AvailableModels = _bridgeClient.AvailableModels;
+            if (_bridgeClient.ModelDisplayNames.Count > 0)
+                ModelDisplayNames = _bridgeClient.ModelDisplayNames;
             SyncRemoteSessions();
             NotifyStateChangedCoalesced();
         };
diff --git a/PolyPilot/Services/CopilotService.Events.cs b/PolyPilot/Services/CopilotService.Events.cs
index 295684bb33..51c36c6ad1 100644
--- a/PolyPilot/Services/CopilotService.Events.cs
+++ b/PolyPilot/Services/CopilotService.Events.cs
@@ -710,8 +710,18 @@ await notifService.SendNotificationAsync(
                 if (!string.IsNullOrEmpty(startModel))
                 {
                     var normalizedStartModel = Models.ModelHelper.NormalizeToSlug(startModel);
-                    state.Info.Model = normalizedStartModel;
-                    Debug($"Session model from start event: {startModel} → {normalizedStartModel}");
+                    // Only update if the user hasn't already set a model — the CLI may
+                    // report a default model (e.g. haiku) after abort/resume that overrides
+                    // the user's explicit choice.
+                    if (string.IsNullOrEmpty(state.Info.Model) || state.Info.Model == "resumed")
+                    {
+                        state.Info.Model = normalizedStartModel;
+                        Debug($"Session model from start event: {startModel} → {normalizedStartModel}");
+                    }
+                    else if (normalizedStartModel != state.Info.Model)
+                    {
+                        Debug($"Session model from start event ignored: {startModel} → {normalizedStartModel} (keeping user choice: {state.Info.Model})");
+                    }
                 }
                 Invoke(() => { if (!IsRestoring) SaveActiveSessionsToDisk(); });
                 break;
diff --git a/PolyPilot/Services/CopilotService.Organization.cs b/PolyPilot/Services/CopilotService.Organization.cs
index 09701d4467..324d027413 100644
--- a/PolyPilot/Services/CopilotService.Organization.cs
+++ b/PolyPilot/Services/CopilotService.Organization.cs
@@ -428,8 +428,14 @@ public void SaveOrganization()
         InvalidateOrganizedSessionsCache();
         // Debounce: restart the timer. The callback marshals to the UI thread for
         // serialization since Organization contains non-thread-safe List<T> collections.
+        // Capture paths at schedule time so stale timer callbacks from old service instances
+        // (created when SetBaseDirForTesting redirects the static) always write to the
+        // directory that was current when SaveOrganization was called, not wherever the
+        // static points at fire time. Fixes cross-test timer contamination in tests.
+        var capturedOrgFile = OrganizationFile;
+        var capturedBaseDir = PolyPilotBaseDir;
         _saveOrgDebounce?.Dispose();
-        _saveOrgDebounce = new Timer(_ => InvokeOnUI(() => SaveOrganizationCore()), null, 2000, Timeout.Infinite);
+        _saveOrgDebounce = new Timer(_ => InvokeOnUI(() => SaveOrganizationCore(capturedOrgFile, capturedBaseDir)), null, 2000, Timeout.Infinite);
     }
 
     internal void FlushSaveOrganization()
@@ -439,7 +445,9 @@ internal void FlushSaveOrganization()
         SaveOrganizationCore();
     }
 
-    private void SaveOrganizationCore()
+    private void SaveOrganizationCore() => SaveOrganizationCore(OrganizationFile, PolyPilotBaseDir);
+
+    private void SaveOrganizationCore(string orgFile, string baseDir)
     {
         try
         {
@@ -457,7 +465,7 @@ private void SaveOrganizationCore()
                 };
             }
             var json = JsonSerializer.Serialize(snapshot, new JsonSerializerOptions { WriteIndented = true });
-            WriteOrgFile(json);
+            WriteOrgFile(json, orgFile, baseDir);
         }
         catch (Exception ex)
         {
@@ -467,18 +475,18 @@ private void SaveOrganizationCore()
         }
     }
 
-    private void WriteOrgFile(string json)
+    private void WriteOrgFile(string json, string orgFile, string baseDir)
     {
         try
         {
-            Directory.CreateDirectory(PolyPilotBaseDir);
+            Directory.CreateDirectory(baseDir);
             // Atomic write: write to temp file then rename to prevent corruption on crash
-            var tempFile = OrganizationFile + ".tmp";
+            var tempFile = orgFile + ".tmp";
             File.WriteAllText(tempFile, json);
-            File.Move(tempFile, OrganizationFile, overwrite: true);
+            File.Move(tempFile, orgFile, overwrite: true);
 
             // Verify the write actually persisted (guards against silent filesystem failures)
-            var fi = new FileInfo(OrganizationFile);
+            var fi = new FileInfo(orgFile);
             if (!fi.Exists || fi.Length == 0)
             {
                 Debug($"[SAVE-ERROR] organization file verification failed — file missing or empty after write");
diff --git a/PolyPilot/Services/CopilotService.Persistence.cs b/PolyPilot/Services/CopilotService.Persistence.cs
index fbf7d825f7..923ffccbc0 100644
--- a/PolyPilot/Services/CopilotService.Persistence.cs
+++ b/PolyPilot/Services/CopilotService.Persistence.cs
@@ -646,16 +646,49 @@ public async Task RestorePreviousSessionsAsync(CancellationToken cancellationTok
                             _sessions[entry.DisplayName] = lazyState;
                             _activeSessionName ??= entry.DisplayName;
                             RestoreUsageStats(entry);
-                            // Eagerly resume sessions that are still actively processing on the
-                            // headless server. Check events.jsonl (authoritative) first, then fall
-                            // back to LastPrompt (saved when IsProcessing=true at debounce time).
-                            // Without this, actively-running sessions appear idle after app restart
-                            // because they're only loaded as lazy placeholders with no SDK connection.
+                            // Check if session is still actively processing on the headless server.
                             var isStillActive = IsSessionStillProcessing(entry.SessionId);
-                            if (isStillActive || !string.IsNullOrWhiteSpace(entry.LastPrompt))
+                            if (isStillActive)
                             {
+                                // Session is actively running on the copilot server (tool calls in
+                                // flight). Do NOT eager-resume — ResumeSessionAsync kills in-flight
+                                // tool execution on the CLI (the resume replaces the event stream and
+                                // abandons running tools). Instead, mark as processing locally and
+                                // start a file-based poller that watches events.jsonl for completion.
+                                // When the CLI finishes, the poller triggers a lazy-resume to pick up
+                                // the results.
+                                Debug($"Deferring resume for actively-processing session: {entry.DisplayName} (will poll events.jsonl)");
+                                var capturedState = lazyState;
+                                var capturedName = entry.DisplayName;
+                                var capturedSessionId = entry.SessionId;
+                                InvokeOnUI(() =>
+                                {
+                                    capturedState.Info.IsProcessing = true;
+                                    capturedState.Info.IsResumed = true;
+                                    capturedState.HasUsedToolsThisTurn = true;
+                                    // INV-9: Set IsMultiAgentSession so the watchdog uses the correct
+                                    // timeout tier (600s for multi-agent workers, not 120s).
+                                    capturedState.IsMultiAgentSession = IsSessionInMultiAgentGroup(capturedName);
+                                    capturedState.Info.ProcessingPhase = 3; // Working
+                                    capturedState.Info.ProcessingStartedAt = DateTime.UtcNow;
+                                    // Reset LastUpdatedAt so the UI doesn't show stale "Xm ago" from
+                                    // a previous app instance. Without this, sessions show "494m ago"
+                                    // because LastUpdatedAt is only updated by SDK events (which don't
+                                    // arrive during the poll-then-resume window).
+                                    capturedState.Info.LastUpdatedAt = DateTime.Now;
+                                    StartProcessingWatchdog(capturedState, capturedName);
+                                    NotifyStateChanged();
+                                });
+                                // Poll events.jsonl — when the CLI finishes (session.idle/shutdown),
+                                // trigger a lazy resume to connect and pick up the response.
+                                _ = PollEventsAndResumeWhenIdleAsync(capturedName, capturedState, capturedSessionId, cancellationToken);
+                            }
+                            else if (!string.IsNullOrWhiteSpace(entry.LastPrompt))
+                            {
+                                // Session had a pending prompt but CLI is no longer active —
+                                // safe to eager-resume to retry the prompt.
                                 eagerResumeCandidates.Add((entry.DisplayName, lazyState));
-                                Debug($"Queued eager resume for interrupted session: {entry.DisplayName} (active={isStillActive}, hasLastPrompt={!string.IsNullOrWhiteSpace(entry.LastPrompt)})");
+                                Debug($"Queued eager resume for interrupted session: {entry.DisplayName} (hasLastPrompt=true)");
                             }
                             Debug($"Loaded session placeholder: {entry.DisplayName} ({lazyHistory.Count} messages)");
                         }
@@ -797,6 +830,126 @@ public async Task RestorePreviousSessionsAsync(CancellationToken cancellationTok
 
     }
 
+    /// <summary>
+    /// Polls events.jsonl for a session that's actively processing on the CLI.
+    /// When the CLI finishes (session.idle or session.shutdown appears, or the file
+    /// goes stale), triggers a lazy-resume to connect and load the response.
+    /// 
+    /// IMPORTANT: We cannot call ResumeSessionAsync while the CLI is running tools —
+    /// the resume command kills in-flight tool execution. This poller bridges the gap
+    /// by waiting for the CLI to finish before connecting.
+    /// </summary>
+    private async Task PollEventsAndResumeWhenIdleAsync(
+        string sessionName, SessionState state, string sessionId, CancellationToken ct)
+    {
+        var eventsFile = Path.Combine(SessionStatePath, sessionId, "events.jsonl");
+        var maxPollTime = TimeSpan.FromMinutes(30);
+        var pollInterval = TimeSpan.FromSeconds(5);
+        var started = DateTime.UtcNow;
+
+        Debug($"[POLL] Starting events.jsonl poll for '{sessionName}' (id={sessionId})");
+
+        try
+        {
+            while (!ct.IsCancellationRequested && (DateTime.UtcNow - started) < maxPollTime)
+            {
+                await Task.Delay(pollInterval, ct);
+
+                // Check if the user already interacted (sent a message) which would have
+                // triggered EnsureSessionConnectedAsync — no need to poll anymore.
+                if (state.Session != null)
+                {
+                    Debug($"[POLL] '{sessionName}' already connected (user interaction) — stopping poll");
+                    return;
+                }
+
+                // Check if the watchdog already cleared IsProcessing — session is done.
+                if (!state.Info.IsProcessing)
+                {
+                    Debug($"[POLL] '{sessionName}' no longer processing (watchdog cleared) — stopping poll");
+                    return;
+                }
+
+                // Read last event type from events.jsonl — only terminal events are reliable.
+                // File-size stability is NOT reliable because the CLI has many states where
+                // it's working but not writing (model thinking, tool executing, etc).
+                // The watchdog handles the "zero-idle" case via timeout.
+                var lastEventType = GetLastEventType(eventsFile);
+                if (lastEventType == null) continue;
+
+                var isTerminal = lastEventType is "session.idle" or "session.error" or "session.shutdown";
+
+                if (isTerminal)
+                {
+                    Debug($"[POLL] '{sessionName}' CLI finished (lastEvent={lastEventType}) — resuming session");
+
+                    // INV-3/INV-12: Capture generation BEFORE async operations to prevent
+                    // stale poller from corrupting a new turn started by user interaction.
+                    var pollerGen = Interlocked.Read(ref state.ProcessingGeneration);
+
+                    // Load the full history from events.jsonl (includes response content).
+                    // Merge happens inside InvokeOnUI because History is an ObservableCollection
+                    // and all other mutations run on the UI thread.
+                    List<ChatMessage>? diskHistory = null;
+                    try
+                    {
+                        (diskHistory, _) = await LoadBestHistoryAsync(sessionId);
+                    }
+                    catch (Exception ex)
+                    {
+                        Debug($"[POLL] '{sessionName}' failed to load disk history: {ex.Message}");
+                    }
+
+                    // Now safe to resume — the CLI is idle, no tools to interrupt.
+                    try
+                    {
+                        await EnsureSessionConnectedAsync(sessionName, state, ct);
+                        Debug($"[POLL] '{sessionName}' lazy-resume complete after poll");
+                    }
+                    catch (Exception ex)
+                    {
+                        Debug($"[POLL] '{sessionName}' lazy-resume failed: {ex.Message}");
+                    }
+
+                    // Complete the response — the session is done.
+                    InvokeOnUI(() =>
+                    {
+                        // INV-3: Generation guard — if user sent a new message during
+                        // the poll→resume window, this completion belongs to the old turn.
+                        if (Interlocked.Read(ref state.ProcessingGeneration) != pollerGen) return;
+                        if (!state.Info.IsProcessing) return; // watchdog already cleared
+
+                        // Merge disk history on UI thread (History is ObservableCollection)
+                        if (diskHistory != null && diskHistory.Count > state.Info.History.Count)
+                        {
+                            var existingCount = state.Info.History.Count;
+                            foreach (var msg in diskHistory.Skip(existingCount))
+                                state.Info.History.Add(msg);
+                            Debug($"[POLL] '{sessionName}' loaded {diskHistory.Count - existingCount} new messages from disk (total={state.Info.History.Count})");
+                        }
+                        FlushCurrentResponse(state);
+                        CompleteResponse(state, pollerGen);
+                        NotifyStateChanged();
+                    });
+                    return;
+                }
+            }
+
+            if ((DateTime.UtcNow - started) >= maxPollTime)
+            {
+                Debug($"[POLL] '{sessionName}' poll timed out after {maxPollTime.TotalMinutes:F0} minutes");
+            }
+        }
+        catch (OperationCanceledException) when (ct.IsCancellationRequested)
+        {
+            Debug($"[POLL] '{sessionName}' poll cancelled");
+        }
+        catch (Exception ex)
+        {
+            Debug($"[POLL] '{sessionName}' poll error: {ex.Message}");
+        }
+    }
+
     public void SaveUiState(string currentPage, string? activeSession = null, int? fontSize = null, string? selectedModel = null, bool? expandedGrid = null, string? expandedSession = "<<unspecified>>", Dictionary<string, string>? inputModes = null, int? gridColumns = null, int? cardMinHeight = null)
     {
         try
diff --git a/PolyPilot/Services/CopilotService.Utilities.cs b/PolyPilot/Services/CopilotService.Utilities.cs
index 61d0eabcd2..d3a77d73c4 100644
--- a/PolyPilot/Services/CopilotService.Utilities.cs
+++ b/PolyPilot/Services/CopilotService.Utilities.cs
@@ -134,14 +134,15 @@ internal bool IsSessionStillProcessing(string sessionId, string basePath)
 
             using var doc = JsonDocument.Parse(lastLine);
             var type = doc.RootElement.GetProperty("type").GetString();
-            
-            var activeEvents = new[] { 
-                "assistant.turn_start", "tool.execution_start", 
-                "tool.execution_progress", "assistant.message_delta",
-                "assistant.reasoning", "assistant.reasoning_delta",
-                "assistant.intent"
-            };
-            return activeEvents.Contains(type);
+            if (type == null) return false; // Corrupt/partial event — treat as terminal
+
+            // Use a blacklist of terminal events rather than a whitelist of active ones.
+            // Any event that is NOT terminal means the session is still processing.
+            // The old whitelist missed intermediate states like assistant.turn_end (between
+            // tool rounds), assistant.message, and tool.execution_complete, causing
+            // actively-processing sessions to be incorrectly detected as idle on restore.
+            var terminalEvents = new[] { "session.idle", "session.error", "session.shutdown" };
+            return !terminalEvents.Contains(type);
         }
         catch { return false; }
     }
@@ -794,15 +795,29 @@ private async Task FetchAvailableModelsAsync()
             var modelList = await _client.ListModelsAsync();
             if (modelList != null && modelList.Count > 0)
             {
-                var models = modelList
-                    .Where(m => !string.IsNullOrEmpty(m.Id))
-                    .Select(m => m.Id!)
-                    .OrderBy(m => m)
-                    .ToList();
+                // Use Id (slug) as the canonical model identifier, not Name (display name).
+                // Name is a display string like "Claude Opus 4.6 (1M Context)(Internal Only)"
+                // which NormalizeToSlug can't reliably round-trip. Id is the SDK slug.
+                var displayNames = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                var models = new List<string>();
+                foreach (var m in modelList)
+                {
+                    var id = m.Id;
+                    var name = m.Name;
+                    // Prefer Id (slug); fall back to Name if Id is missing
+                    var key = !string.IsNullOrEmpty(id) ? id : name;
+                    if (string.IsNullOrEmpty(key)) continue;
+                    if (!models.Contains(key))
+                        models.Add(key);
+                    if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(id))
+                        displayNames[id] = name;
+                }
+                models.Sort(StringComparer.OrdinalIgnoreCase);
                 if (models.Count > 0)
                 {
-                    _localAvailableModels = models;
-                    Debug($"Loaded {models.Count} models from SDK");
+                    AvailableModels = models;
+                    ModelDisplayNames = displayNames;
+                    Debug($"Loaded {models.Count} models from SDK (ids)");
                     OnStateChanged?.Invoke();
                 }
             }
diff --git a/PolyPilot/Services/CopilotService.cs b/PolyPilot/Services/CopilotService.cs
index 8015a065ed..b05e23372b 100644
--- a/PolyPilot/Services/CopilotService.cs
+++ b/PolyPilot/Services/CopilotService.cs
@@ -259,11 +259,12 @@ private static string FindProjectDir()
     public string? ActiveSessionName => _activeSessionName;
     public IChatDatabase ChatDb => _chatDb;
     public ConnectionMode CurrentMode { get; private set; } = ConnectionMode.Embedded;
-    public List<string> AvailableModels =>
-        IsRemoteMode && _bridgeClient.AvailableModels.Count > 0
-            ? _bridgeClient.AvailableModels
-            : _localAvailableModels;
-    private List<string> _localAvailableModels = new();
+    public List<string> AvailableModels { get; private set; } = new();
+    /// <summary>
+    /// Maps model slug (Id) → display name from the SDK's ListModelsAsync.
+    /// Used for richer display when the algorithmic prettification isn't sufficient.
+    /// </summary>
+    public Dictionary<string, string> ModelDisplayNames { get; private set; } = new();
 
     private readonly RepoManager _repoManager;
     private readonly CodespaceService _codespaceService;
diff --git a/PolyPilot/Services/IWsBridgeClient.cs b/PolyPilot/Services/IWsBridgeClient.cs
index cc7c555e1a..6fffda9bb8 100644
--- a/PolyPilot/Services/IWsBridgeClient.cs
+++ b/PolyPilot/Services/IWsBridgeClient.cs
@@ -18,6 +18,7 @@ public interface IWsBridgeClient
     string? GitHubLogin { get; }
     string? ServerMachineName { get; }
     List<string> AvailableModels { get; }
+    Dictionary<string, string> ModelDisplayNames { get; }
 
     // Events
     event Action? OnStateChanged;
diff --git a/PolyPilot/Services/WsBridgeClient.cs b/PolyPilot/Services/WsBridgeClient.cs
index fec92c0d7f..54b81d9d60 100644
--- a/PolyPilot/Services/WsBridgeClient.cs
+++ b/PolyPilot/Services/WsBridgeClient.cs
@@ -42,6 +42,7 @@ public class WsBridgeClient : IWsBridgeClient, IDisposable
     public string? GitHubLogin { get; private set; }
     public string? ServerMachineName { get; private set; }
     public List<string> AvailableModels { get; private set; } = new();
+    public Dictionary<string, string> ModelDisplayNames { get; private set; } = new();
 
     // --- Events matching CopilotService signatures ---
     public event Action? OnStateChanged;
@@ -677,8 +678,10 @@ private void HandleServerMessage(string json)
                     GitHubAvatarUrl = sessions.GitHubAvatarUrl;
                     GitHubLogin = sessions.GitHubLogin;
                     ServerMachineName = sessions.ServerMachineName;
-                    if (sessions.AvailableModels is { Count: > 0 } models)
-                        AvailableModels = models;
+                    if (sessions.AvailableModels is { Count: > 0 })
+                        AvailableModels = sessions.AvailableModels;
+                    if (sessions.ModelDisplayNames is { Count: > 0 })
+                        ModelDisplayNames = sessions.ModelDisplayNames;
                     HasReceivedSessionsList = true;
                     Console.WriteLine($"[WsBridgeClient] Got {Sessions.Count} sessions, active={ActiveSessionName}");
                     OnStateChanged?.Invoke();
diff --git a/PolyPilot/Services/WsBridgeServer.cs b/PolyPilot/Services/WsBridgeServer.cs
index 808b6f77fa..e5b6566602 100644
--- a/PolyPilot/Services/WsBridgeServer.cs
+++ b/PolyPilot/Services/WsBridgeServer.cs
@@ -1193,6 +1193,7 @@ private SessionsListPayload BuildSessionsListPayload()
             GitHubLogin = _copilot.GitHubLogin,
             ServerMachineName = Environment.MachineName,
             AvailableModels = _copilot.AvailableModels.Count > 0 ? _copilot.AvailableModels : null,
+            ModelDisplayNames = _copilot.ModelDisplayNames.Count > 0 ? _copilot.ModelDisplayNames : null,
         };
     }
 
diff --git a/PolyPilot/wwwroot/index.html b/PolyPilot/wwwroot/index.html
index 11c7464c48..a51087c0da 100644
--- a/PolyPilot/wwwroot/index.html
+++ b/PolyPilot/wwwroot/index.html
@@ -559,7 +559,7 @@
 
                 var q = context.query.toLowerCase();
                 var filtered = workers.filter(function(w) {
-                    return w.toLowerCase().indexOf(q) === 0;
+                    return w.toLowerCase().indexOf(q) >= 0;
                 }).slice(0, 12);
 
                 if (filtered.length === 0) {