diff --git a/app/api/agent/[id]/events/route.ts b/app/api/agent/[id]/events/route.ts
index dfb0620a8e..8c33d62458 100644
--- a/app/api/agent/[id]/events/route.ts
+++ b/app/api/agent/[id]/events/route.ts
@@ -51,7 +51,7 @@ export async function GET(
       };
 
       // Send initial connected event
-      encode({ type: "connected", sessionId: id });
+      encode({ type: "connected", sessionId: session.sessionId, runtimeId: session.runtimeId });
 
       const unsubscribe = session.onEvent((event) => {
         const clientEvent = toClientEvent(event);
diff --git a/app/api/agent/[id]/route.ts b/app/api/agent/[id]/route.ts
index ea7debda2e..8d7e1488be 100644
--- a/app/api/agent/[id]/route.ts
+++ b/app/api/agent/[id]/route.ts
@@ -1,6 +1,6 @@
 import { NextResponse } from "next/server";
 import { resolveSessionPath } from "@/lib/session-reader";
-import { startRpcSession, getRpcSession } from "@/lib/rpc-manager";
+import { startRpcSession, getRpcSession, getFinalRpcSessionId } from "@/lib/rpc-manager";
 import { hasJsonContentType, isApiRequestAllowed } from "@/lib/request-security";
 
 // POST /api/agent/[id] - Send a command to an existing session
@@ -28,7 +28,15 @@ export async function POST(
     if (existing?.isAlive()) {
       const result = await existing.send(body);
       promptAccepted = body.type === "prompt";
-      return NextResponse.json({ success: true, data: result });
+      existing.syncSessionIdentity();
+      return NextResponse.json({ success: true, data: result, sessionId: existing.sessionId, runtimeId: existing.runtimeId });
+    }
+
+    if (id.startsWith("runtime:")) {
+      return NextResponse.json({
+        error: "Runtime session expired", code: "runtime_expired", accepted: false,
+        sessionId: getFinalRpcSessionId(id),
+      }, { status: 404 });
     }
 
     const filePath = await resolveSessionPath(id);
@@ -45,7 +53,8 @@ export async function POST(
     const result = await session.send(body);
     promptAccepted = body.type === "prompt";
 
-    return NextResponse.json({ success: true, data: result });
+    session.syncSessionIdentity();
+    return NextResponse.json({ success: true, data: result, sessionId: session.sessionId, runtimeId: session.runtimeId });
   } catch (error) {
     return NextResponse.json({
       error: error instanceof Error ? error.message : String(error),
@@ -64,9 +73,13 @@ export async function GET(
   const { id } = await params;
 
   try {
-    const session = getRpcSession(id);
+    let session = getRpcSession(id);
     if (!session || !session.isAlive()) {
-      return NextResponse.json({ running: false });
+      const sessionId = getFinalRpcSessionId(id);
+      session = sessionId ? getRpcSession(sessionId) : undefined;
+      if (!session?.isAlive()) {
+        return NextResponse.json({ running: false, ...(sessionId ? { state: { sessionId } } : {}) });
+      }
     }
 
     const state = await session.send({ type: "get_state" });
diff --git a/app/api/agent/new/route.ts b/app/api/agent/new/route.ts
index 60adfb2ddb..98cd8c7cc8 100644
--- a/app/api/agent/new/route.ts
+++ b/app/api/agent/new/route.ts
@@ -65,7 +65,7 @@ export async function POST(req: Request) {
     // that share a key onto one session. Date.now() (ms resolution) collides for
     // requests in the same millisecond, merging two new sessions into one.
     const tempKey = `__new__${randomUUID()}`;
-    const { session, realSessionId } = await startRpcSession(tempKey, "", cwd, {
+    const { session } = await startRpcSession(tempKey, "", cwd, {
       ...(toolNames ? { toolNames } : {}),
       ...(provider && modelId ? { initialModel: { provider, modelId } } : {}),
       ...(explicitThinkingLevel ? { thinkingLevel: explicitThinkingLevel } : {}),
@@ -86,7 +86,8 @@ export async function POST(req: Request) {
     if (promptCommand.type === "ensure_session") {
       return NextResponse.json({
         success: true,
-        sessionId: realSessionId,
+        sessionId: session.sessionId,
+        runtimeId: session.runtimeId,
         data: null,
         model: state.model
           ? { provider: state.model.provider, modelId: state.model.id }
@@ -101,7 +102,8 @@ export async function POST(req: Request) {
 
     return NextResponse.json({
       success: true,
-      sessionId: realSessionId,
+      sessionId: session.sessionId,
+      runtimeId: session.runtimeId,
       data: result,
       model: state.model
         ? { provider: state.model.provider, modelId: state.model.id }
diff --git a/app/api/agent/running/route.ts b/app/api/agent/running/route.ts
index ecde5b7b64..4cab9dd7ad 100644
--- a/app/api/agent/running/route.ts
+++ b/app/api/agent/running/route.ts
@@ -1,12 +1,12 @@
 import { NextResponse } from "next/server";
-import { getRunningRpcSessionIds } from "@/lib/rpc-manager";
+import { getRpcSessionActivitySnapshot } from "@/lib/rpc-manager";
 
 export const dynamic = "force-dynamic";
 
 // GET /api/agent/running - Lightweight snapshot for visible-tab polling.
 export async function GET() {
   return NextResponse.json(
-    { runningSessionIds: getRunningRpcSessionIds() },
+    getRpcSessionActivitySnapshot(),
     { headers: { "Cache-Control": "no-store" } },
   );
 }
diff --git a/app/api/sessions/[id]/auto-name/route.ts b/app/api/sessions/[id]/auto-name/route.ts
index 70fb23dbbb..9ad85182b1 100644
--- a/app/api/sessions/[id]/auto-name/route.ts
+++ b/app/api/sessions/[id]/auto-name/route.ts
@@ -1,6 +1,6 @@
 import { NextResponse } from "next/server";
 import { generateSessionTitle } from "@/lib/session-title";
-import { getRpcSession, startRpcSession } from "@/lib/rpc-manager";
+import { getRpcSession, startRpcSession, getFinalRpcSessionId } from "@/lib/rpc-manager";
 import { invalidateSessionListCache, resolveSessionPath } from "@/lib/session-reader";
 
 export async function POST(
@@ -10,16 +10,16 @@ export async function POST(
   const { id } = await params;
 
   try {
-    const filePath = await resolveSessionPath(id);
-    if (!filePath) {
-      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    let session = getRpcSession(id);
+    if (!session?.isAlive()) {
+      const canonicalId = id.startsWith("runtime:") ? getFinalRpcSessionId(id) : id;
+      const filePath = canonicalId ? await resolveSessionPath(canonicalId) : undefined;
+      if (!canonicalId || !filePath) {
+        return NextResponse.json({ error: "Session not found" }, { status: 404 });
+      }
+      ({ session } = await startRpcSession(canonicalId, filePath, undefined));
     }
 
-    const existing = getRpcSession(id);
-    const { session } = existing?.isAlive()
-      ? { session: existing }
-      : await startRpcSession(id, filePath, undefined);
-
     // globalThis keeps wrappers alive across dev hot reloads; older instances
     // may predate waitUntilReady(), but those have already completed startup.
     await session.waitUntilReady?.();
@@ -40,7 +40,7 @@ export async function POST(
 
     await session.inner.sessionManager.setSessionName(result.title, "auto");
     invalidateSessionListCache();
-    return NextResponse.json({ title: result.title });
+    return NextResponse.json({ title: result.title, sessionId: session.sessionId, runtimeId: session.runtimeId });
   } catch (error) {
     return NextResponse.json(
       { error: error instanceof Error ? error.message : String(error) },
diff --git a/app/api/sessions/[id]/context/route.ts b/app/api/sessions/[id]/context/route.ts
index fe2692e3a7..b2c452d2c6 100644
--- a/app/api/sessions/[id]/context/route.ts
+++ b/app/api/sessions/[id]/context/route.ts
@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 import { SessionManager } from "@oh-my-pi/pi-coding-agent";
 import { resolveSessionPath, buildSessionContext, getHistoricalContextUsage } from "@/lib/session-reader";
-import { getRpcSession } from "@/lib/rpc-manager";
+import { getRpcSession, getFinalRpcSessionId } from "@/lib/rpc-manager";
 
 export async function GET(
   req: Request,
@@ -14,9 +14,11 @@ export async function GET(
   const deferToolResultImages = url.searchParams.has("deferMedia");
 
   try {
-    const rpc = getRpcSession(id);
+    const directRpc = getRpcSession(id);
+    const canonicalId = directRpc?.sessionId ?? getFinalRpcSessionId(id) ?? id;
+    const rpc = directRpc ?? getRpcSession(canonicalId);
     const liveRpc = rpc?.isAlive() ? rpc : undefined;
-    const filePath = liveRpc ? null : await resolveSessionPath(id);
+    const filePath = liveRpc ? null : await resolveSessionPath(canonicalId);
     if (!liveRpc && !filePath) {
       return NextResponse.json({ error: "Session not found" }, { status: 404 });
     }
@@ -30,6 +32,8 @@ export async function GET(
     const contextUsage = await getHistoricalContextUsage(entries, leafId);
 
     return NextResponse.json({
+      sessionId: liveRpc?.sessionId ?? sm.getSessionId(),
+      runtimeId: liveRpc?.runtimeId ?? null,
       context,
       ...(contextUsage ? { contextUsage } : {}),
     });
diff --git a/app/api/sessions/[id]/export/route.ts b/app/api/sessions/[id]/export/route.ts
index 4680bc6dd1..901ab460fc 100644
--- a/app/api/sessions/[id]/export/route.ts
+++ b/app/api/sessions/[id]/export/route.ts
@@ -7,6 +7,7 @@ import { promisify } from "util";
 import { fileURLToPath, pathToFileURL } from "url";
 import { NextResponse } from "next/server";
 import { isApiRequestAllowed } from "@/lib/request-security";
+import { getRpcSession, getFinalRpcSessionId } from "@/lib/rpc-manager";
 import { resolveSessionPath } from "@/lib/session-reader";
 
 const execFileAsync = promisify(execFile);
@@ -114,7 +115,9 @@ export async function GET(
   const inline = new URL(req.url).searchParams.get("inline") === "1";
 
   try {
-    const filePath = await resolveSessionPath(id);
+    const canonicalId = getRpcSession(id)?.sessionId ?? getFinalRpcSessionId(id)
+      ?? (id.startsWith("runtime:") ? undefined : id);
+    const filePath = canonicalId ? await resolveSessionPath(canonicalId) : null;
     if (!filePath) {
       return NextResponse.json({ error: "Session not found" }, { status: 404 });
     }
diff --git a/app/api/sessions/[id]/route.ts b/app/api/sessions/[id]/route.ts
index f8e3e4dfb7..9476b1e03b 100644
--- a/app/api/sessions/[id]/route.ts
+++ b/app/api/sessions/[id]/route.ts
@@ -44,6 +44,10 @@ export async function GET(
     const deferThinking = searchParams.has("deferThinking");
     const deferToolResultImages = searchParams.has("deferMedia");
     const context = buildSessionContext(entries, leafId, { deferThinking, deferToolResultImages });
+    // A runtime fallback can differ from the last persisted model selector.
+    if (liveRpc?.inner.model) {
+      context.model = { provider: liveRpc.inner.model.provider, modelId: liveRpc.inner.model.id };
+    }
     const contextUsage = await getHistoricalContextUsage(entries, leafId);
     const totalActiveMs = computeSessionTotalActiveMs(entries);
     const header = sm.getHeader();
@@ -72,7 +76,8 @@ export async function GET(
     } : null;
 
     return NextResponse.json({
-      sessionId: id,
+      sessionId: liveRpc?.sessionId ?? sm.getSessionId(),
+      runtimeId: liveRpc?.runtimeId,
       filePath,
       info,
       leafId,
diff --git a/app/api/sessions/export-route.test.mjs b/app/api/sessions/export-route.test.mjs
new file mode 100644
index 0000000000..3e858ce77b
--- /dev/null
+++ b/app/api/sessions/export-route.test.mjs
@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  alias: { "@": process.cwd() },
+  interopDefault: true,
+  moduleCache: false,
+});
+const { GET: getExport } = await jiti.import("./[id]/export/route.ts");
+
+function exportFixture(t) {
+  const stateKeys = [
+    "__ompSessions", "__ompFinalSessionIds", "__ompSessionPathCache",
+    "__ompPathToSessionIdCache", "__ompSessionListCache",
+  ];
+  const previousState = stateKeys.map((key) => [key, globalThis[key]]);
+  const dir = mkdtempSync(join(tmpdir(), "omp-web-export-test-"));
+  const a = "export-history-a";
+  const b = "export-current-b";
+  const runtimeId = "runtime:export-r";
+  const timestamp = "2026-08-12T01:02:03.000Z";
+  const paths = new Map();
+  for (const id of [a, b]) {
+    const path = join(dir, `${id}.jsonl`);
+    paths.set(id, path);
+    writeFileSync(path, [
+      { type: "session", version: 3, id, timestamp, cwd: dir },
+      {
+        type: "message", id: "u1", parentId: null, timestamp,
+        message: { role: "user", content: `transcript ${id}` },
+      },
+    ].map((entry) => JSON.stringify(entry)).join("\n") + "\n");
+  }
+  globalThis.__ompSessions = new Map([[a, {
+    sessionId: b,
+    runtimeId,
+    sessionFile: paths.get(b),
+    isAlive: () => true,
+    syncSessionIdentity: () => {},
+  }]]);
+  globalThis.__ompFinalSessionIds = new Map();
+  globalThis.__ompSessionPathCache = new Map(paths);
+  globalThis.__ompPathToSessionIdCache = new Map([...paths].map(([id, path]) => [path, id]));
+  // Missing files must not scan the user's session directory.
+  globalThis.__ompSessionListCache = { data: [], ts: Date.now() };
+  t.after(() => {
+    for (const [key, value] of previousState) globalThis[key] = value;
+    rmSync(dir, { recursive: true, force: true });
+  });
+  return { a, b, runtimeId, paths };
+}
+
+function requestExport(id, headers = { host: "localhost" }) {
+  return getExport(
+    new Request(`http://localhost/api/sessions/${encodeURIComponent(id)}/export?inline=1`, { headers }),
+    { params: Promise.resolve({ id }) },
+  );
+}
+
+async function assertTranscript(response, id) {
+  assert.equal(response.status, 200, await response.clone().text());
+  assert.equal(response.headers.get("Content-Type"), "text/html; charset=utf-8");
+  assert.match(response.headers.get("Content-Disposition"), /^inline;/);
+  const html = await response.text();
+  const encoded = html.match(/<script id="session-data" type="application\/json">([^<]+)<\/script>/)?.[1];
+  assert.ok(encoded, "export contains the SDK's embedded transcript");
+  const data = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+  assert.equal(data.header.id, id);
+  assert.deepEqual(data.entries.map((entry) => entry.message?.content), [`transcript ${id}`]);
+}
+
+test("export follows a live runtime to its current transcript after a missed identity update", async (t) => {
+  const { runtimeId, b } = exportFixture(t);
+  await assertTranscript(await requestExport(runtimeId), b);
+});
+
+test("export follows a destroyed runtime's final identity", async (t) => {
+  const { runtimeId, b } = exportFixture(t);
+  globalThis.__ompSessions.clear();
+  globalThis.__ompFinalSessionIds.set(runtimeId, b);
+  await assertTranscript(await requestExport(runtimeId), b);
+});
+
+test("exporting a historical ID still returns its original transcript", async (t) => {
+  const { a } = exportFixture(t);
+  await assertTranscript(await requestExport(a), a);
+});
+
+test("unknown runtime handles cannot be treated as historical file IDs", async (t) => {
+  const { a, paths } = exportFixture(t);
+  globalThis.__ompSessionPathCache.set("runtime:unknown", paths.get(a));
+  const response = await requestExport("runtime:unknown");
+  assert.equal(response.status, 404);
+  assert.deepEqual(await response.json(), { error: "Session not found" });
+});
+
+for (const alive of [true, false]) {
+  test(`export never falls back to the old file when the ${alive ? "live" : "destroyed"} runtime's current file is missing`, async (t) => {
+    const { runtimeId, a, b, paths } = exportFixture(t);
+    if (!alive) {
+      globalThis.__ompSessions.clear();
+      globalThis.__ompFinalSessionIds.set(runtimeId, b);
+    }
+    globalThis.__ompSessionPathCache.set(runtimeId, paths.get(a));
+    rmSync(paths.get(b));
+    const response = await requestExport(runtimeId);
+    assert.equal(response.status, 404);
+    assert.deepEqual(await response.json(), { error: "Session not found" });
+  });
+}
+
+test("export rejects untrusted requests before accessing the runtime registry", async (t) => {
+  const { runtimeId } = exportFixture(t);
+  globalThis.__ompSessions.values().next().value.syncSessionIdentity = () => {
+    assert.fail("untrusted request must not access runtimes");
+  };
+  const response = await requestExport(runtimeId, { host: "untrusted.invalid" });
+  assert.equal(response.status, 403);
+  assert.deepEqual(await response.json(), { error: "Untrusted API request" });
+});
diff --git a/app/api/sessions/route.ts b/app/api/sessions/route.ts
index ebb0c18863..4de6baff46 100644
--- a/app/api/sessions/route.ts
+++ b/app/api/sessions/route.ts
@@ -4,7 +4,7 @@ import {
   listAllSessions,
   mergeSessionLists,
 } from "@/lib/session-reader";
-import { getRpcSessionInfos, getRunningRpcSessionIds } from "@/lib/rpc-manager";
+import { getRpcSessionInfos, getRpcSessionActivitySnapshot } from "@/lib/rpc-manager";
 import { readArchivedIds } from "@/lib/session-archive";
 
 export const dynamic = "force-dynamic";
@@ -21,7 +21,7 @@ export async function GET(req: Request) {
     const sessions = mergeSessionLists(persistedSessions, runtimeSessions)
       .filter((s) => (showArchived ? archived.has(s.id) : !archived.has(s.id)));
     return NextResponse.json(
-      { sessions, runningSessionIds: getRunningRpcSessionIds() },
+      { sessions, ...getRpcSessionActivitySnapshot() },
       { headers: { "Cache-Control": "no-store" } },
     );
   } catch (error) {
diff --git a/app/api/sessions/runtime-route.test.mjs b/app/api/sessions/runtime-route.test.mjs
index 4699b3be5a..cc236909d7 100644
--- a/app/api/sessions/runtime-route.test.mjs
+++ b/app/api/sessions/runtime-route.test.mjs
@@ -13,7 +13,9 @@ const jiti = createJiti(import.meta.url, {
   moduleCache: false,
 });
 const { GET: getSessionDetail } = await jiti.import("./[id]/route.ts");
+const { GET: getSessionContext } = await jiti.import("./[id]/context/route.ts");
 const { GET: getSessionState } = await jiti.import("./[id]/state/route.ts");
+const { GET: getAgentState } = await jiti.import("../agent/[id]/route.ts");
 
 test("session listing merges live registry snapshots and honors force refresh", () => {
   assert.match(listRoute, /searchParams\.get\("force"\) === "1"/);
@@ -26,7 +28,7 @@ test("session listing merges live registry snapshots and honors force refresh",
 test("session reads use the live SessionManager before requiring a JSONL path", () => {
   for (const source of [detailRoute, contextRoute]) {
     const liveLookup = source.indexOf("getRpcSession(id)");
-    const pathLookup = source.indexOf("resolveSessionPath(id)");
+    const pathLookup = source.indexOf("resolveSessionPath(");
     assert.ok(liveLookup >= 0);
     assert.ok(pathLookup > liveLookup);
     assert.match(source, /liveRpc\?\.inner\.sessionManager \?\? (?:await )?SessionManager\.open/);
@@ -43,7 +45,10 @@ test("live agent state is available before the session file is persisted", () =>
 
 test("live detail and state routes work without a persisted JSONL file", async (t) => {
   const previousRegistry = globalThis.__ompSessions;
+  const previousFinalIds = globalThis.__ompFinalSessionIds;
   const id = "live-route-test";
+  const runtimeId = "live-route-after-fallback";
+  const handle = "runtime:live-route";
   const timestamp = "2026-08-12T01:02:03.000Z";
   const entry = {
     type: "message",
@@ -65,15 +70,18 @@ test("live detail and state routes work without a persisted JSONL file", async (
     isRunning: () => true,
     inner: { sessionManager },
     sessionFile: sessionManager.getSessionFile(),
-    sessionId: id,
+    sessionId: runtimeId,
+    runtimeId: handle,
+    syncSessionIdentity: () => {},
     cwd: "/tmp",
     send: async () => ({ isStreaming: true }),
   }]]);
   t.after(() => {
     globalThis.__ompSessions = previousRegistry;
+    globalThis.__ompFinalSessionIds = previousFinalIds;
   });
 
-  const routeContext = { params: Promise.resolve({ id }) };
+  const routeContext = { params: Promise.resolve({ id: handle }) };
   const detailResponse = await getSessionDetail(
     new Request(`http://localhost/api/sessions/${id}`, { headers: { host: "localhost" } }),
     routeContext,
@@ -85,6 +93,8 @@ test("live detail and state routes work without a persisted JSONL file", async (
   const detail = await detailResponse.json();
 
   assert.equal(detailResponse.status, 200);
+  assert.equal(detail.sessionId, runtimeId);
+  assert.equal(detail.runtimeId, handle);
   assert.equal(detail.info.transient, true);
   assert.deepEqual(detail.context.messages.map((message) => message.content), ["hello live"]);
   assert.equal(stateResponse.status, 200);
@@ -92,4 +102,38 @@ test("live detail and state routes work without a persisted JSONL file", async (
     running: true,
     state: { isStreaming: true },
   });
+
+  globalThis.__ompFinalSessionIds = new Map([["runtime:expired-context", runtimeId]]);
+  const contextResponse = await getSessionContext(new Request("http://localhost/api/sessions/runtime:expired-context/context"), {
+    params: Promise.resolve({ id: "runtime:expired-context" }),
+  });
+  const context = await contextResponse.json();
+  assert.equal(contextResponse.status, 200);
+  assert.equal(context.sessionId, runtimeId);
+  assert.equal(context.runtimeId, handle);
+  assert.deepEqual(context.context.messages.map((message) => message.content), ["hello live"]);
+});
+
+
+test("an expired runtime reports a reopened canonical session's live state", async (t) => {
+  const previousRegistry = globalThis.__ompSessions;
+  const previousFinalIds = globalThis.__ompFinalSessionIds;
+  const state = { sessionId: "reopened-b", runtimeId: "runtime:new", isStreaming: true };
+  globalThis.__ompFinalSessionIds = new Map([["runtime:old", state.sessionId]]);
+  globalThis.__ompSessions = new Map([[state.sessionId, {
+    sessionId: state.sessionId,
+    runtimeId: state.runtimeId,
+    isAlive: () => true,
+    syncSessionIdentity: () => {},
+    send: async (command) => { assert.equal(command.type, "get_state"); return state; },
+  }]]);
+  t.after(() => {
+    globalThis.__ompSessions = previousRegistry;
+    globalThis.__ompFinalSessionIds = previousFinalIds;
+  });
+  const response = await getAgentState(new Request("http://localhost/api/agent/runtime:old"), {
+    params: Promise.resolve({ id: "runtime:old" }),
+  });
+  assert.equal(response.status, 200);
+  assert.deepEqual(await response.json(), { running: true, state });
 });
diff --git a/components/AppShell.auto-name.test.mjs b/components/AppShell.auto-name.test.mjs
index 6bbdcb1a70..55ab7ae85b 100644
--- a/components/AppShell.auto-name.test.mjs
+++ b/components/AppShell.auto-name.test.mjs
@@ -20,5 +20,5 @@ test("尚未落盘的会话不会触发依赖 JSONL 的自动命名", () => {
 
 test("会话落盘后会用服务端记录清除临时状态", () => {
   assert.match(source, /\{ \.\.\.prev, \.\.\.full, transient: full\.transient \?\? false \}/);
-  assert.match(source, /if \(selectedSession\) hydrateSelectedSession\(selectedSession\.id\)/);
+  assert.match(source, /if \(targetSession\) hydrateSelectedSession\(targetSession\.id\)/);
 });
diff --git a/components/AppShell.history.test.mjs b/components/AppShell.history.test.mjs
new file mode 100644
index 0000000000..c02a36d7a9
--- /dev/null
+++ b/components/AppShell.history.test.mjs
@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+
+const source = await readFile(new URL("./AppShell.tsx", import.meta.url), "utf8");
+const start = source.indexOf("  const handleViewFullHistory = useCallback");
+const end = source.indexOf("\n  }, [selectedSession]);", start);
+assert.ok(start >= 0 && end > start, "History callback not found");
+// Execute the production callback with a window double, rather than duplicating
+// its URL selection logic in the test.
+const createHistoryCallback = new Function(
+  "selectedSession", "window", "useCallback",
+  `${source.slice(start, end + "\n  }, [selectedSession]);".length)}\nreturn handleViewFullHistory;`,
+);
+
+for (const { name, selectedSession, expectedId } of [
+  {
+    name: "History follows the selected runtime after a missed identity update",
+    selectedSession: { id: "history-a", runtimeId: "runtime:history-r" },
+    expectedId: "runtime:history-r",
+  },
+  {
+    name: "History preserves historical session IDs without a runtime handle",
+    selectedSession: { id: "history-a" },
+    expectedId: "history-a",
+  },
+  {
+    name: "History does nothing without a selected session",
+    selectedSession: null,
+  },
+]) {
+  test(name, () => {
+    const opened = [];
+    const callback = createHistoryCallback(
+      selectedSession,
+      { open: (...args) => opened.push(args) },
+      (callback) => callback,
+    );
+    callback();
+    assert.deepEqual(opened, expectedId ? [[
+      `/api/sessions/${encodeURIComponent(expectedId)}/export?inline=1`,
+      "_blank",
+      "noopener,noreferrer",
+    ]] : []);
+  });
+}
diff --git a/components/AppShell.tsx b/components/AppShell.tsx
index 731c40415d..28791ab90b 100644
--- a/components/AppShell.tsx
+++ b/components/AppShell.tsx
@@ -18,6 +18,7 @@ import { useIsMobile } from "@/hooks/useIsMobile";
 import { useViewportHeight } from "@/hooks/useViewportHeight";
 import { useResizablePanel } from "@/hooks/useResizablePanel";
 import { useAudio } from "@/hooks/useAudio";
+import { canApplySessionIdentity, type SessionIdentity } from "@/lib/agent-client";
 import { copyText } from "@/lib/clipboard";
 import { getFileName } from "@/lib/file-paths";
 import { buildAtMentionText, buildFileAtMentionsText, buildFileLineMentionText } from "@/lib/file-fuzzy";
@@ -27,7 +28,7 @@ import {
   showBrowserNotification,
 } from "@/lib/browser-notifications";
 import { getInitialNavigation } from "@/lib/initial-navigation";
-import { clearLastOpen, getLastOpenSession, setLastOpenSession } from "@/lib/workspace-memory";
+import { clearLastOpen, getLastOpenSession, setLastOpenSession, getSessionContinuation, clearSessionContinuation, rememberSessionContinuation, restoreSessionContinuation } from "@/lib/workspace-memory";
 import {
   getDefaultRightPanelWidth,
   getRightPanelMaxWidth,
@@ -190,6 +191,8 @@ export function AppShell() {
   const autoNameTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const activeSessionIdRef = useRef<string | null>(selectedSession?.id ?? null);
   activeSessionIdRef.current = selectedSession?.id ?? null;
+  const activeRuntimeIdRef = useRef(selectedSession?.runtimeId);
+  activeRuntimeIdRef.current = selectedSession?.runtimeId;
   const handleSessionStatsChange = useCallback((stats: SessionStatsInfo | null) => {
     setSessionStats(stats);
   }, []);
@@ -354,10 +357,10 @@ export function AppShell() {
     const lastOpenSessionId = getLastOpenSession(projectKey);
     if (!lastOpenSessionId) return;
     void fetch("/api/sessions")
-      .then((r) => (r.ok ? (r.json() as Promise<{ sessions: SessionInfo[] }>) : null))
+      .then((r) => (r.ok ? (r.json() as Promise<{ sessions: SessionInfo[]; sessionIdsByRuntimeId?: Record<string, string> }>) : null))
       .then((d) => {
         if (token !== workspaceRestoreTokenRef.current) return; // stale switch
-        const s = d?.sessions.find((x) => x.id === lastOpenSessionId);
+        const s = d ? restoreSessionContinuation(lastOpenSessionId, d.sessions, d.sessionIdsByRuntimeId) : undefined;
         if (!s) {
           // The list loaded but the remembered session is gone — forget it.
           // When the list itself failed (d === null) keep the memory so a
@@ -439,21 +442,21 @@ export function AppShell() {
     // project switch and the just-selected session is cleared.
     activeProjectRootRef.current = session.projectRoot ?? session.cwd;
     invalidateWorkspaceRestore();
-    // Re-clicking the already-open session must not remount the chat and
-    // re-run the full load/positioning cycle. Only skip when the effective
-    // cwd context already matches — otherwise a pending cwd move still needs
-    // the full re-select flow.
+    // A current row with a continuation handle can explicitly reopen history,
+    // including recovery from a handle unknown after a server restart.
+    // Keep ordinary same-session clicks as a no-op.
     if (!isRestore && selectedSession) {
       const sameProject =
         (selectedSession.projectRoot ?? selectedSession.cwd) ===
         (session.projectRoot ?? session.cwd);
-      if (selectedSession.id === session.id && sameProject) {
+      if (selectedSession.id === session.id && sameProject && !selectedSession.runtimeId) {
         if (isMobile) setSidebarOpen(false);
         return;
       }
     }
     setNewSessionCwd(null);
-    setSelectedSession(session);
+    if (!isRestore) clearSessionContinuation();
+    setSelectedSession({ ...session, runtimeId: isRestore ? session.runtimeId ?? getSessionContinuation(session.id) : undefined });
     setSessionKey((k) => k + 1);
     setSystemPrompt(null);
     setInitialSessionRestored(true);
@@ -472,6 +475,7 @@ export function AppShell() {
   }, [invalidateWorkspaceRestore, router, isMobile, selectedSession]);
 
   const handleNewSession = useCallback((_sessionId: string, cwd: string) => {
+    clearSessionContinuation();
     invalidateWorkspaceRestore();
     setSelectedSession(null);
     setNewSessionCwd(cwd);
@@ -553,13 +557,15 @@ export function AppShell() {
     }
   }, [handleSelectSession]);
 
-  const handleAgentEnd = useCallback(() => {
+  const handleAgentEnd = useCallback((completedSessionId?: string) => {
     setRefreshKey((k) => k + 1);
     setExplorerRefreshKey((k) => k + 1);
-    if (selectedSession) hydrateSelectedSession(selectedSession.id);
+    const targetSession = selectedSession
+      ? { ...selectedSession, id: completedSessionId ?? selectedSession.id }
+      : null;
+    if (targetSession) hydrateSelectedSession(targetSession.id);
 
     if (!shouldShowBrowserNotification()) return;
-    const targetSession = selectedSession;
     deliverSessionNotification({
       targetSession,
       title: targetSession?.name ?? translate("i18n.sessionComplete"),
@@ -581,27 +587,60 @@ export function AppShell() {
     });
   }, [deliverSessionNotification, selectedSession, translate]);
 
+  const handleSessionForked = useCallback((newSessionId: string, runtimeId?: string | null) => {
+    activeSessionIdRef.current = newSessionId;
+    activeRuntimeIdRef.current = runtimeId ?? undefined;
+    invalidateWorkspaceRestore();
+    setRefreshKey((k) => k + 1);
+    if (runtimeId === undefined) setSessionKey((k) => k + 1);
+    setNewSessionCwd(null);
+    setSelectedSession((prev) => ({
+      ...(prev ?? { path: "", cwd: "", created: "", modified: "", messageCount: 0, firstMessage: "" }),
+      id: newSessionId,
+      runtimeId: runtimeId ?? undefined,
+      transient: false,
+    }));
+    hydrateSelectedSession(newSessionId);
+    router.replace(`?session=${encodeURIComponent(newSessionId)}`, { scroll: false });
+  }, [invalidateWorkspaceRestore, router, hydrateSelectedSession]);
+
+  const handleRuntimeIdentity = useCallback((identity: SessionIdentity, request: SessionIdentity) => {
+    const current = { sessionId: activeSessionIdRef.current ?? "", runtimeId: activeRuntimeIdRef.current ?? null };
+    if (!canApplySessionIdentity(current, identity, request)) return false;
+    if (current.sessionId === identity.sessionId && current.runtimeId === identity.runtimeId) return true;
+    chatInputRef.current?.rekeyDraft(current.sessionId, identity.sessionId);
+    if (identity.runtimeId) rememberSessionContinuation(identity.sessionId, identity.runtimeId);
+    else if (request.runtimeId) clearSessionContinuation(undefined, request.runtimeId);
+    handleSessionForked(identity.sessionId, identity.runtimeId);
+    return true;
+  }, [handleSessionForked]);
+
   const handleAutoName = useCallback(async () => {
     const sessionId = selectedSession?.id;
+    const runtimeId = selectedSession?.runtimeId;
     if (!sessionId || autoNameStatus.kind === "naming") return;
     if (autoNameTimerRef.current) clearTimeout(autoNameTimerRef.current);
     setActiveTopPanel(null);
     setAutoNameStatus({ kind: "naming" });
 
     try {
-      const response = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/auto-name`, {
+      const response = await fetch(`/api/sessions/${encodeURIComponent(runtimeId ?? sessionId)}/auto-name`, {
         method: "POST",
       });
-      const body = (await response.json().catch(() => ({}))) as { title?: string; error?: string };
+      const body = (await response.json().catch(() => ({}))) as { title?: string; error?: string; sessionId?: string; runtimeId?: string };
       if (!response.ok || !body.title) {
         throw new Error(body.error || `HTTP ${response.status}`);
       }
 
       const title = body.title.trim();
       setRefreshKey((key) => key + 1);
-      if (activeSessionIdRef.current !== sessionId) return;
-      setSelectedSession((current) => current?.id === sessionId ? { ...current, name: title } : current);
-      setSessionStats((current) => current?.sessionId === sessionId ? { ...current, sessionName: title } : current);
+      const canonicalId = body.sessionId ?? sessionId;
+      if (!handleRuntimeIdentity(
+        { sessionId: canonicalId, runtimeId: body.runtimeId ?? null },
+        { sessionId, runtimeId: runtimeId ?? null },
+      )) return;
+      setSelectedSession((current) => current?.id === canonicalId ? { ...current, name: title } : current);
+      setSessionStats((current) => current ? { ...current, sessionId: canonicalId, sessionName: title } : current);
       setAutoNameStatus({ kind: "success" });
       autoNameTimerRef.current = setTimeout(() => setAutoNameStatus({ kind: "idle" }), 1800);
     } catch (error) {
@@ -610,7 +649,7 @@ export function AppShell() {
       setAutoNameStatus({ kind: "error", message });
       autoNameTimerRef.current = setTimeout(() => setAutoNameStatus({ kind: "idle" }), 5000);
     }
-  }, [autoNameStatus.kind, selectedSession?.id]);
+  }, [autoNameStatus.kind, selectedSession?.id, selectedSession?.runtimeId, handleRuntimeIdentity]);
 
   useEffect(() => {
     if (autoNameTimerRef.current) clearTimeout(autoNameTimerRef.current);
@@ -621,20 +660,6 @@ export function AppShell() {
     setExplorerRefreshKey((k) => k + 1);
   }, []);
 
-  const handleSessionForked = useCallback((newSessionId: string) => {
-    invalidateWorkspaceRestore();
-    setRefreshKey((k) => k + 1);
-    setSessionKey((k) => k + 1);
-    setNewSessionCwd(null);
-    setSelectedSession((prev) => ({
-      ...(prev ?? { path: "", cwd: "", created: "", modified: "", messageCount: 0, firstMessage: "" }),
-      id: newSessionId,
-      transient: false,
-    }));
-    hydrateSelectedSession(newSessionId);
-    router.replace(`?session=${encodeURIComponent(newSessionId)}`, { scroll: false });
-  }, [invalidateWorkspaceRestore, router, hydrateSelectedSession]);
-
   const handleInitialRestoreDone = useCallback(() => {
     setInitialSessionRestored(true);
   }, []);
@@ -711,7 +736,7 @@ export function AppShell() {
   const handleViewFullHistory = useCallback(() => {
     if (!selectedSession) return;
     window.open(
-      `/api/sessions/${encodeURIComponent(selectedSession.id)}/export?inline=1`,
+      `/api/sessions/${encodeURIComponent(selectedSession.runtimeId ?? selectedSession.id)}/export?inline=1`,
       "_blank",
       "noopener,noreferrer",
     );
@@ -789,6 +814,7 @@ export function AppShell() {
     <>
       <SessionSidebar
         selectedSessionId={selectedSession?.id ?? null}
+        selectedRuntimeId={selectedSession?.runtimeId}
         optimisticSession={selectedSession}
         onSelectSession={handleSelectSession}
         onNewSession={handleNewSession}
@@ -1706,6 +1732,8 @@ export function AppShell() {
             <div className="subagent-column">
               <SubagentPanel
                 sessionId={selectedSession?.id ?? null}
+                runtimeId={selectedSession?.runtimeId}
+                onRuntimeIdentity={handleRuntimeIdentity}
                 cwd={selectedSession?.cwd ?? effectiveNewSessionCwd ?? undefined}
                 subagents={subagents}
               />
@@ -1814,9 +1842,16 @@ export function AppShell() {
       <SettingsConfig
         cwd={projectTrustCwd}
         sessionId={selectedSession?.id ?? null}
+        runtimeId={selectedSession?.runtimeId}
+        onRuntimeIdentity={handleRuntimeIdentity}
         onClose={() => setSettingsConfigOpen(false)}
         onModelsChanged={() => setModelsRefreshKey((key) => key + 1)}
-        onReloaded={() => setSessionKey((key) => key + 1)}
+        onReloaded={(runtimeId) => {
+          const ownsSession = runtimeId
+            ? activeRuntimeIdRef.current === runtimeId
+            : activeSessionIdRef.current === selectedSession?.id && !activeRuntimeIdRef.current;
+          if (ownsSession) setSessionKey((key) => key + 1);
+        }}
       />
     )}
     {projectTrustDialogOpen && projectTrustCwd && (
diff --git a/components/ChatWindow.tsx b/components/ChatWindow.tsx
index 4176205669..ff6ac6b8ea 100644
--- a/components/ChatWindow.tsx
+++ b/components/ChatWindow.tsx
@@ -41,10 +41,10 @@ import {
 interface Props {
   session: SessionInfo | null;
   newSessionCwd: string | null;
-  onAgentEnd?: () => void;
+  onAgentEnd?: (sessionId?: string) => void;
   onAttentionNeeded?: (request: BlockingExtensionUiRequest) => void;
   onSessionCreated?: (session: SessionInfo) => void;
-  onSessionForked?: (newSessionId: string) => void;
+  onSessionForked?: (newSessionId: string, runtimeId?: string | null) => void;
   modelsRefreshKey?: number;
   chatInputRef?: React.RefObject<ChatInputHandle | null>;
   onBranchDataChange?: (tree: SessionTreeNode[], activeLeafId: string | null, onLeafChange: (leafId: string | null) => void) => void;
@@ -203,11 +203,11 @@ export function ChatWindow({ session, newSessionCwd, onAgentEnd, onAttentionNeed
   const soundEnabledRef = useRef(soundEnabled);
   soundEnabledRef.current = soundEnabled;
   const soundedExtensionDialogIdRef = useRef<string | null>(null);
-  const wrappedOnAgentEnd = useCallback(() => {
+  const wrappedOnAgentEnd = useCallback((sessionId?: string) => {
     if (soundEnabledRef.current) {
       playDoneSoundRef.current();
     }
-    onAgentEnd?.();
+    onAgentEnd?.(sessionId);
   }, [onAgentEnd]);
 
   // 稳定化 onEditContent 引用，配合 React.memo 防止历史消息重渲染
diff --git a/components/PluginsConfig.tsx b/components/PluginsConfig.tsx
index ce45041268..7549057132 100644
--- a/components/PluginsConfig.tsx
+++ b/components/PluginsConfig.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { sendAgentCommand } from "@/lib/agent-client";
+import { sendAgentCommand, type RuntimeSessionBinding } from "@/lib/agent-client";
 import { useIsMobile } from "@/hooks/useIsMobile";
 import type { PluginPackageInfo, PluginsResponse } from "@/lib/api-types";
 import { useI18n } from "@/hooks/useI18n";
@@ -615,14 +615,18 @@ function PackageDetail({
 export function PluginsConfig({
   cwd,
   sessionId,
+  runtimeId,
+  onRuntimeIdentity,
   onClose,
   onReloaded,
   embedded = false,
 }: {
   cwd: string;
   sessionId: string | null;
+  runtimeId?: string;
+  onRuntimeIdentity?: RuntimeSessionBinding["onIdentity"];
   onClose: () => void;
-  onReloaded?: () => void;
+  onReloaded?: (runtimeId: string | null) => void;
   embedded?: boolean;
 }) {
   const isMobile = useIsMobile();
@@ -741,8 +745,9 @@ export function PluginsConfig({
     setActionError(null);
     setActionMessage(null);
     try {
-      await sendAgentCommand(sessionId, { type: "reload" });
-      onReloaded?.();
+      const binding = { current: runtimeId ?? null, onIdentity: onRuntimeIdentity };
+      await sendAgentCommand(sessionId, { type: "reload" }, binding);
+      onReloaded?.(binding.current);
       await loadPlugins();
       setActionMessage("Session reloaded.");
     } catch (err) {
@@ -750,7 +755,7 @@ export function PluginsConfig({
     } finally {
       setBusyKey(null);
     }
-  }, [loadPlugins, onReloaded, sessionId]);
+  }, [loadPlugins, onReloaded, onRuntimeIdentity, runtimeId, sessionId]);
 
   const addBusy = busyKey?.startsWith("install:") ?? false;
 
diff --git a/components/SessionSidebar.test.mjs b/components/SessionSidebar.test.mjs
index 07571ef7fe..0f385dd2c1 100644
--- a/components/SessionSidebar.test.mjs
+++ b/components/SessionSidebar.test.mjs
@@ -65,3 +65,90 @@ test("does not expose disk-backed actions for transient sessions", () => {
   assert.match(sessionItemSource, /if \(session\.transient\) return;/);
   assert.match(sessionItemSource, /\{hovered && !session\.transient && \(/);
 });
+
+// Execute the actual activity effect with state/notification doubles, so these
+// cases cover unread markers and completion callbacks without copying its logic.
+const activityEffectStart = source.indexOf("    const previousSnapshot = previousActivitySnapshotRef.current;");
+const activityEffectEnd = source.indexOf("\n  }, [activitySnapshot,", activityEffectStart);
+assert.ok(activityEffectStart >= 0 && activityEffectEnd > activityEffectStart);
+const runActivityEffect = new Function(
+  "previousActivitySnapshotRef", "activitySnapshot", "runningSessionIds",
+  "selectedSessionId", "selectedRuntimeId", "allSessions", "setUnreadSessionIds",
+  "loadSessions", "onBackgroundTaskDone",
+  source.slice(activityEffectStart, activityEffectEnd),
+);
+
+const snapshot = (runningSessionIds, sessionIdsByRuntimeId = {}) => ({ runningSessionIds, sessionIdsByRuntimeId });
+const activityCases = [
+  {
+    name: "does not report selected runtime completion when restart loses its relocated identity",
+    previous: snapshot(["a"], { "runtime:selected": "a" }),
+    current: snapshot([]),
+    selectedSessionId: "b", selectedRuntimeId: "runtime:selected",
+    expectedUnread: [],
+  },
+  {
+    name: "still reports another runtime completing in the same restart snapshot",
+    previous: snapshot(["a", "other"], { "runtime:selected": "a", "runtime:other": "other" }),
+    current: snapshot([]),
+    selectedSessionId: "b", selectedRuntimeId: "runtime:selected",
+    expectedUnread: ["other"],
+  },
+  {
+    name: "does not suppress background completion when both runtime IDs are absent",
+    previous: snapshot(["a"]),
+    current: snapshot([]),
+    selectedSessionId: "b",
+    expectedUnread: ["a"],
+  },
+  {
+    name: "keeps ordinary selected transcript completion out of background notifications",
+    previous: snapshot(["a"]),
+    current: snapshot([]),
+    selectedSessionId: "a",
+    expectedUnread: [],
+  },
+  {
+    name: "matches selected completion through the current runtime mapping",
+    previous: snapshot(["a"], { "runtime:selected": "a" }),
+    current: snapshot([], { "runtime:selected": "b" }),
+    selectedSessionId: "a", selectedRuntimeId: "runtime:selected",
+    expectedUnread: [],
+  },
+  {
+    name: "does not complete a relocated runtime that is still running",
+    previous: snapshot(["a"], { "runtime:other": "a" }),
+    current: snapshot(["b"], { "runtime:other": "b" }),
+    selectedSessionId: "selected", selectedRuntimeId: "runtime:selected",
+    initialUnread: ["b"], expectedUnread: [],
+  },
+  {
+    name: "marks the current transcript unread when a background runtime finishes",
+    previous: snapshot(["a"], { "runtime:other": "a" }),
+    current: snapshot([], { "runtime:other": "b" }),
+    selectedSessionId: "selected", selectedRuntimeId: "runtime:selected",
+    expectedUnread: ["b"],
+  },
+];
+
+for (const scenario of activityCases) {
+  test(scenario.name, () => {
+    const previousRef = { current: scenario.previous };
+    let unread = new Set(scenario.initialUnread ?? []);
+    let completionCount = 0;
+    const refreshes = [];
+    runActivityEffect(
+      previousRef, scenario.current, new Set(scenario.current.runningSessionIds),
+      scenario.selectedSessionId, scenario.selectedRuntimeId,
+      ["a", "b", "other", "selected"].map((id) => ({ id })),
+      (update) => { unread = update(unread); },
+      (...args) => { refreshes.push(args); },
+      () => { completionCount += 1; },
+    );
+    assert.deepEqual([...unread], scenario.expectedUnread);
+    const completed = scenario.expectedUnread.length > 0;
+    assert.equal(completionCount, completed ? 1 : 0);
+    assert.deepEqual(refreshes, completed ? [[false, true]] : []);
+    assert.equal(previousRef.current, scenario.current);
+  });
+}
diff --git a/components/SessionSidebar.tsx b/components/SessionSidebar.tsx
index 39f082c5b3..53bd8699d5 100644
--- a/components/SessionSidebar.tsx
+++ b/components/SessionSidebar.tsx
@@ -4,6 +4,7 @@ import { useEffect, useLayoutEffect, useState, useCallback, useMemo, useRef, typ
 import type { SessionInfo } from "@/lib/types";
 import { loadExplorerOpen, saveExplorerOpen } from "@/lib/file-explorer-state";
 import { dispatchSessionRowContextMenu } from "@/lib/session-row-context-menu";
+import { restoreSessionContinuation } from "@/lib/workspace-memory";
 import { skillExpansionToCommand } from "@/lib/slash-display";
 import { useI18n } from "@/hooks/useI18n";
 import { DirectoryPicker } from "./DirectoryPicker";
@@ -79,6 +80,7 @@ function ToolbarIconButton({
 
 interface Props {
   selectedSessionId: string | null;
+  selectedRuntimeId?: string;
   optimisticSession?: SessionInfo | null;
   onSelectSession: (session: SessionInfo, isRestore?: boolean) => void;
   onNewSession?: (sessionId: string, cwd: string) => void;
@@ -444,7 +446,7 @@ function PiWebTitle() {
   );
 }
 
-export function SessionSidebar({ selectedSessionId, optimisticSession, onSelectSession, onNewSession, initialSessionId, skipInitialProjectSelection, onInitialRestoreDone, refreshKey, onSessionDeleted, selectedCwd: selectedCwdProp, onCwdChange, onOpenFile, explorerRefreshKey, onExplorerRefresh, onAtMention, onAtMentions, onBackgroundTaskDone }: Props) {
+export function SessionSidebar({ selectedSessionId, selectedRuntimeId, optimisticSession, onSelectSession, onNewSession, initialSessionId, skipInitialProjectSelection, onInitialRestoreDone, refreshKey, onSessionDeleted, selectedCwd: selectedCwdProp, onCwdChange, onOpenFile, explorerRefreshKey, onExplorerRefresh, onAtMention, onAtMentions, onBackgroundTaskDone }: Props) {
   const { t } = useI18n();
   const [allSessions, setAllSessions] = useState<SessionInfo[]>([]);
   const sessionsForDisplay = optimisticSession && !allSessions.some((session) => session.id === optimisticSession.id)
@@ -481,9 +483,14 @@ export function SessionSidebar({ selectedSessionId, optimisticSession, onSelectS
   const [changesCollapsed, setChangesCollapsed] = useState(true);
   const [sessionRefreshDone, setSessionRefreshDone] = useState(false);
   const [explorerRefreshDone, setExplorerRefreshDone] = useState(false);
-  const [runningSessionIds, setRunningSessionIds] = useState<Set<string>>(() => new Set());
+  const [activitySnapshot, setActivitySnapshot] = useState<{
+    runningSessionIds?: string[];
+    sessionIdsByRuntimeId?: Record<string, string>;
+  }>({});
+  const runningSessionIds = useMemo(() => new Set(activitySnapshot.runningSessionIds ?? []), [activitySnapshot]);
   const [unreadSessionIds, setUnreadSessionIds] = useState<Set<string>>(() => loadUnreadSessionIds());
-  const previousRunningSessionIdsRef = useRef<Set<string>>(new Set());
+  const previousActivitySnapshotRef = useRef(activitySnapshot);
+  const listedRuntimeIdsRef = useRef<Record<string, string>>({});
   // Once polling has delivered a snapshot it is the source of truth for
   // running state; late /api/sessions responses must not overwrite it.
   const runningPollAuthoritativeRef = useRef(false);
@@ -503,12 +510,13 @@ export function SessionSidebar({ selectedSessionId, optimisticSession, onSelectS
         cache: "no-store",
       });
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
-      const data = await res.json() as { sessions: SessionInfo[]; runningSessionIds?: string[] };
+      const data = await res.json() as { sessions: SessionInfo[]; runningSessionIds?: string[]; sessionIdsByRuntimeId?: Record<string, string> };
+      listedRuntimeIdsRef.current = data.sessionIdsByRuntimeId ?? {};
       setAllSessions(data.sessions);
       // Treat the fetched running set as an initial fallback only. Once the
       // lightweight poll is live, a slow session-list fetch cannot overwrite it.
       if (!runningPollAuthoritativeRef.current) {
-        setRunningSessionIds(new Set(data.runningSessionIds ?? []));
+        setActivitySnapshot({ runningSessionIds: data.runningSessionIds, sessionIdsByRuntimeId: data.sessionIdsByRuntimeId });
       }
       // Drop unread markers for sessions that no longer exist (e.g. deleted).
       const existingIds = new Set(data.sessions.map((s) => s.id));
@@ -584,10 +592,10 @@ export function SessionSidebar({ selectedSessionId, optimisticSession, onSelectS
           signal: current.signal,
         });
         if (!res.ok) return;
-        const data = await res.json() as { runningSessionIds?: string[] };
+        const data = await res.json() as { runningSessionIds?: string[]; sessionIdsByRuntimeId?: Record<string, string> };
         if (stopped || controller !== current) return;
         runningPollAuthoritativeRef.current = true;
-        setRunningSessionIds(new Set(data.runningSessionIds ?? []));
+        setActivitySnapshot({ runningSessionIds: data.runningSessionIds, sessionIdsByRuntimeId: data.sessionIdsByRuntimeId });
       } catch {
         // Keep the last known state; the next visible-tab poll retries.
       } finally {
@@ -617,8 +625,23 @@ export function SessionSidebar({ selectedSessionId, optimisticSession, onSelectS
   }, []);
 
   useEffect(() => {
-    const previous = previousRunningSessionIdsRef.current;
-    const completedInBackground = [...previous].filter((id) => !runningSessionIds.has(id) && id !== selectedSessionId);
+    const previousSnapshot = previousActivitySnapshotRef.current;
+    const previous = new Set(previousSnapshot.runningSessionIds ?? []);
+    // Compare the same live wrapper across fallback IDs before reporting completion.
+    const previousRuntimeIds = new Map(Object.entries(previousSnapshot.sessionIdsByRuntimeId ?? {})
+      .map(([runtimeId, sessionId]) => [sessionId, runtimeId]));
+    const selectedCanonicalId = selectedRuntimeId
+      ? activitySnapshot.sessionIdsByRuntimeId?.[selectedRuntimeId] ?? selectedSessionId
+      : selectedSessionId;
+    const completedInBackground = [...previous].flatMap((id) => {
+      const runtimeId = previousRuntimeIds.get(id);
+      // A server restart can erase the current mapping before the sidebar sees
+      // a relocation. The previous snapshot still identifies the selected run.
+      if (runtimeId && runtimeId === selectedRuntimeId) return [];
+      const currentId = (runtimeId && activitySnapshot.sessionIdsByRuntimeId?.[runtimeId]) || id;
+      return !runningSessionIds.has(currentId) && currentId !== selectedCanonicalId
+        ? [currentId] : [];
+    });
     const newlyRunning = [...runningSessionIds].filter((id) => !previous.has(id));
 
     if (completedInBackground.length > 0 || newlyRunning.length > 0) {
@@ -639,8 +662,8 @@ export function SessionSidebar({ selectedSessionId, optimisticSession, onSelectS
       onBackgroundTaskDone?.();
     }
 
-    previousRunningSessionIdsRef.current = runningSessionIds;
-  }, [runningSessionIds, selectedSessionId, allSessions, loadSessions, onBackgroundTaskDone]);
+    previousActivitySnapshotRef.current = activitySnapshot;
+  }, [activitySnapshot, runningSessionIds, selectedSessionId, selectedRuntimeId, allSessions, loadSessions, onBackgroundTaskDone]);
 
   useEffect(() => {
     if (!selectedSessionId) return;
@@ -736,7 +759,7 @@ export function SessionSidebar({ selectedSessionId, optimisticSession, onSelectS
       // If restoring a session, set cwd to match that session
       if (initialSessionId && !restoredRef.current) {
         restoredRef.current = true;
-        const target = allSessions.find((s) => s.id === initialSessionId);
+        const target = restoreSessionContinuation(initialSessionId, allSessions, listedRuntimeIdsRef.current);
         if (target) {
           setSelectedCwd(target.cwd);
           onSelectSession(target, true);
diff --git a/components/SettingsConfig.tsx b/components/SettingsConfig.tsx
index 475f536a10..1e0493758e 100644
--- a/components/SettingsConfig.tsx
+++ b/components/SettingsConfig.tsx
@@ -8,7 +8,7 @@ import { AccessConfig } from "./AccessConfig";
 import { SearchableSelect } from "./SearchableSelect";
 import { refreshOmpTheme, useTheme } from "@/hooks/useTheme";
 import { refreshDisplaySettings } from "@/hooks/useDisplaySettings";
-import { sendAgentCommand } from "@/lib/agent-client";
+import { sendAgentCommand, type RuntimeSessionBinding } from "@/lib/agent-client";
 import type {
   McpConfigResponse,
   McpScopeConfig,
@@ -26,10 +26,12 @@ type SettingsSection = "models" | "themes" | "skills" | "plugins" | "mcp" | "acc
 interface SettingsConfigProps {
   cwd?: string | null;
   sessionId: string | null;
+  runtimeId?: string;
+  onRuntimeIdentity?: RuntimeSessionBinding["onIdentity"];
   initialSection?: SettingsSection;
   onClose: () => void;
   onModelsChanged?: () => void;
-  onReloaded?: () => void;
+  onReloaded?: (runtimeId: string | null) => void;
 }
 
 const CORE_SECTIONS: Array<{ id: SettingsSection; label: string; icon: string; requiresCwd?: boolean }> = [
@@ -187,7 +189,7 @@ function ThemePreview({ palette }: { palette: WebThemePalette }) {
 /** Settings the web client applies itself, without reloading the agent. */
 const DISPLAY_SETTING_PATHS = new Set(["hideThinkingBlock"]);
 
-export function SettingsConfig({ cwd, sessionId, initialSection = "models", onClose, onModelsChanged, onReloaded }: SettingsConfigProps) {
+export function SettingsConfig({ cwd, sessionId, runtimeId, onRuntimeIdentity, initialSection = "models", onClose, onModelsChanged, onReloaded }: SettingsConfigProps) {
   const [section, setSection] = useState<SettingsSection>(initialSection);
   const [settings, setSettings] = useState<SettingsResponse | null>(null);
   const [loading, setLoading] = useState(true);
@@ -257,15 +259,16 @@ export function SettingsConfig({ cwd, sessionId, initialSection = "models", onCl
     if (!sessionId) return;
     setReloading(true);
     try {
-      await sendAgentCommand(sessionId, { type: "reload" });
+      const binding = { current: runtimeId ?? null, onIdentity: onRuntimeIdentity };
+      await sendAgentCommand(sessionId, { type: "reload" }, binding);
       setNeedsReload(false);
-      onReloaded?.();
+      onReloaded?.(binding.current);
     } catch (error) {
       setLoadError(error instanceof Error ? error.message : String(error));
     } finally {
       setReloading(false);
     }
-  }, [onReloaded, sessionId]);
+  }, [onReloaded, onRuntimeIdentity, runtimeId, sessionId]);
   const selectedTab = settings?.tabs.find((tab) => tab.id === activeTab);
   const pageTitle = query.trim() ? `Search · ${filteredFields.length}` : selectedTab?.label ?? "Settings";
 
@@ -340,14 +343,15 @@ export function SettingsConfig({ cwd, sessionId, initialSection = "models", onCl
           <div className={styles.closeRail}><button type="button" className={styles.closeButton} onClick={close}><span>Close settings</span><span aria-hidden="true">×</span></button></div>
         </aside>
         <main className={styles.content}>
-          {query.trim() ? renderGenericSettings() : section === "models" ? <ModelsConfig cwd={cwd} embedded onClose={close} onModelsChanged={onModelsChanged} /> : section === "themes" ? renderThemeSection() : section === "skills" && cwd ? <SkillsConfig cwd={cwd} embedded onClose={close} /> : section === "plugins" && cwd ? <PluginsConfig cwd={cwd} sessionId={sessionId} embedded onClose={close} onReloaded={onReloaded} /> : section === "mcp" ? <McpSettings cwd={cwd} sessionId={sessionId} onReloaded={onReloaded} /> : section === "access" ? <AccessConfig /> : renderGenericSettings()}
+          {query.trim() ? renderGenericSettings() : section === "models" ? <ModelsConfig cwd={cwd} embedded onClose={close} onModelsChanged={onModelsChanged} /> : section === "themes" ? renderThemeSection() : section === "skills" && cwd ? <SkillsConfig cwd={cwd} embedded onClose={close} /> : section === "plugins" && cwd ? <PluginsConfig cwd={cwd} sessionId={sessionId} runtimeId={runtimeId} onRuntimeIdentity={onRuntimeIdentity} embedded onClose={close} onReloaded={onReloaded} /> : section === "mcp" ? <McpSettings cwd={cwd} sessionId={sessionId} runtimeId={runtimeId} onRuntimeIdentity={onRuntimeIdentity} onReloaded={onReloaded} /> : section === "access" ? <AccessConfig /> : renderGenericSettings()}
         </main>
       </div>
     </div>
   );
 }
 
-function McpSettings({ cwd, sessionId, onReloaded }: { cwd?: string | null; sessionId?: string | null; onReloaded?: () => void }) {
+function McpSettings({ cwd, sessionId, runtimeId, onRuntimeIdentity, onReloaded }: { cwd?: string | null; sessionId?: string | null; runtimeId?: string;
+  onRuntimeIdentity?: RuntimeSessionBinding["onIdentity"]; onReloaded?: (runtimeId: string | null) => void }) {
   const [data, setData] = useState<McpConfigResponse | null>(null);
   const [scope, setScope] = useState<"user" | "project">("user");
   const [selected, setSelected] = useState(0);
@@ -423,8 +427,9 @@ function McpSettings({ cwd, sessionId, onReloaded }: { cwd?: string | null; sess
       if (!response.ok || result.error) throw new Error(result.error ?? `HTTP ${response.status}`);
       await load();
       if (sessionId) {
-        await sendAgentCommand(sessionId, { type: "reload" });
-        onReloaded?.();
+        const binding = { current: runtimeId ?? null, onIdentity: onRuntimeIdentity };
+        await sendAgentCommand(sessionId, { type: "reload" }, binding);
+        onReloaded?.(binding.current);
       }
     } catch (caught) {
       setError(caught instanceof Error ? caught.message : String(caught));
diff --git a/components/SubagentPanel.tsx b/components/SubagentPanel.tsx
index eb0d9ac4c0..1acf7dd416 100644
--- a/components/SubagentPanel.tsx
+++ b/components/SubagentPanel.tsx
@@ -4,7 +4,7 @@ import { useEffect, useMemo, useRef, useState } from "react";
 import type { AgentMessage, SubagentSnapshot, ToolResultMessage } from "@/lib/types";
 import { useI18n } from "@/hooks/useI18n";
 import { normalizeToolCalls } from "@/lib/normalize";
-import { sendAgentCommand } from "@/lib/agent-client";
+import { sendAgentCommand, type RuntimeSessionBinding } from "@/lib/agent-client";
 import { MessageView } from "./MessageView";
 
 type SubagentTranscriptEntry = {
@@ -70,11 +70,15 @@ function subagentActivity(subagent: SubagentSnapshot, t: (key: string, params?:
 
 function SubagentDetail({
   sessionId,
+  runtimeId,
+  onRuntimeIdentity,
   cwd,
   subagent,
   onBack,
 }: {
   sessionId: string;
+  runtimeId?: string;
+  onRuntimeIdentity?: RuntimeSessionBinding["onIdentity"];
   cwd?: string;
   subagent: SubagentSnapshot;
   onBack: () => void;
@@ -104,7 +108,10 @@ function SubagentDetail({
           type: "get_subagent_messages",
           subagentId: subagent.id,
           fromByte: nextByte,
-        });
+        }, { current: runtimeId ?? null, onIdentity: (identity, request) => {
+          if (disposed) return false;
+          return onRuntimeIdentity?.(identity, request);
+        } });
         if (disposed) return;
         const chunk = result.entries.flatMap((entry, index) =>
           entry.type === "message" && entry.message
@@ -130,7 +137,7 @@ function SubagentDetail({
       disposed = true;
       clearInterval(interval);
     };
-  }, [active, sessionId, subagent.id]);
+  }, [active, sessionId, runtimeId, onRuntimeIdentity, subagent.id]);
 
   useEffect(() => {
     if (!followTailRef.current) return;
@@ -269,7 +276,7 @@ function SubagentRow({ subagent, selected, onSelect }: { subagent: SubagentSnaps
   );
 }
 
-export function SubagentPanel({ sessionId, cwd, subagents }: { sessionId: string | null; cwd?: string; subagents: SubagentSnapshot[] }) {
+export function SubagentPanel({ sessionId, runtimeId, onRuntimeIdentity, cwd, subagents }: { sessionId: string | null; runtimeId?: string; onRuntimeIdentity?: RuntimeSessionBinding["onIdentity"]; cwd?: string; subagents: SubagentSnapshot[] }) {
   const { t } = useI18n();
   const [collapsed, setCollapsed] = useState(false);
   const [selectedId, setSelectedId] = useState<string | null>(null);
@@ -305,7 +312,7 @@ export function SubagentPanel({ sessionId, cwd, subagents }: { sessionId: string
       }}
     >
       {selected ? (
-        <SubagentDetail sessionId={sessionId} cwd={cwd} subagent={selected} onBack={() => setSelectedId(null)} />
+        <SubagentDetail sessionId={sessionId} runtimeId={runtimeId} onRuntimeIdentity={onRuntimeIdentity} cwd={cwd} subagent={selected} onBack={() => setSelectedId(null)} />
       ) : (
         <>
           <button
diff --git a/hooks/useAgentSession.runtime-context.test.mjs b/hooks/useAgentSession.runtime-context.test.mjs
new file mode 100644
index 0000000000..8b166d0c25
--- /dev/null
+++ b/hooks/useAgentSession.runtime-context.test.mjs
@@ -0,0 +1,263 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import ts from "typescript";
+
+const source = await readFile(new URL("./useAgentSession.ts", import.meta.url), "utf8");
+const clientSource = await readFile(new URL("../lib/agent-client.ts", import.meta.url), "utf8");
+const memorySource = await readFile(new URL("../lib/workspace-memory.ts", import.meta.url), "utf8");
+const ast = ts.createSourceFile("useAgentSession.ts", source, ts.ScriptTarget.Latest, true);
+const callbacks = new Map();
+function collect(node) {
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)
+    && node.initializer && ts.isCallExpression(node.initializer)
+    && node.initializer.expression.getText(ast) === "useCallback") {
+    callbacks.set(node.name.text, node.initializer.arguments[0].getText(ast));
+  }
+  if (ts.isBinaryExpression(node) && node.left.getText(ast) === "runtimeIdRef.onIdentity") {
+    callbacks.set("onIdentity", node.right.getText(ast));
+  }
+  ts.forEachChild(node, collect);
+}
+collect(ast);
+
+// Run production callback bodies and modules, removing TypeScript syntax only.
+// All identity/retry/storage decisions remain in production code. Each harness
+// gets its own fetch and sessionStorage, without patching shared browser globals.
+function callback(name, bindings) {
+  assert.ok(callbacks.has(name), `Missing callback: ${name}`);
+  const { outputText } = ts.transpileModule(`const callback = ${callbacks.get(name)};`, {
+    compilerOptions: { target: ts.ScriptTarget.ES2022 },
+  });
+  return new Function(...Object.keys(bindings), `${outputText}\nreturn callback;`)(...Object.values(bindings));
+}
+
+function productionModule(source, bindings, dependencies = {}) {
+  const { outputText } = ts.transpileModule(source, {
+    compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS },
+  });
+  const exports = {};
+  const require = (name) => {
+    assert.ok(Object.hasOwn(dependencies, name), `Unexpected dependency: ${name}`);
+    return dependencies[name];
+  };
+  new Function("exports", "require", ...Object.keys(bindings), outputText)(
+    exports, require, ...Object.values(bindings),
+  );
+  return exports;
+}
+
+function deferred() {
+  let resolve;
+  const promise = new Promise((done) => { resolve = done; });
+  return { promise, resolve };
+}
+
+const response = (data, status = 200) => ({ ok: status < 400, status, json: async () => data });
+const context = (label, identity = { sessionId: "b", runtimeId: "runtime:r1" }) => ({
+  ...identity,
+  context: {
+    messages: [{ role: "user", content: label }],
+    entryIds: [`${label}-entry`],
+  },
+  contextUsage: { percent: 73, contextWindow: 1000, tokens: 730 },
+});
+
+function harness() {
+  const effects = [];
+  const storage = new Map();
+  const memory = productionModule(memorySource, {
+    window: { sessionStorage: {
+      getItem: (key) => storage.get(key) ?? null,
+      setItem: (key, value) => { storage.set(key, value); effects.push(["storage:set", key, value]); },
+      removeItem: (key) => { storage.delete(key); effects.push(["storage:remove", key]); },
+    } },
+  });
+  memory.rememberSessionContinuation("b", "runtime:r1");
+  effects.length = 0;
+  const ui = {
+    Messages: [{ role: "user", content: "current messages" }],
+    EntryIds: ["current-entry"],
+    ContextUsage: { percent: 10, contextWindow: 1000, tokens: 100 },
+    ActiveLeafId: "current-leaf",
+  };
+  const bindings = {
+    mountedRef: { current: true },
+    sessionIdRef: { current: "b" },
+    runtimeIdRef: { current: "runtime:r1" },
+    identityDraftKeyRef: { current: "b" },
+    contextRequestRef: { current: 0 },
+    eventSourceRef: { current: null },
+    eventSourceSessionIdRef: { current: "b" },
+    eventSourceRuntimeIdRef: { current: null },
+    bashRunningRef: { current: false },
+    opts: {},
+    closeEvents: () => effects.push(["closeEvents"]),
+    onSessionForked: (...args) => effects.push(["identity", ...args]),
+    rememberSessionContinuation: memory.rememberSessionContinuation,
+    clearSessionContinuation: memory.clearSessionContinuation,
+    console: { error: (...args) => effects.push(["error", ...args]) },
+    fetch: () => { throw new Error("Unexpected request"); },
+  };
+  for (const field of Object.keys(ui)) {
+    bindings[`set${field}`] = (value) => {
+      ui[field] = value;
+      effects.push([field, value]);
+    };
+  }
+  const client = productionModule(clientSource, { fetch: (...args) => bindings.fetch(...args) }, {
+    "./workspace-memory": memory,
+  });
+  const commands = [];
+  bindings.canApplySessionIdentity = client.canApplySessionIdentity;
+  bindings.sendAgentCommand = (...args) => {
+    const command = client.sendAgentCommand(...args);
+    commands.push(command);
+    return command;
+  };
+  bindings.followSessionIdentity = callback("followSessionIdentity", bindings);
+  bindings.runtimeIdRef.onIdentity = callback("onIdentity", bindings);
+  // Use an indirection only for fetch so responses can be scheduled per test.
+  const callbackBindings = { ...bindings, fetch: (...args) => bindings.fetch(...args) };
+  bindings.loadContext = callback("loadContext", callbackBindings);
+  bindings.handleNavigate = callback("handleNavigate", bindings);
+  return { bindings, commands, effects, memory, storage, ui };
+}
+
+function snapshot(h) {
+  return structuredClone({
+    sessionId: h.bindings.sessionIdRef.current,
+    runtimeId: h.bindings.runtimeIdRef.current,
+    storage: [...h.storage],
+    ui: h.ui,
+  });
+}
+
+for (const [label, identity] of [
+  ["explicit null runtime", { sessionId: "b", runtimeId: null }],
+  ["missing runtime", { sessionId: "b" }],
+  ["old live runtime", { sessionId: "b", runtimeId: "runtime:r1" }],
+]) {
+  test(`navigation ignores delayed context with ${label} after its command reopens B/R2`, async () => {
+    const h = harness();
+    const expiredCommand = deferred();
+    const oldContext = deferred();
+    const contextRequested = deferred();
+    const requests = [];
+    h.bindings.fetch = async (url, options) => {
+      requests.push({ url, command: options ? JSON.parse(options.body) : null });
+      if (url === "/api/agent/runtime%3Ar1") return expiredCommand.promise;
+      if (url === "/api/agent/b") {
+        return response({ success: true, data: {}, sessionId: "b", runtimeId: "runtime:r2" });
+      }
+      assert.equal(url, "/api/sessions/runtime%3Ar1/context?deferThinking=1&deferMedia=1&leafId=old-leaf");
+      return { ok: true, json: () => { contextRequested.resolve(); return oldContext.promise; } };
+    };
+
+    const navigating = h.bindings.handleNavigate("old-leaf");
+    await contextRequested.promise;
+    expiredCommand.resolve(response({
+      error: "Runtime session expired", code: "runtime_expired", accepted: false, sessionId: "b",
+    }, 404));
+    await Promise.all(h.commands);
+    assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+    assert.equal(h.memory.getSessionContinuation("b"), "runtime:r2");
+    assert.equal(h.bindings.contextRequestRef.current, 1, "same-transcript reopening keeps the context request number");
+    assert.deepEqual(requests, [
+      { url: "/api/agent/runtime%3Ar1", command: { type: "navigate_tree", targetId: "old-leaf" } },
+      { url: "/api/sessions/runtime%3Ar1/context?deferThinking=1&deferMedia=1&leafId=old-leaf", command: null },
+      { url: "/api/agent/b", command: { type: "navigate_tree", targetId: "old-leaf" } },
+    ]);
+    const reopened = snapshot(h);
+    h.effects.length = 0;
+
+    // The response body completes only after the production expiry retry has
+    // rebound the same transcript to R2 and persisted that continuation.
+    oldContext.resolve(context("obsolete branch", identity));
+    await navigating;
+    assert.deepEqual(snapshot(h), reopened, "stale context must not clear R2 or replace its UI/storage");
+    assert.deepEqual(h.effects, [], "stale context must not notify the parent or invoke any setter");
+  });
+}
+
+test("an owned expired runtime still clears its continuation and applies historical context", async () => {
+  const h = harness();
+  const historical = context("historical", { sessionId: "b", runtimeId: null });
+  h.bindings.fetch = async () => response(historical);
+  assert.equal(await h.bindings.loadContext("b", null), true);
+  assert.equal(h.bindings.runtimeIdRef.current, null);
+  assert.equal(h.memory.getSessionContinuation("b"), undefined);
+  assert.deepEqual(h.ui.Messages, historical.context.messages);
+  assert.deepEqual(h.ui.EntryIds, historical.context.entryIds);
+  assert.deepEqual(h.ui.ContextUsage, historical.contextUsage);
+  assert.ok(h.effects.some(([kind, sessionId, runtimeId]) => kind === "identity" && sessionId === "b" && runtimeId === null));
+});
+
+test("a same-runtime context response still applies its messages, entry IDs and usage", async () => {
+  const h = harness();
+  const current = context("owned branch");
+  h.bindings.fetch = async () => response(current);
+  assert.equal(await h.bindings.loadContext("b", "owned-leaf"), true);
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r1");
+  assert.equal(h.memory.getSessionContinuation("b"), "runtime:r1");
+  assert.deepEqual(h.ui.Messages, current.context.messages);
+  assert.deepEqual(h.ui.EntryIds, current.context.entryIds);
+  assert.deepEqual(h.ui.ContextUsage, current.contextUsage);
+  assert.equal(h.effects.some(([kind]) => kind === "identity" || kind === "storage:remove"), false);
+});
+
+test("an owned same-runtime relocation still follows its new transcript", async () => {
+  const h = harness();
+  const relocated = context("relocated", { sessionId: "c", runtimeId: "runtime:r1" });
+  h.bindings.fetch = async () => response(relocated);
+  assert.equal(await h.bindings.loadContext("b", "owned-leaf"), true);
+  assert.equal(h.bindings.sessionIdRef.current, "c");
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r1");
+  assert.equal(h.memory.getSessionContinuation("c"), "runtime:r1");
+  assert.deepEqual(h.ui.Messages, relocated.context.messages);
+});
+
+test("a newer context request owns the UI even when the runtime stays the same", async () => {
+  const h = harness();
+  const older = deferred();
+  const requested = deferred();
+  const latest = context("latest branch");
+  h.bindings.fetch = async (url) => {
+    if (url.endsWith("leafId=old-leaf")) {
+      return { ok: true, json: () => { requested.resolve(); return older.promise; } };
+    }
+    assert.ok(url.endsWith("leafId=latest-leaf"));
+    return response(latest);
+  };
+  const loadingOld = h.bindings.loadContext("b", "old-leaf");
+  await requested.promise;
+  assert.equal(await h.bindings.loadContext("b", "latest-leaf"), true);
+  assert.deepEqual(h.ui.Messages, latest.context.messages);
+  const newest = snapshot(h);
+  h.effects.length = 0;
+  older.resolve(context("obsolete", { sessionId: "b", runtimeId: null }));
+  assert.equal(await loadingOld, false);
+  assert.deepEqual(snapshot(h), newest);
+  assert.deepEqual(h.effects, []);
+});
+
+for (const superseded of ["different session selection", "unmount"]) {
+  test(`context does not apply after ${superseded}`, async () => {
+    const h = harness();
+    const older = deferred();
+    const requested = deferred();
+    h.bindings.fetch = async () => ({
+      ok: true, json: () => { requested.resolve(); return older.promise; },
+    });
+    const loading = h.bindings.loadContext("b", "old-leaf");
+    await requested.promise;
+    if (superseded === "unmount") h.bindings.mountedRef.current = false;
+    else h.bindings.followSessionIdentity("c", "runtime:r2");
+    const current = snapshot(h);
+    h.effects.length = 0;
+    older.resolve(context("obsolete", { sessionId: "b", runtimeId: null }));
+    assert.equal(await loading, false);
+    assert.deepEqual(snapshot(h), current);
+    assert.deepEqual(h.effects, []);
+  });
+}
diff --git a/hooks/useAgentSession.runtime-events.test.mjs b/hooks/useAgentSession.runtime-events.test.mjs
new file mode 100644
index 0000000000..afb55ab990
--- /dev/null
+++ b/hooks/useAgentSession.runtime-events.test.mjs
@@ -0,0 +1,641 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import ts from "typescript";
+import { isBlockingExtensionUiRequest } from "../lib/browser-notifications.ts";
+import { normalizeToolCalls } from "../lib/normalize.ts";
+
+const source = await readFile(new URL("./useAgentSession.ts", import.meta.url), "utf8");
+const ast = ts.createSourceFile("useAgentSession.ts", source, ts.ScriptTarget.Latest, true);
+const callbacks = new Map();
+const declarations = new Map();
+function collect(node) {
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)
+    && node.initializer && ts.isCallExpression(node.initializer)
+    && node.initializer.expression.getText(ast) === "useCallback") {
+    callbacks.set(node.name.text, node.initializer.arguments[0].getText(ast));
+  }
+  if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) && node.name) {
+    declarations.set(node.name.text, node.getText(ast));
+  }
+  ts.forEachChild(node, collect);
+}
+collect(ast);
+
+const callbackNames = [
+  "closeEvents", "followSessionIdentity", "followRuntimeState", "cancelEventStreamGrace",
+  "handleExtensionUiRequest", "handleAgentEvent", "connectEvents", "ensureEventsConnected", "refreshContextUsage",
+];
+const helperNames = ["streamReducer", "EventStreamConnectionError"];
+for (const name of callbackNames) assert.ok(callbacks.has(name), `Missing callback: ${name}`);
+for (const name of helperNames) assert.ok(declarations.has(name), `Missing declaration: ${name}`);
+// Compile the real callbacks together so their cross-callback calls, ordering and
+// ownership guards stay production code. Only browser/network/React effects are doubles.
+const { outputText } = ts.transpileModule([
+  ...helperNames.map((name) => declarations.get(name)),
+  ...callbackNames.map((name) => `const ${name} = ${callbacks.get(name)};`),
+  `return { ${[...callbackNames, ...helperNames].join(", ")} };`,
+].join("\n"), { compilerOptions: { target: ts.ScriptTarget.ES2022 } });
+
+const response = (data) => ({ ok: true, json: async () => data });
+const tick = () => new Promise((resolve) => setImmediate(resolve));
+function track(promise) {
+  const result = { status: "pending" };
+  result.promise = promise.then(
+    (value) => Object.assign(result, { status: "fulfilled", value }),
+    (error) => Object.assign(result, { status: "rejected", error }),
+  );
+  return result;
+}
+
+function harness({ sessionId = "a", runtimeId = "runtime:r1" } = {}) {
+  const sources = [];
+  const effects = [];
+  const requests = [];
+  const replies = [];
+  const timers = new Map();
+  const state = { stream: { isStreaming: false, streamingMessage: null }, ExtensionDialog: null };
+  let nextTimer = 0;
+  class FakeEventSource {
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSED = 2;
+    readyState = FakeEventSource.CONNECTING;
+    closeCount = 0;
+    constructor(url) { this.url = url; sources.push(this); }
+    open() { this.readyState = FakeEventSource.OPEN; }
+    frame(event) { this.onmessage?.({ data: JSON.stringify(event) }); }
+    close() { this.closeCount += 1; this.readyState = FakeEventSource.CLOSED; }
+  }
+  const bindings = {
+    EventSource: FakeEventSource,
+    isBlockingExtensionUiRequest,
+    normalizeToolCalls,
+    mountedRef: { current: true },
+    sessionIdRef: { current: sessionId },
+    runtimeIdRef: { current: runtimeId },
+    identityDraftKeyRef: { current: sessionId },
+    contextRequestRef: { current: 0 },
+    contextUsageRequestIdRef: { current: 0 },
+    promptRunIdRef: { current: 1 },
+    modelSwitchPendingRef: { current: false },
+    eventSourceRef: { current: null },
+    eventSourceSessionIdRef: { current: null },
+    eventSourceRuntimeIdRef: { current: null },
+    eventConnectionAttemptRef: { current: null },
+    eventStreamGraceGenerationRef: { current: 0 },
+    eventStreamGraceActiveRef: { current: false },
+    eventStreamGraceTimerRef: { current: null },
+    handleAgentEventRef: { current: null },
+    agentRunningRef: { current: false },
+    sdkAgentActiveRef: { current: false },
+    EVENT_STREAM_CONNECT_TIMEOUT_MS: 5_000,
+    opts: {},
+    onSessionForked: (...args) => effects.push(["identity", ...args]),
+    rememberSessionContinuation: (...args) => effects.push(["remember", ...args]),
+    clearSessionContinuation: (...args) => effects.push(["clear", ...args]),
+    onAttentionNeeded: (request) => effects.push(["attention", request]),
+    setTimeout: (fn, delay) => { const id = ++nextTimer; timers.set(id, { fn, delay }); return id; },
+    clearTimeout: (id) => timers.delete(id),
+    fetch: async (url) => {
+      requests.push(url);
+      return replies.length ? replies.shift() : response({
+        running: true,
+        state: { sessionId: bindings.sessionIdRef.current, runtimeId: bindings.runtimeIdRef.current },
+      });
+    },
+    dispatch: (action) => {
+      effects.push(["dispatch", action]);
+      state.stream = api.streamReducer(state.stream, action);
+    },
+  };
+  for (const name of ["AgentRunning", "AgentPhase", "ExtensionDialog", "ExtensionCustomUi",
+    "ExtensionStatuses", "ExtensionWidgets", "CurrentModelOverride", "ContextUsage"]) {
+    bindings[`set${name}`] = (value) => {
+      state[name] = typeof value === "function" ? value(state[name]) : value;
+      effects.push([name, state[name]]);
+    };
+  }
+  const api = new Function(...Object.keys(bindings), outputText)(...Object.values(bindings));
+  bindings.handleAgentEventRef.current = api.handleAgentEvent;
+  return {
+    ...api, bindings, sources, effects, requests, replies, timers, state,
+    runTimers(delay) {
+      const selected = [...timers].filter(([, timer]) => timer.delay === delay);
+      assert.ok(selected.length, `No timer scheduled for ${delay}ms`);
+      for (const [id, timer] of selected) { timers.delete(id); timer.fn(); }
+    },
+  };
+}
+
+async function openRuntime(h, sessionId = "a", runtimeId = "runtime:r1") {
+  const pending = track(h.connectEvents(sessionId));
+  const stream = h.sources.at(-1);
+  stream.open();
+  stream.frame({ type: "connected", sessionId, runtimeId });
+  await tick();
+  assert.equal(pending.status, "fulfilled");
+  assert.equal(pending.value.status, "connected");
+  assert.equal(h.bindings.eventSourceRef.current, stream);
+  return stream;
+}
+
+function assertOutputAndDialog(h, stream) {
+  const message = { role: "assistant", content: [{ type: "text", text: "Replacement runtime is streaming" }] };
+  const request = { type: "extension_ui_request", method: "confirm", id: "approval:r2", title: "Continue?", message: "Approve this step" };
+  stream.frame({ type: "agent_start" });
+  stream.frame({ type: "message_update", message });
+  stream.frame(request);
+  assert.equal(h.state.stream.isStreaming, true);
+  assert.deepEqual(h.state.stream.streamingMessage, message);
+  assert.deepEqual(h.state.ExtensionDialog, request);
+  assert.deepEqual(h.effects.filter(([kind]) => kind === "attention"), [["attention", request]]);
+}
+
+for (const initialId of ["a", "b"]) {
+  test(`expired OPEN ${initialId}→b stream reconnects through b before a prompt and delivers R2 output and UI`, async () => {
+    const h = harness({ sessionId: initialId });
+    const old = await openRuntime(h, initialId);
+    h.replies.push(response({ running: false, state: { sessionId: "b" } }));
+    let promptStarted = false;
+    const sending = track(h.ensureEventsConnected(initialId).then(() => { promptStarted = true; }));
+    await tick();
+    assert.equal(old.readyState, 2, "expiry must close the old source even if it was OPEN");
+    assert.equal(h.sources.length, 2, "expiry must reconnect instead of reusing old OPEN source");
+    assert.equal(h.sources[1].url, "/api/agent/b/events");
+    assert.equal(promptStarted, false);
+    assert.equal(sending.status, "pending");
+    const replacement = h.sources[1];
+    replacement.open();
+    await tick();
+    assert.equal(promptStarted, false, "transport OPEN must not bypass the connected handshake");
+    replacement.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+    await tick();
+    assert.equal(sending.status, "fulfilled");
+    assert.equal(promptStarted, true);
+    assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+    assert.equal(h.bindings.eventSourceRef.current, replacement);
+    assert.deepEqual(h.requests, ["/api/agent/runtime%3Ar1"]);
+    assertOutputAndDialog(h, replacement);
+  });
+}
+
+for (const initialId of ["a", "b"]) {
+  test(`expiry ${initialId}→b settles an old pending handshake immediately`, async () => {
+    const h = harness({ sessionId: initialId });
+    const oldAttempt = track(h.connectEvents(initialId));
+    const old = h.sources[0];
+    h.followSessionIdentity("b", null);
+    await tick();
+    assert.equal(oldAttempt.status, "fulfilled", "cancellation must not wait for the five-second timeout");
+    assert.equal(oldAttempt.value.status, "closed");
+    assert.equal(old.readyState, 2);
+    assert.equal(h.timers.size, 0, "cancelled attempt must clear its timeout");
+    const ensuring = track(h.ensureEventsConnected("b"));
+    assert.equal(h.sources.at(-1).url, "/api/agent/b/events");
+    const replacement = h.sources.at(-1);
+    replacement.open();
+    replacement.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+    await tick();
+    assert.equal(ensuring.status, "fulfilled");
+    assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+  });
+}
+
+for (const phase of ["pending", "open"]) {
+  test(`same-runtime A→B relocation preserves the ${phase} source`, async () => {
+    const h = harness();
+    const connection = track(h.connectEvents("a"));
+    const original = h.sources[0];
+    if (phase === "open") {
+      original.open();
+      original.frame({ type: "connected", sessionId: "a", runtimeId: "runtime:r1" });
+      await tick();
+    }
+    h.followSessionIdentity("b", "runtime:r1");
+    assert.equal(h.bindings.eventSourceRef.current, original);
+    assert.equal(original.closeCount, 0);
+    const ensuring = track(h.ensureEventsConnected("b"));
+    await tick();
+    assert.equal(h.sources.length, 1);
+    if (phase === "pending") {
+      assert.equal(ensuring.status, "pending");
+      original.open();
+      original.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r1" });
+      await tick();
+    }
+    assert.equal(connection.status, "fulfilled");
+    assert.equal(ensuring.status, "fulfilled");
+    assert.equal(h.bindings.sessionIdRef.current, "b");
+    assert.equal(h.bindings.runtimeIdRef.current, "runtime:r1");
+    assert.equal(original.closeCount, 0);
+  });
+}
+
+for (const phase of ["pending", "open"]) {
+  test(`direct R1→R2 replacement invalidates the ${phase} R1 source`, async () => {
+    const h = harness({ sessionId: "b" });
+    const connection = track(h.connectEvents("b"));
+    const old = h.sources[0];
+    if (phase === "open") {
+      old.open();
+      old.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r1" });
+      await tick();
+    }
+    h.followSessionIdentity("b", "runtime:r2");
+    await tick();
+    assert.equal(old.readyState, 2);
+    assert.equal(h.bindings.eventSourceRef.current, null);
+    if (phase === "pending") {
+      assert.equal(connection.status, "fulfilled");
+      assert.equal(connection.value.status, "closed");
+    }
+    const ensuring = track(h.ensureEventsConnected("b"));
+    await tick();
+    const replacement = h.sources.at(-1);
+    assert.equal(replacement.url, "/api/agent/runtime%3Ar2/events");
+    replacement.open();
+    replacement.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+    await tick();
+    assert.equal(ensuring.status, "fulfilled");
+  });
+}
+
+test("queued messages from a superseded source cannot change identity, stream output or dialogs", async () => {
+  const h = harness();
+  const old = await openRuntime(h);
+  h.followSessionIdentity("b", "runtime:r2");
+  const current = await openRuntime(h, "b", "runtime:r2");
+  assertOutputAndDialog(h, current);
+  const before = structuredClone(h.state);
+  h.effects.length = 0;
+  // Keep invoking the detached callback, as a queued browser delivery can do.
+  old.frame({ type: "connected", sessionId: "a", runtimeId: "runtime:r1" });
+  old.frame({ type: "session_changed", sessionId: "stale", runtimeId: "runtime:r1" });
+  old.frame({ type: "agent_start" });
+  old.frame({ type: "message_update", message: { role: "assistant", content: [{ type: "text", text: "stale" }] } });
+  old.frame({ type: "extension_ui_request", method: "confirm", id: "stale", title: "Stale?" });
+  assert.deepEqual(h.effects, []);
+  assert.deepEqual(h.state, before);
+  assert.equal(h.bindings.sessionIdRef.current, "b");
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+  assert.equal(h.bindings.eventSourceRef.current, current);
+});
+
+test("a fresh canonical null→R2 handshake retains its own source", async () => {
+  const h = harness({ sessionId: "b", runtimeId: null });
+  const ensuring = track(h.ensureEventsConnected("b"));
+  const current = h.sources[0];
+  assert.equal(current.url, "/api/agent/b/events");
+  current.open();
+  current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+  await tick();
+  assert.equal(ensuring.status, "fulfilled");
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+  assert.equal(h.bindings.eventSourceRef.current, current);
+  assert.equal(h.bindings.eventSourceRuntimeIdRef.current, "runtime:r2");
+  assert.equal(current.closeCount, 0);
+});
+
+for (const existingAttempt of [false, true]) {
+  test(`${existingAttempt ? "pending reused" : "new"} OPEN stream times out without connected and never admits a prompt`, async () => {
+    const h = harness({ sessionId: "b", runtimeId: null });
+    if (existingAttempt) h.connectEvents("b");
+    const ensuring = track(h.ensureEventsConnected("b"));
+    await tick();
+    const current = h.sources[0];
+    current.open();
+    h.runTimers(5_000);
+    await tick();
+    assert.notEqual(ensuring.status, "fulfilled", "OPEN without a connected frame cannot permit prompting");
+    // A reused failed attempt may be retried once; that replacement must also
+    // complete its own handshake rather than inheriting OPEN from the old one.
+    if (ensuring.status === "pending") {
+      assert.equal(h.sources.length, 2);
+      h.sources[1].open();
+      h.runTimers(5_000);
+      await tick();
+    }
+    assert.equal(ensuring.status, "rejected");
+    assert.equal(ensuring.error.name, "EventStreamConnectionError");
+    assert.equal(ensuring.error.status, "timeout");
+    assert.equal(h.bindings.eventSourceRef.current, null);
+    assert.ok(h.sources.every((stream) => stream.readyState === 2));
+  });
+}
+
+test("closeEvents immediately settles a pending attempt and clears all stream ownership", async () => {
+  const h = harness();
+  const pending = track(h.connectEvents("a"));
+  h.closeEvents();
+  await tick();
+  assert.equal(pending.status, "fulfilled");
+  assert.equal(pending.value.status, "closed");
+  assert.equal(h.bindings.eventSourceRef.current, null);
+  assert.equal(h.bindings.eventSourceSessionIdRef.current, null);
+  assert.equal(h.bindings.eventSourceRuntimeIdRef.current, null);
+  assert.equal(h.bindings.eventConnectionAttemptRef.current, null);
+  assert.equal(h.timers.size, 0);
+});
+
+test("frames delivered after unmount are ignored even before source cleanup", async () => {
+  const h = harness();
+  const current = await openRuntime(h);
+  h.effects.length = 0;
+  h.bindings.mountedRef.current = false;
+  current.frame({ type: "agent_start" });
+  current.frame({ type: "message_update", message: { role: "assistant", content: [{ type: "text", text: "late" }] } });
+  current.frame({ type: "extension_ui_request", method: "confirm", id: "late", title: "Late?" });
+  assert.deepEqual(h.effects, []);
+  assert.equal(h.state.stream.isStreaming, false);
+  assert.equal(h.state.ExtensionDialog, null);
+});
+
+test("unmount cancels a pending ensure and cannot accept a queued connected frame", async () => {
+  const h = harness({ sessionId: "b", runtimeId: null });
+  const ensuring = track(h.ensureEventsConnected("b"));
+  const current = h.sources[0];
+  h.bindings.mountedRef.current = false;
+  h.closeEvents();
+  h.effects.length = 0;
+  current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+  await tick();
+  assert.equal(ensuring.status, "rejected");
+  assert.match(ensuring.error.message, /no longer active/);
+  assert.equal(h.bindings.runtimeIdRef.current, null);
+  assert.deepEqual(h.effects, []);
+  assert.equal(h.timers.size, 0);
+});
+
+test("an ensure already awaiting R1 moves promptly to B after that handshake is cancelled", async () => {
+  const h = harness();
+  const oldAttempt = track(h.connectEvents("a"));
+  const ensuring = track(h.ensureEventsConnected("a"));
+  await tick();
+  assert.equal(ensuring.status, "pending");
+  assert.equal(h.sources.length, 1);
+  h.followSessionIdentity("b", null);
+  await tick();
+  assert.equal(oldAttempt.status, "fulfilled");
+  assert.equal(oldAttempt.value.status, "closed");
+  assert.equal(h.sources.length, 2, "the awaiting ensure must continue without the old timeout");
+  const current = h.sources[1];
+  assert.equal(current.url, "/api/agent/b/events");
+  assert.equal(ensuring.status, "pending");
+  current.open();
+  current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+  await tick();
+  assert.equal(ensuring.status, "fulfilled");
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+  assert.equal(h.timers.size, 0);
+});
+
+test("an OPEN fire-and-forget source that timed out cannot satisfy a later ensure", async () => {
+  const h = harness({ sessionId: "b", runtimeId: null });
+  const attempt = track(h.connectEvents("b"));
+  const old = h.sources[0];
+  old.open();
+  h.runTimers(5_000);
+  await tick();
+  assert.equal(attempt.status, "fulfilled");
+  assert.equal(attempt.value.status, "timeout");
+  const ensuring = track(h.ensureEventsConnected("b"));
+  await tick();
+  assert.equal(ensuring.status, "pending", "a timeout is not a completed connected handshake");
+  assert.equal(h.sources.length, 2);
+  assert.equal(old.readyState, 2);
+  const current = h.sources[1];
+  current.open();
+  current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+  await tick();
+  assert.equal(ensuring.status, "fulfilled");
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+});
+
+for (const connectedAgain of [false, true]) {
+  test(`recoverable error followed by OPEN ${connectedAgain ? "and connected reuses" : "alone cannot reuse"} the source`, async () => {
+    const h = harness({ sessionId: "b" });
+    const original = await openRuntime(h, "b");
+    original.readyState = 0;
+    original.onerror();
+    original.open();
+    if (connectedAgain) original.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r1" });
+    const ensuring = track(h.ensureEventsConnected("b"));
+    await tick();
+    if (connectedAgain) {
+      assert.equal(ensuring.status, "fulfilled");
+      assert.equal(h.sources.length, 1);
+      assert.equal(original.closeCount, 0);
+    } else {
+      assert.equal(ensuring.status, "pending", "a reconnect must establish a fresh connected handshake");
+      assert.equal(h.sources.length, 2);
+      assert.equal(original.readyState, 2);
+      const current = h.sources[1];
+      current.open();
+      current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r1" });
+      await tick();
+      assert.equal(ensuring.status, "fulfilled");
+    }
+  });
+}
+
+for (const transportOpen of [false, true]) {
+  test(`state polling adopts its own ${transportOpen ? "OPEN" : "CONNECTING"} canonical stream and still waits for connected`, async () => {
+    const h = harness({ sessionId: "b", runtimeId: null });
+    let promptStarted = false;
+    const sending = track(h.ensureEventsConnected("b").then(() => { promptStarted = true; }));
+    const current = h.sources[0];
+    if (transportOpen) current.open();
+    const contextUsage = { percent: 20, contextWindow: 1000, tokens: 200 };
+    h.replies.push(response({ running: true, state: { sessionId: "b", runtimeId: "runtime:r2", contextUsage } }));
+    await h.refreshContextUsage("b");
+    await tick();
+    assert.equal(current.closeCount, 0, "the state poll must not cancel its own canonical connection");
+    assert.equal(h.bindings.eventSourceRef.current, current);
+    assert.equal(h.bindings.eventSourceRuntimeIdRef.current, "runtime:r2");
+    assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+    assert.deepEqual(h.state.ContextUsage, contextUsage, "the actual refresh callback must apply the state");
+    assert.equal(sending.status, "pending");
+    assert.equal(promptStarted, false);
+
+    // A second poll is now addressed by R2. It must neither replace the source
+    // nor count runtime discovery as a completed SSE handshake.
+    h.replies.push(response({ running: true, state: { sessionId: "b", runtimeId: "runtime:r2", contextUsage } }));
+    await h.refreshContextUsage("b");
+    await tick();
+    assert.deepEqual(h.requests, ["/api/agent/b", "/api/agent/runtime%3Ar2"]);
+    assert.equal(h.sources.length, 1);
+    assert.equal(current.closeCount, 0);
+    assert.equal(sending.status, "pending");
+    assert.equal(promptStarted, false);
+
+    current.open();
+    current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+    await tick();
+    assert.equal(sending.status, "fulfilled");
+    assert.equal(promptStarted, true);
+    assert.equal(h.bindings.eventSourceRef.current, current);
+    assert.equal(h.sources.length, 1);
+    assert.equal(h.timers.size, 0);
+    assertOutputAndDialog(h, current);
+  });
+}
+
+for (const [label, sourceId, selectedId, incomingId] of [
+  ["a different source label", "a", "b", "b"],
+  ["a newly selected session", "b", "c", "c"],
+  ["a different incoming transcript", "b", "b", "c"],
+]) {
+  test(`state discovery cannot adopt a pending canonical source for ${label}`, async () => {
+    const h = harness({ sessionId: "b", runtimeId: null });
+    const connection = track(h.connectEvents(sourceId));
+    const current = h.sources[0];
+    h.bindings.sessionIdRef.current = selectedId;
+    h.replies.push(response({ running: true, state: { sessionId: incomingId, runtimeId: "runtime:r2" } }));
+    await h.refreshContextUsage(selectedId);
+    await tick();
+    assert.equal(connection.status, "fulfilled");
+    assert.equal(connection.value.status, "closed");
+    assert.equal(current.readyState, 2);
+    assert.equal(h.bindings.eventSourceRef.current, null);
+    assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+    assert.equal(h.bindings.sessionIdRef.current, incomingId);
+    assert.equal(h.timers.size, 0);
+  });
+}
+
+for (const handshakeComplete of [false, true]) {
+  test(`state discovery still invalidates a ${handshakeComplete ? "connected" : "pending"} source already bound to R1`, async () => {
+    const h = harness({ sessionId: "b" });
+    const connection = track(h.connectEvents("b"));
+    const current = h.sources[0];
+    if (handshakeComplete) {
+      current.open();
+      current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r1" });
+      await tick();
+    }
+    h.replies.push(response({ running: true, state: { sessionId: "b", runtimeId: "runtime:r2" } }));
+    await h.refreshContextUsage("b");
+    await tick();
+    assert.deepEqual(h.requests, ["/api/agent/runtime%3Ar1"]);
+    assert.equal(current.readyState, 2);
+    assert.equal(h.bindings.eventSourceRef.current, null);
+    assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+    assert.equal(connection.status, "fulfilled");
+    assert.equal(connection.value.status, handshakeComplete ? "connected" : "closed");
+  });
+}
+
+test("state discovery cannot adopt an unbound source whose pending handshake already timed out", async () => {
+  const h = harness({ sessionId: "b", runtimeId: null });
+  const connection = track(h.connectEvents("b"));
+  const current = h.sources[0];
+  current.open();
+  h.runTimers(5_000);
+  await tick();
+  assert.equal(connection.value.status, "timeout");
+  h.replies.push(response({ running: true, state: { sessionId: "b", runtimeId: "runtime:r2" } }));
+  await h.refreshContextUsage("b");
+  await tick();
+  assert.equal(current.readyState, 2);
+  assert.equal(h.bindings.eventSourceRef.current, null);
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+});
+
+test("a conflicting first handshake after R2 adoption cannot roll back identity or admit a prompt", async () => {
+  const h = harness({ sessionId: "b", runtimeId: null });
+  let promptStarted = false;
+  const sending = track(h.ensureEventsConnected("b").then(() => { promptStarted = true; }));
+  const current = h.sources[0];
+  h.replies.push(response({ running: true, state: { sessionId: "b", runtimeId: "runtime:r2" } }));
+  await h.refreshContextUsage("b");
+  await tick();
+  assert.equal(h.bindings.eventSourceRef.current, current, "R2 discovery must preserve the pending source");
+  assert.equal(sending.status, "pending");
+  h.effects.length = 0;
+  current.open();
+  current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r1" });
+  await tick();
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+  assert.equal(current.readyState, 2);
+  assert.notEqual(sending.status, "fulfilled");
+  assert.equal(promptStarted, false);
+  assert.deepEqual(h.effects, [], "a conflicting handshake must not reach the identity callback");
+});
+
+test("a source initially bound to R2 also rejects a conflicting first R1 handshake", async () => {
+  const h = harness({ sessionId: "b", runtimeId: "runtime:r2" });
+  let promptStarted = false;
+  const sending = track(h.ensureEventsConnected("b").then(() => { promptStarted = true; }));
+  await tick();
+  const current = h.sources[0];
+  assert.equal(current.url, "/api/agent/runtime%3Ar2/events");
+  h.effects.length = 0;
+  current.open();
+  current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r1" });
+  await tick();
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+  assert.equal(current.readyState, 2);
+  assert.notEqual(sending.status, "fulfilled");
+  assert.equal(promptStarted, false);
+  assert.deepEqual(h.effects, []);
+});
+
+test("an adopted source still rejects its conflicting first frame after its promise timed out", async () => {
+  const h = harness({ sessionId: "b", runtimeId: null });
+  const connection = track(h.connectEvents("b"));
+  const current = h.sources[0];
+  current.open();
+  h.replies.push(response({ running: true, state: { sessionId: "b", runtimeId: "runtime:r2" } }));
+  await h.refreshContextUsage("b");
+  await tick();
+  assert.equal(h.bindings.eventSourceRef.current, current);
+  h.runTimers(5_000);
+  await tick();
+  assert.equal(connection.value.status, "timeout");
+  assert.equal(current.closeCount, 0);
+  h.effects.length = 0;
+  current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r1" });
+  await tick();
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+  assert.equal(current.readyState, 2);
+  assert.equal(h.bindings.eventSourceRef.current, null);
+  assert.deepEqual(h.effects, []);
+
+  const ensuring = track(h.ensureEventsConnected("b"));
+  await tick();
+  assert.equal(ensuring.status, "pending");
+  const replacement = h.sources[1];
+  assert.equal(replacement.url, "/api/agent/runtime%3Ar2/events");
+  replacement.open();
+  replacement.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+  await tick();
+  assert.equal(ensuring.status, "fulfilled");
+});
+
+test("a canonical source can discover R3 on a later reconnect after accepting its first R2 handshake", async () => {
+  const h = harness({ sessionId: "b", runtimeId: null });
+  const connection = track(h.connectEvents("b"));
+  const current = h.sources[0];
+  h.replies.push(response({ running: true, state: { sessionId: "b", runtimeId: "runtime:r2" } }));
+  await h.refreshContextUsage("b");
+  await tick();
+  assert.equal(h.bindings.eventSourceRef.current, current);
+  current.open();
+  current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r2" });
+  await tick();
+  assert.equal(connection.value.status, "connected");
+  current.readyState = 0;
+  current.onerror();
+  current.open();
+  current.frame({ type: "connected", sessionId: "b", runtimeId: "runtime:r3" });
+  await tick();
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r3");
+  assert.equal(h.bindings.eventSourceRuntimeIdRef.current, "runtime:r3");
+  assert.equal(h.bindings.eventSourceRef.current, current);
+  assert.equal(current.closeCount, 0);
+  const ensuring = track(h.ensureEventsConnected("b"));
+  await tick();
+  assert.equal(ensuring.status, "fulfilled");
+  assert.equal(h.sources.length, 1);
+});
diff --git a/hooks/useAgentSession.runtime-state.test.mjs b/hooks/useAgentSession.runtime-state.test.mjs
new file mode 100644
index 0000000000..769b1119cc
--- /dev/null
+++ b/hooks/useAgentSession.runtime-state.test.mjs
@@ -0,0 +1,276 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import ts from "typescript";
+
+const source = await readFile(new URL("./useAgentSession.ts", import.meta.url), "utf8");
+const ast = ts.createSourceFile("useAgentSession.ts", source, ts.ScriptTarget.Latest, true);
+const callbacks = new Map();
+function collect(node) {
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)
+    && node.initializer && ts.isCallExpression(node.initializer)
+    && node.initializer.expression.getText(ast) === "useCallback") {
+    callbacks.set(node.name.text, node.initializer.arguments[0].getText(ast));
+  }
+  ts.forEachChild(node, collect);
+}
+collect(ast);
+
+// Execute the production callbacks, stripping only TypeScript syntax. Network,
+// React setters and browser storage are doubles; no copy of the guard logic.
+function callback(name, bindings) {
+  assert.ok(callbacks.has(name), `Missing callback: ${name}`);
+  const { outputText } = ts.transpileModule(`const callback = ${callbacks.get(name)};`, {
+    compilerOptions: { target: ts.ScriptTarget.ES2022 },
+  });
+  return new Function(...Object.keys(bindings), `${outputText}\nreturn callback;`)(...Object.values(bindings));
+}
+
+const response = (data) => ({ ok: true, json: async () => data });
+const live = (runtimeId = "runtime:r2") => ({ sessionId: "b", runtimeId, isStreaming: true });
+const deferred = () => {
+  let resolve;
+  const promise = new Promise((done) => { resolve = done; });
+  return { promise, resolve };
+};
+
+function harness() {
+  const effects = [];
+  const continuation = { current: { sessionId: "b", runtimeId: "runtime:r1" } };
+  const bindings = {
+    mountedRef: { current: true },
+    sessionIdRef: { current: "b" },
+    runtimeIdRef: { current: "runtime:r1" },
+    identityDraftKeyRef: { current: "b" },
+    contextRequestRef: { current: 0 },
+    eventSourceRef: { current: null },
+    eventSourceSessionIdRef: { current: "b" },
+    eventSourceRuntimeIdRef: { current: "runtime:r1" },
+    closeEvents: () => {},
+    historyRequestRef: { current: 0 },
+    contextUsageRequestIdRef: { current: 0 },
+    promptRunIdRef: { current: 1 },
+    bashRecoveryIdRef: { current: 0 },
+    agentRunningRef: { current: true },
+    bashRunningRef: { current: true },
+    modelSwitchPendingRef: { current: false },
+    opts: {},
+    onSessionForked: (...args) => effects.push(["identity", ...args]),
+    rememberSessionContinuation: (sessionId, runtimeId) => { continuation.current = { sessionId, runtimeId }; },
+    clearSessionContinuation: (_sessionId, runtimeId) => {
+      if (continuation.current?.runtimeId === runtimeId) continuation.current = null;
+      effects.push(["clear", runtimeId]);
+    },
+    normalizeQueuedMessages: (queue) => queue ?? { steering: [], followUp: [] },
+    mergeSubagentSnapshots: (_current, incoming) => incoming,
+    finishPromptWithoutStream: async (...args) => effects.push(["finish", ...args]),
+    loadSession: async (...args) => effects.push(["history", ...args]),
+    dispatch: (...args) => effects.push(["dispatch", ...args]),
+    delay: async () => {},
+    PROMPT_SETTLE_INITIAL_DELAY_MS: 1,
+    PROMPT_SETTLE_POLL_MS: 1,
+    PROMPT_SETTLE_MAX_MS: 1000,
+    BASH_STATE_RECONCILE_MS: 1,
+  };
+  for (const name of ["Loading", "Data", "ActiveLeafId", "Messages", "EntryIds", "Error",
+    "ContextUsage", "CurrentModelOverride", "SystemPrompt", "ThinkingLevel", "EffectiveThinkingLevel",
+    "ExtensionStatuses", "ExtensionWidgets", "QueuedMessages", "Subagents", "IsCompacting",
+    "AgentPhase", "RetryInfo", "GoalStatus", "BashRunning", "PendingBash"]) {
+    bindings[`set${name}`] = (...args) => effects.push([name, ...args]);
+  }
+  bindings.followSessionIdentity = callback("followSessionIdentity", bindings);
+  bindings.followRuntimeState = callback("followRuntimeState", bindings);
+  return { bindings, effects, continuation };
+}
+
+function installNewRuntime(h) {
+  assert.equal(h.bindings.followRuntimeState(live(), "b", "runtime:r1"), false);
+  h.effects.length = 0;
+}
+
+function assertNewRuntime(h) {
+  assert.equal(h.bindings.runtimeIdRef.current, "runtime:r2");
+  assert.deepEqual(h.continuation.current, { sessionId: "b", runtimeId: "runtime:r2" });
+  assert.equal(h.effects.some(([kind]) => kind === "clear" || kind === "identity"), false);
+}
+
+for (const [label, state] of [
+  ["tombstone", { sessionId: "b" }],
+  ["old live identity", { sessionId: "b", runtimeId: "runtime:r1" }],
+  ["missing state", undefined],
+]) {
+  test(`rejects a superseded runtime's ${label}`, () => {
+    const h = harness();
+    installNewRuntime(h);
+    assert.equal(h.bindings.followRuntimeState(state, "b", "runtime:r1"), true);
+    assertNewRuntime(h);
+  });
+}
+
+test("accepts owned expiry, reopening and same-runtime relocation", () => {
+  const h = harness();
+  assert.equal(h.bindings.followRuntimeState({ sessionId: "c", runtimeId: "runtime:r1" }, "b", "runtime:r1"), false);
+  assert.equal(h.bindings.sessionIdRef.current, "c");
+  assert.equal(h.bindings.followRuntimeState({ sessionId: "c" }, "c", "runtime:r1"), false);
+  assert.equal(h.bindings.runtimeIdRef.current, null);
+  assert.equal(h.continuation.current, null);
+  assert.equal(h.bindings.followRuntimeState({ sessionId: "c", runtimeId: "runtime:r2" }, "c", null), false);
+  assert.deepEqual(h.continuation.current, { sessionId: "c", runtimeId: "runtime:r2" });
+});
+
+test("ignores responses after unmount or another session selection", () => {
+  for (const change of [(b) => { b.mountedRef.current = false; }, (b) => { b.sessionIdRef.current = "other"; }]) {
+    const h = harness();
+    change(h.bindings);
+    assert.equal(h.bindings.followRuntimeState(live(), "b", "runtime:r1"), true);
+    assert.equal(h.bindings.runtimeIdRef.current, "runtime:r1");
+    assert.deepEqual(h.effects, []);
+  }
+});
+
+test("mount history loading drops the entire stale state response", async () => {
+  const h = harness();
+  const pending = deferred();
+  const requested = deferred();
+  h.bindings.fetch = async (url) => {
+    if (url.startsWith("/api/sessions/")) return response({
+      sessionId: "b", runtimeId: "runtime:r1", leafId: null,
+      context: { messages: [], entryIds: [], thinkingLevel: "off" },
+    });
+    assert.equal(url, "/api/agent/runtime%3Ar1");
+    requested.resolve();
+    return pending.promise;
+  };
+  const loading = callback("loadSession", h.bindings)("b", false, true);
+  await requested.promise;
+  installNewRuntime(h);
+  pending.resolve(response({ running: false, state: { sessionId: "b" } }));
+  assert.equal(await loading, null);
+  assertNewRuntime(h);
+  assert.deepEqual(h.effects.filter(([name]) => name !== "Loading"), []);
+});
+
+for (const name of ["reconcileAgentState", "refreshContextUsage", "handleAgentEvent"]) {
+  test(`${name} ignores a delayed old-runtime state body`, async () => {
+    const h = harness();
+    const pending = deferred();
+    const requested = deferred();
+    h.bindings.fetch = async (url) => {
+      assert.equal(url, "/api/agent/runtime%3Ar1");
+      requested.resolve();
+      // Hold json(), not just fetch(), to cover ownership across body parsing.
+      return { ok: true, json: () => pending.promise };
+    };
+    const fn = callback(name, h.bindings);
+    const result = fn(name === "handleAgentEvent" ? { type: "agent_end" } : "b");
+    await requested.promise;
+    installNewRuntime(h);
+    pending.resolve({ running: false, state: { sessionId: "b", contextUsage: { percent: 99 } } });
+    await result;
+    await new Promise((resolve) => setImmediate(resolve));
+    assertNewRuntime(h);
+    assert.deepEqual(h.effects, []);
+  });
+}
+
+test("a superseded preflight keeps the new runtime for the event handshake", async () => {
+  const h = harness();
+  const pending = deferred();
+  h.bindings.fetch = async () => pending.promise;
+  h.bindings.EventSource = { OPEN: 1 };
+  h.bindings.eventSourceRef = { current: null };
+  h.bindings.eventConnectionAttemptRef = { current: null };
+  h.bindings.connectEvents = async (sid) => {
+    h.effects.push(["connect", sid, h.bindings.runtimeIdRef.current]);
+    const source = { readyState: 1 };
+    h.bindings.eventSourceRef.current = source;
+    return { source, status: "connected" };
+  };
+  const connecting = callback("ensureEventsConnected", h.bindings)("b");
+  installNewRuntime(h);
+  pending.resolve(response({ running: false, state: { sessionId: "b" } }));
+  await connecting;
+  assertNewRuntime(h);
+  assert.deepEqual(h.effects, [["connect", "b", "runtime:r2"]]);
+});
+
+test("grace cleanup retries the current runtime instead of closing from a stale idle response", async () => {
+  const h = harness();
+  const timers = [];
+  const requests = [];
+  const pending = deferred();
+  Object.assign(h.bindings, {
+    cancelEventStreamGrace: () => {},
+    eventStreamGraceActiveRef: { current: false },
+    eventStreamGraceGenerationRef: { current: 1 },
+    eventStreamGraceTimerRef: { current: null },
+    sdkAgentActiveRef: { current: false },
+    rpcPromptPendingRef: { current: false },
+    setAgentRunning: () => {},
+    closeEvents: () => h.effects.push(["close"]),
+    setTimeout: (fn) => { timers.push(fn); return timers.length; },
+    EVENT_STREAM_IDLE_GRACE_MS: 30_000,
+    CONTEXT_USAGE_REFRESH_MS: 1,
+    fetch: async (url) => {
+      requests.push(url);
+      return requests.length === 1 ? pending.promise : response({ running: true, state: live() });
+    },
+  });
+  callback("scheduleEventStreamClose", h.bindings)("b");
+  timers.shift()();
+  installNewRuntime(h);
+  pending.resolve(response({ running: false, state: { sessionId: "b" } }));
+  await new Promise((resolve) => setImmediate(resolve));
+  assertNewRuntime(h);
+  assert.deepEqual(h.effects, []);
+  assert.equal(timers.length, 1, "must not abandon the grace check after ignoring a response");
+  timers.shift()();
+  await new Promise((resolve) => setImmediate(resolve));
+  assertNewRuntime(h);
+  assert.deepEqual(requests, ["/api/agent/runtime%3Ar1", "/api/agent/runtime%3Ar2"]);
+  assert.equal(h.effects.some(([kind]) => kind === "close"), false);
+  assert.equal(h.bindings.sdkAgentActiveRef.current, true);
+  assert.equal(timers.length, 0);
+});
+
+for (const name of ["waitForPromptSettlement", "waitForBashSettlement"]) {
+  test(`${name} retries R2 before settling after a delayed R1 tombstone`, async () => {
+    const h = harness();
+    const pending = deferred();
+    const requested = deferred();
+    const requests = [];
+    h.bindings.fetch = async (url) => {
+      requests.push(url);
+      if (requests.length === 1) { requested.resolve(); return pending.promise; }
+      assertNewRuntime(h);
+      assert.deepEqual(h.effects, []);
+      return response({ running: true, state: { sessionId: "b", runtimeId: "runtime:r2" } });
+    };
+    const settling = callback(name, h.bindings)("b", 1);
+    await requested.promise;
+    installNewRuntime(h);
+    pending.resolve(response({ running: false, state: { sessionId: "b" } }));
+    await settling;
+    assertNewRuntime(h);
+    assert.deepEqual(requests, ["/api/agent/runtime%3Ar1", "/api/agent/runtime%3Ar2"]);
+    assert.ok(h.effects.some(([kind]) => kind === (name === "waitForPromptSettlement" ? "finish" : "history")));
+  });
+
+  for (const superseded of ["unmounted", "new run"]) {
+    test(`${name} drops an in-flight response when ${superseded}`, async () => {
+      const h = harness();
+      const pending = deferred();
+      const requested = deferred();
+      h.bindings.fetch = async () => { requested.resolve(); return pending.promise; };
+      const settling = callback(name, h.bindings)("b", 1);
+      await requested.promise;
+      if (superseded === "unmounted") h.bindings.mountedRef.current = false;
+      else if (name === "waitForPromptSettlement") h.bindings.promptRunIdRef.current += 1;
+      else h.bindings.bashRecoveryIdRef.current += 1;
+      pending.resolve(response({ running: false, state: { sessionId: "b" } }));
+      await settling;
+      assert.equal(h.bindings.runtimeIdRef.current, "runtime:r1");
+      assert.deepEqual(h.effects, []);
+    });
+  }
+}
diff --git a/hooks/useAgentSession.test.mjs b/hooks/useAgentSession.test.mjs
index 182ca53e66..480aed3131 100644
--- a/hooks/useAgentSession.test.mjs
+++ b/hooks/useAgentSession.test.mjs
@@ -39,14 +39,14 @@ test("keeps the session event stream open through the idle grace window", () =>
 
   assert.match(source, /const EVENT_STREAM_IDLE_GRACE_MS = 30_000/);
   assert.match(graceSource, /setTimeout\(\(\) => void checkServerIdle\(\), EVENT_STREAM_IDLE_GRACE_MS\)/);
-  assert.match(graceSource, /fetch\(`\/api\/agent\/\$\{encodeURIComponent\(sid\)\}`\)/);
+  assert.match(graceSource, /fetch\(`\/api\/agent\/\$\{encodeURIComponent\(requestedRuntimeId \?\? sid\)\}`\)/);
   assert.match(graceSource, /closeEvents\(\)/);
   assert.match(finishSource, /scheduleEventStreamClose\(sid\)/);
   assert.doesNotMatch(finishSource, /closeEvents\(\)/);
   assert.doesNotMatch(agentEndSource, /closeEvents\(\)/);
   assert.match(agentStartSource, /cancelEventStreamGrace\(\)/);
   assert.match(agentSettledSource, /scheduleEventStreamClose\(sid\)/);
-  assert.match(agentSettledSource, /onAgentEnd\?\.\(\)/);
+  assert.match(agentSettledSource, /onAgentEnd\?\.\(sessionIdRef\.current \?\? undefined\)/);
   assert.match(promptDoneSource, /notifyPromptStage\(runId\)/);
   assert.match(promptDoneSource, /scheduleEventStreamClose\(sid\)/);
   assert.match(sendSource, /const definitivelyRejected = !promptRequestStarted \|\| isPromptRejectedError\(e\)/);
@@ -170,11 +170,11 @@ test("/handoff forwards the focus text verbatim and keeps the UI busy", () => {
   assert.match(handoffCaseSource, /complete\(\{ handled: true, error: "Handoff cancelled" \}\)/);
   assert.doesNotMatch(handoffCaseSource, /execute_slash_command/);
   assert.doesNotMatch(handoffCaseSource, /type: "prompt"/);
-  const connectIndex = handoffCaseSource.indexOf("await ensureEventsConnected(sid)");
+  const connectIndex = handoffCaseSource.indexOf("await ensureEventsConnected(sessionIdRef.current ?? sid)");
   const dispatchIndex = handoffCaseSource.indexOf('type: "handoff"');
   assert.ok(connectIndex >= 0);
   assert.ok(dispatchIndex > connectIndex);
-  assert.match(handoffCaseSource, /scheduleEventStreamClose\(sid\)/);
+  assert.match(handoffCaseSource, /scheduleEventStreamClose\(finalSid\)/);
 });
 
 test("/handoff reloads the same session after an in-place compaction", () => {
@@ -191,7 +191,7 @@ test("/handoff reloads the same session after an in-place compaction", () => {
   // reloads this transcript instead of navigating to a replacement session.
   assert.doesNotMatch(handoffCaseSource, /newSessionId/);
   assert.doesNotMatch(handoffCaseSource, /onSessionForked/);
-  assert.match(handoffCaseSource, /if \(await loadSession\(sid, true\)\) promoteNewSession\(\);/);
+  assert.match(handoffCaseSource, /loadSession\(sessionIdRef\.current \?\? currentSid, true\)/);
   // Every branch returns handled so the command never reaches the SDK
   // fallback — the busy state is torn down in a finally block and the case
   // yields to the default bridge with a return.
diff --git a/hooks/useAgentSession.ts b/hooks/useAgentSession.ts
index 90a5a6b2e9..b7bda1d7e1 100644
--- a/hooks/useAgentSession.ts
+++ b/hooks/useAgentSession.ts
@@ -1,6 +1,6 @@
 "use client";
 
-import { useState, useCallback, useRef, useEffect, useMemo, useReducer } from "react";
+import { useState, useCallback, useRef, useEffect, useLayoutEffect, useMemo, useReducer } from "react";
 import type {
   AgentMessage,
   BlockingExtensionUiRequest,
@@ -15,12 +15,14 @@ import type {
 import { isBlockingExtensionUiRequest } from "@/lib/browser-notifications";
 import { normalizeToolCalls } from "@/lib/normalize";
 import { stripAnsi } from "@/lib/ansi";
-import { isPromptRejectedError, sendAgentCommand } from "@/lib/agent-client";
+import { canApplySessionIdentity, isPromptRejectedError, sendAgentCommand, type RuntimeSessionBinding } from "@/lib/agent-client";
+import { rememberSessionContinuation, clearSessionContinuation } from "@/lib/workspace-memory";
 import { getToolNamesForPreset, type ToolEntry } from "@/lib/tool-presets";
 import type { ContextUsage, GoalStatusInfo, SessionStatsInfo, SlashCommandInfo } from "@/lib/omp-types";
 import type { ModelRoleAssignment } from "@/lib/api-types";
 
 export interface SessionData {
+  runtimeId?: string;
   sessionId: string;
   filePath: string;
   totalActiveMs: number;
@@ -76,6 +78,9 @@ interface LastAssistantTextResponse {
 }
 
 type AgentStateResponse = {
+  runtimeId?: string;
+  sessionId?: string;
+  model?: { provider: string; id: string };
   contextUsage?: { percent: number | null; contextWindow: number; tokens: number | null } | null;
   systemPrompt?: string;
   thinkingLevel?: string;
@@ -167,10 +172,10 @@ export type BuiltinSlashCommandResult =
 export interface UseAgentSessionOptions {
   session: SessionInfo | null;
   newSessionCwd: string | null;
-  onAgentEnd?: () => void;
+  onAgentEnd?: (sessionId?: string) => void;
   onAttentionNeeded?: (request: BlockingExtensionUiRequest) => void;
   onSessionCreated?: (session: SessionInfo) => void;
-  onSessionForked?: (newSessionId: string) => void;
+  onSessionForked?: (newSessionId: string, runtimeId?: string | null) => void;
   modelsRefreshKey?: number;
   chatInputRef?: React.RefObject<ChatInputHandle | null>;
   onBranchDataChange?: (tree: SessionTreeNode[], activeLeafId: string | null, onLeafChange: (leafId: string | null) => void) => void;
@@ -208,6 +213,8 @@ type EventStreamConnectionAttempt = {
   source: EventSource;
   promise: Promise<EventStreamConnectionResult>;
   pending: boolean;
+  connected: boolean;
+  cancel: () => void;
 };
 
 class EventStreamConnectionError extends Error {
@@ -336,6 +343,7 @@ export interface ChatInputHandle {
   prependText: (text: string) => void;
   addImages: (files: File[]) => void;
   restoreSubmission: (text: string, images?: Array<{ data: string; mimeType: string }>, targetDraftKey?: string) => void;
+  rekeyDraft?: (previousKey: string, nextKey: string) => void;
 }
 
 export interface AttachedImage {
@@ -416,11 +424,26 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
 
   const eventSourceRef = useRef<EventSource | null>(null);
   const eventSourceSessionIdRef = useRef<string | null>(null);
+  const eventSourceRuntimeIdRef = useRef<string | null>(null);
   const eventConnectionAttemptRef = useRef<EventStreamConnectionAttempt | null>(null);
   const eventStreamGraceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const eventStreamGraceGenerationRef = useRef(0);
   const eventStreamGraceActiveRef = useRef(false);
   const sessionIdRef = useRef<string | null>(session?.id ?? null);
+  const runtimeIdRef: RuntimeSessionBinding = useRef(session?.runtimeId ?? null);
+  const historyRequestRef = useRef(0);
+  const contextRequestRef = useRef(0);
+  const mountedRef = useRef(false);
+  const identityDraftKeyRef = useRef<string | undefined>(undefined);
+  useLayoutEffect(() => {
+    mountedRef.current = true;
+    if (session) {
+      sessionIdRef.current = session.id;
+      runtimeIdRef.current = session.runtimeId ?? null;
+    }
+    identityDraftKeyRef.current = session?.id ?? (newSessionCwd ? `new:${newSessionCwd}` : undefined);
+    return () => { mountedRef.current = false; };
+  }, [session?.id, session?.runtimeId, newSessionCwd]);
   const agentRunningRef = useRef(false);
   const sdkAgentActiveRef = useRef(false);
   const rpcPromptPendingRef = useRef(false);
@@ -495,14 +518,87 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     } satisfies SessionStatsInfo;
   }, [messages, sessionStatsOverride, contextUsage, data?.filePath, data?.totalActiveMs, session?.id, session?.name]);
 
+  const closeEvents = useCallback(() => {
+    const source = eventSourceRef.current;
+    const attempt = eventConnectionAttemptRef.current;
+    eventSourceRef.current = null;
+    eventSourceSessionIdRef.current = null;
+    eventSourceRuntimeIdRef.current = null;
+    eventConnectionAttemptRef.current = null;
+    attempt?.cancel();
+    source?.close();
+  }, []);
+
+  const followSessionIdentity = useCallback((nextId: string, runtimeId?: string | null) => {
+    if (!mountedRef.current) return;
+    const previousRuntimeId = runtimeIdRef.current;
+    const handleChanged = runtimeId !== undefined && runtimeId !== previousRuntimeId;
+    // A source belongs to one live wrapper, not merely its transcript ID. An
+    // expired wrapper can keep heartbeating, so OPEN alone cannot prove reuse is
+    // safe. Same-runtime relocations retain their source and pending handshake.
+    if (runtimeId !== undefined && eventSourceRef.current
+      && eventSourceRuntimeIdRef.current !== runtimeId) {
+      const attempt = eventConnectionAttemptRef.current;
+      // State polling can discover a canonical connection's new wrapper before
+      // its first frame arrives. Adopt that expected binding without declaring
+      // the handshake ready; known/expired or unrelated sources still retire.
+      if (runtimeId !== null && previousRuntimeId === null && eventSourceRuntimeIdRef.current === null
+        && nextId === sessionIdRef.current && eventSourceSessionIdRef.current === nextId
+        && attempt?.source === eventSourceRef.current && attempt.pending) {
+        eventSourceRuntimeIdRef.current = runtimeId;
+      } else {
+        closeEvents();
+      }
+    }
+    if (runtimeId !== undefined) runtimeIdRef.current = runtimeId;
+    if (runtimeId === null && previousRuntimeId) clearSessionContinuation(undefined, previousRuntimeId);
+    if (runtimeIdRef.current) rememberSessionContinuation(nextId, runtimeIdRef.current);
+    if (nextId === sessionIdRef.current) {
+      if (handleChanged || runtimeId === null) onSessionForked?.(nextId, runtimeId);
+      return;
+    }
+    // Async sends awaiting the SSE handshake must use the new ID immediately;
+    // React state alone leaves pending callbacks pointing at historical IDs.
+    if (identityDraftKeyRef.current) {
+      opts.chatInputRef?.current?.rekeyDraft?.(identityDraftKeyRef.current, nextId);
+    }
+    contextRequestRef.current += 1;
+    identityDraftKeyRef.current = nextId;
+    sessionIdRef.current = nextId;
+    if (eventSourceRef.current) eventSourceSessionIdRef.current = nextId;
+    onSessionForked?.(nextId, runtimeId === null ? null : runtimeIdRef.current ?? undefined);
+  }, [closeEvents, onSessionForked, opts.chatInputRef]);
+
+  runtimeIdRef.onIdentity = (identity, request) => {
+    if (!mountedRef.current || !sessionIdRef.current) return false;
+    const current = { sessionId: sessionIdRef.current, runtimeId: runtimeIdRef.current };
+    if (!canApplySessionIdentity(current, identity, request)) return false;
+    followSessionIdentity(identity.sessionId, identity.runtimeId);
+    return true;
+  };
+
+  const followRuntimeState = useCallback((state: AgentStateResponse | undefined, requestedId: string, requestedRuntimeId: string | null) => {
+    // A response from an expired handle can arrive after another request has
+    // installed its replacement for the same transcript. Drop all stale state,
+    // including idle flags, rather than clearing or settling that newer runtime.
+    if (!mountedRef.current || sessionIdRef.current !== requestedId
+      || runtimeIdRef.current !== requestedRuntimeId) return true;
+    if (state?.sessionId) {
+      followSessionIdentity(state.sessionId, state.runtimeId ?? null);
+    }
+    return false;
+  }, [followSessionIdentity]);
+
   const loadSession = useCallback(async (sid: string, showLoading = false, includeState = false) => {
+    const requestId = ++historyRequestRef.current;
+    const ownsHistory = () => mountedRef.current && sessionIdRef.current === sid && historyRequestRef.current === requestId;
     let messagesLoaded = false;
     try {
       if (showLoading) setLoading(true);
       const params = new URLSearchParams({ deferThinking: "1", deferMedia: "1" });
       const res = await fetch(`/api/sessions/${encodeURIComponent(sid)}?${params}`);
       if (res.status === 404) {
-        if (showLoading) {
+        if (showLoading && ownsHistory()) {
           setData(null);
           setActiveLeafId(null);
           setMessages([]);
@@ -512,7 +608,11 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       }
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const d = await res.json() as SessionData;
-      if (sessionIdRef.current !== sid) return null;
+      if (!ownsHistory()) return null;
+      if (d.runtimeId || d.sessionId !== sid) {
+        followSessionIdentity(d.sessionId, d.runtimeId);
+        sid = d.sessionId;
+      }
       setData(d);
       setActiveLeafId(d.leafId);
       setMessages(d.context.messages);
@@ -528,12 +628,17 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       if (!includeState) return null;
 
       try {
-        const stateRes = await fetch(`/api/sessions/${encodeURIComponent(sid)}/state`);
+        const requestedRuntimeId = runtimeIdRef.current;
+        const stateRes = await fetch(requestedRuntimeId
+          ? `/api/agent/${encodeURIComponent(requestedRuntimeId)}`
+          : `/api/sessions/${encodeURIComponent(sid)}/state`);
         if (!stateRes.ok) throw new Error(`HTTP ${stateRes.status}`);
         const agentState = await stateRes.json() as { running: boolean; state?: AgentStateResponse };
-        if (sessionIdRef.current !== sid) return null;
+        if (!mountedRef.current || sessionIdRef.current !== sid) return null;
 
         const liveState = agentState.state;
+        if (followRuntimeState(liveState, sid, requestedRuntimeId)) return null;
+        if (!agentState.running && liveState?.sessionId) runtimeIdRef.current = null;
         if (liveState) {
           if (liveState.contextUsage !== undefined) setContextUsage(liveState.contextUsage ?? null);
           if (liveState.systemPrompt !== undefined) setSystemPrompt(liveState.systemPrompt ?? null);
@@ -554,35 +659,45 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         return null;
       }
     } catch (e) {
-      setError(String(e));
+      if (ownsHistory()) setError(String(e));
       return null;
     } finally {
-      if (showLoading && !messagesLoaded) setLoading(false);
+      if (ownsHistory() && (showLoading || messagesLoaded)) setLoading(false);
     }
-  }, []);
+  }, [followSessionIdentity, followRuntimeState, onSessionForked]);
 
   const loadContext = useCallback(async (sid: string, leafId: string | null) => {
+    const requestId = ++contextRequestRef.current;
+    const requestedRuntimeId = runtimeIdRef.current;
+    const ownsContext = () => mountedRef.current && sessionIdRef.current === sid
+      && contextRequestRef.current === requestId && runtimeIdRef.current === requestedRuntimeId;
     try {
       const params = new URLSearchParams({ deferThinking: "1", deferMedia: "1" });
       if (leafId) params.set("leafId", leafId);
-      const url = `/api/sessions/${encodeURIComponent(sid)}/context?${params}`;
+      const url = `/api/sessions/${encodeURIComponent(requestedRuntimeId ?? sid)}/context?${params}`;
       const res = await fetch(url);
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const d = await res.json() as {
+        sessionId?: string;
+        runtimeId?: string | null;
         context: { messages: AgentMessage[]; entryIds: string[] };
         contextUsage?: ContextUsage;
       };
+      if (!ownsContext()) return false;
+      if (d.sessionId) followSessionIdentity(d.sessionId, d.runtimeId ?? null);
       setMessages(d.context.messages);
       setEntryIds(d.context.entryIds ?? []);
       setContextUsage(d.contextUsage ?? null);
+      return true;
     } catch (e) {
-      console.error("Failed to load context:", e);
+      if (ownsContext()) console.error("Failed to load context:", e);
+      return false;
     }
-  }, []);
+  }, [followSessionIdentity]);
 
   const loadTools = useCallback(async (sid: string) => {
     try {
-      const tools = await sendAgentCommand<ToolEntry[]>(sid, { type: "get_tools" });
+      const tools = await sendAgentCommand<ToolEntry[]>(sid, { type: "get_tools" }, runtimeIdRef);
       if (tools) {
         const { getPresetFromTools } = await import("@/lib/tool-presets");
         setToolPresetState(getPresetFromTools(tools));
@@ -594,10 +709,11 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
 
   const promoteNewSession = useCallback((messageCount = 0, firstMessage = "(no messages)") => {
     const sid = sessionIdRef.current;
-    if (!isNew || !newSessionCwd || !sid || newSessionPromotedRef.current) return;
+    if (!mountedRef.current || !isNew || !newSessionCwd || !sid || newSessionPromotedRef.current) return;
     newSessionPromotedRef.current = true;
     onSessionCreated?.({
       id: sid,
+      runtimeId: runtimeIdRef.current ?? undefined,
       path: "",
       cwd: newSessionCwd,
       name: undefined,
@@ -637,12 +753,16 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const result = await res.json() as {
         sessionId: string;
+        runtimeId?: string;
         model?: SelectedModel | null;
         thinkingLevel?: ThinkingLevelOption;
         configuredThinkingLevel?: ThinkingLevelOption;
       };
+      if (!mountedRef.current) return null;
       const realId = result.sessionId;
       sessionIdRef.current = realId;
+      runtimeIdRef.current = result.runtimeId ?? null;
+      if (result.runtimeId) rememberSessionContinuation(realId, result.runtimeId);
       if (result.model && newSessionModelOverrideRef.current === selectedModel) {
         setPendingModel(result.model);
         if (!selectedModel) setNewSessionDefaultModel(result.model);
@@ -673,7 +793,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     }
     setSlashCommandsLoading(true);
     try {
-      const data = await sendAgentCommand<SlashCommandsResponse>(sid, { type: "get_commands" });
+      const data = await sendAgentCommand<SlashCommandsResponse>(sid, { type: "get_commands" }, runtimeIdRef);
       const commands = data?.commands ?? [];
       setSlashCommands(commands);
       return commands;
@@ -695,21 +815,18 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     }
   }, []);
 
-  const closeEvents = useCallback(() => {
-    eventSourceRef.current?.close();
-    eventSourceRef.current = null;
-    eventSourceSessionIdRef.current = null;
-    eventConnectionAttemptRef.current = null;
-  }, []);
-
   const connectEvents = useCallback((sid: string): Promise<EventStreamConnectionResult> => {
+    if (!mountedRef.current) return Promise.reject(new Error("Session is no longer active"));
     closeEvents();
-    const es = new EventSource(`/api/agent/${encodeURIComponent(sid)}/events`);
+    const es = new EventSource(`/api/agent/${encodeURIComponent(runtimeIdRef.current ?? sid)}/events`);
     eventSourceRef.current = es;
     eventSourceSessionIdRef.current = sid;
+    eventSourceRuntimeIdRef.current = runtimeIdRef.current;
 
+    let cancel = () => {};
     const promise = new Promise<EventStreamConnectionResult>((resolve) => {
       let settled = false;
+      let receivedConnected = false;
       const settle = (status: EventStreamConnectionStatus) => {
         if (settled) return;
         settled = true;
@@ -720,17 +837,38 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         resolve({ status, source: es });
       };
       const timeout = setTimeout(() => settle("timeout"), EVENT_STREAM_CONNECT_TIMEOUT_MS);
+      cancel = () => settle("closed");
 
       es.onmessage = (e) => {
+        if (!mountedRef.current || eventSourceRef.current !== es) return;
         try {
           const event = JSON.parse(e.data) as AgentEvent;
-          if (event.type === "connected") settle("connected");
+          // A canonical-ID connection may create a new runtime. Bind its first
+          // frame before following identity so we do not close that fresh source.
+          if (event.type === "connected" && typeof event.runtimeId === "string") {
+            // A poll may have adopted an expected runtime while this source was
+            // unbound. Reject a contradictory first frame, even after timeout,
+            // instead of rolling the selected runtime back to another wrapper.
+            const expectedRuntimeId = eventSourceRuntimeIdRef.current;
+            if (!receivedConnected && expectedRuntimeId !== null && event.runtimeId !== expectedRuntimeId) {
+              closeEvents();
+              return;
+            }
+            eventSourceRuntimeIdRef.current = event.runtimeId;
+          }
+          if (event.type === "connected") receivedConnected = true;
+          if (event.type === "connected" && eventConnectionAttemptRef.current?.source === es) {
+            eventConnectionAttemptRef.current.connected = true;
+          }
           handleAgentEventRef.current?.(event);
+          if (event.type === "connected") settle("connected");
         } catch {
           // ignore
         }
       };
       es.onerror = () => {
+        if (!mountedRef.current || eventSourceRef.current !== es) return;
+        if (eventConnectionAttemptRef.current?.source === es) eventConnectionAttemptRef.current.connected = false;
         if (es.readyState === EventSource.CLOSED) {
           // Fatal error (404/500/content-type mismatch): browser won't
           // auto-reconnect. Settle the Promise and manually reconnect for
@@ -739,11 +877,13 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
           if (eventSourceRef.current === es && (agentRunningRef.current || eventStreamGraceActiveRef.current)) {
             eventSourceRef.current = null;
             eventSourceSessionIdRef.current = null;
+            eventSourceRuntimeIdRef.current = null;
             eventConnectionAttemptRef.current = null;
             const reconnectGeneration = eventStreamGraceGenerationRef.current;
             setTimeout(() => {
               if (
-                reconnectGeneration === eventStreamGraceGenerationRef.current
+                mountedRef.current
+                && reconnectGeneration === eventStreamGraceGenerationRef.current
                 && !eventSourceRef.current
                 && (agentRunningRef.current || eventStreamGraceActiveRef.current)
               ) {
@@ -757,29 +897,55 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         // connection must be ready before they continue.
       };
     });
-    eventConnectionAttemptRef.current = { source: es, promise, pending: true };
+    eventConnectionAttemptRef.current = { source: es, promise, pending: true, connected: false, cancel };
     return promise;
   }, [closeEvents]);
 
   const ensureEventsConnected = useCallback(async (sid: string) => {
+    if (!mountedRef.current) throw new Error("Session is no longer active");
+    const requestedRuntimeId = runtimeIdRef.current;
+    if (requestedRuntimeId) {
+      const stateRes = await fetch(`/api/agent/${encodeURIComponent(requestedRuntimeId)}`);
+      if (stateRes.ok) {
+        const state = await stateRes.json() as { running?: boolean; state?: AgentStateResponse };
+        if (!mountedRef.current || sessionIdRef.current !== sid) throw new Error("Session is no longer active");
+        const stale = followRuntimeState(state.state, sid, requestedRuntimeId);
+        if (!stale && !state.running) {
+          if (!state.state?.sessionId) throw new Error("Runtime identity expired; reopen the intended session");
+          runtimeIdRef.current = null;
+        }
+        sid = sessionIdRef.current ?? sid;
+      }
+    }
+    if (!mountedRef.current) throw new Error("Session is no longer active");
     const current = eventSourceRef.current;
-    if (current && eventSourceSessionIdRef.current === sid) {
-      if (current.readyState === EventSource.OPEN) return;
+    if (current && eventSourceSessionIdRef.current === sid
+      && eventSourceRuntimeIdRef.current === runtimeIdRef.current) {
       const attempt = eventConnectionAttemptRef.current;
       if (attempt?.source === current && attempt.pending) {
-        await attempt.promise;
-        if (eventSourceRef.current === current && current.readyState === EventSource.OPEN) return;
+        const result = await attempt.promise;
+        if (!mountedRef.current) throw new Error("Session is no longer active");
+        if (result.status === "connected" && eventSourceRef.current === current
+          && eventSourceRuntimeIdRef.current === runtimeIdRef.current
+          && current.readyState === EventSource.OPEN) return;
+      } else if (attempt?.source === current && attempt.connected && current.readyState === EventSource.OPEN) {
+        return;
       }
     }
 
-    const result = await connectEvents(sid);
-    if (result.status === "connected" || result.source.readyState === EventSource.OPEN) return;
+    const result = await connectEvents(sessionIdRef.current ?? sid);
+    if (!mountedRef.current || eventSourceRef.current !== result.source) {
+      result.source.close();
+      throw new Error("Session is no longer active");
+    }
+    if (result.status === "connected") return;
     if (eventSourceRef.current === result.source) eventSourceRef.current = null;
     if (eventSourceSessionIdRef.current === sid) eventSourceSessionIdRef.current = null;
+    eventSourceRuntimeIdRef.current = null;
     if (eventConnectionAttemptRef.current?.source === result.source) eventConnectionAttemptRef.current = null;
     result.source.close();
     throw new EventStreamConnectionError(result.status);
-  }, [connectEvents]);
+  }, [connectEvents, followRuntimeState]);
 
   const respondToExtensionUi = useCallback(async (
     request: ExtensionUiDialogRequest,
@@ -793,7 +959,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         type: "extension_ui_response",
         id: request.id,
         ...response,
-      });
+      }, runtimeIdRef);
     } catch (e) {
       console.error("Failed to send extension UI response:", e);
     }
@@ -807,7 +973,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         type: "extension_ui_input",
         id: request.id,
         data,
-      });
+      }, runtimeIdRef);
     } catch (e) {
       console.error("Failed to send extension custom UI input:", e);
     }
@@ -903,9 +1069,9 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
   }, []);
 
   const notifyPromptStage = useCallback((runId: number) => {
-    if (notifiedPromptRunIdRef.current === runId) return false;
+    if (!mountedRef.current || notifiedPromptRunIdRef.current === runId) return false;
     notifiedPromptRunIdRef.current = runId;
-    onAgentEnd?.();
+    onAgentEnd?.(sessionIdRef.current ?? undefined);
     return true;
   }, [onAgentEnd]);
 
@@ -922,7 +1088,8 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       ) return;
 
       try {
-        const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`);
+        const requestedRuntimeId = runtimeIdRef.current;
+        const res = await fetch(`/api/agent/${encodeURIComponent(requestedRuntimeId ?? sid)}`);
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         const data = await res.json() as { running?: boolean; state?: AgentStateResponse };
         if (
@@ -932,6 +1099,13 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         ) return;
 
         const state = data.state;
+        if (followRuntimeState(state, sid, requestedRuntimeId)) {
+          if (mountedRef.current) {
+            eventStreamGraceTimerRef.current = setTimeout(() => void checkServerIdle(), PROMPT_SETTLE_POLL_MS);
+          }
+          return;
+        }
+        sid = sessionIdRef.current ?? sid;
         setSubagents((current) => mergeSubagentSnapshots(current, state?.subagents ?? []));
         const promptActive = Boolean(
           data.running
@@ -978,16 +1152,17 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     };
 
     eventStreamGraceTimerRef.current = setTimeout(() => void checkServerIdle(), EVENT_STREAM_IDLE_GRACE_MS);
-  }, [cancelEventStreamGrace, closeEvents]);
+  }, [cancelEventStreamGrace, closeEvents, followRuntimeState]);
 
   const finishPromptWithoutStream = useCallback(async (sid: string | null = sessionIdRef.current, runId = promptRunIdRef.current) => {
     // Bail out before loadSession too: a stale finish for a previous run
     // must not overwrite the messages of the run currently streaming.
-    if (promptRunIdRef.current !== runId) return;
+    if (!mountedRef.current || promptRunIdRef.current !== runId) return;
+    sid = sessionIdRef.current ?? sid;
     try {
       if (sid) await loadSession(sid);
     } finally {
-      if (promptRunIdRef.current !== runId) return;
+      if (!mountedRef.current || promptRunIdRef.current !== runId) return;
       const promptWasPending = rpcPromptPendingRef.current;
       const agentWasActive = sdkAgentActiveRef.current;
       rpcPromptPendingRef.current = false;
@@ -997,7 +1172,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       if (promptWasPending) {
         notifyPromptStage(runId);
       } else if (agentWasActive && wasRunning) {
-        onAgentEnd?.();
+        onAgentEnd?.(sessionIdRef.current ?? undefined);
       }
       if (sid) scheduleEventStreamClose(sid);
     }
@@ -1008,12 +1183,20 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     const startedAt = Date.now();
 
     while (agentRunningRef.current && Date.now() - startedAt < PROMPT_SETTLE_MAX_MS) {
+      if (!mountedRef.current || sessionIdRef.current !== sid) return;
       if (runId !== undefined && promptRunIdRef.current !== runId) return;
       try {
-        const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`);
+        const requestedRuntimeId = runtimeIdRef.current;
+        const res = await fetch(`/api/agent/${encodeURIComponent(requestedRuntimeId ?? sid)}`);
         if (res.ok) {
           const data = await res.json() as { running?: boolean; state?: AgentStateResponse };
+          if (runId !== undefined && promptRunIdRef.current !== runId) return;
           const state = data.state;
+          if (followRuntimeState(state, sid, requestedRuntimeId)) {
+            await delay(PROMPT_SETTLE_POLL_MS);
+            continue;
+          }
+          sid = sessionIdRef.current ?? sid;
           if (!data.running || !state || (!state.isStreaming && !state.isPromptRunning)) {
             await finishPromptWithoutStream(sid, runId);
             return;
@@ -1024,22 +1207,27 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       }
       await delay(PROMPT_SETTLE_POLL_MS);
     }
-  }, [finishPromptWithoutStream]);
+  }, [finishPromptWithoutStream, followRuntimeState]);
 
   const waitForBashSettlement = useCallback(async (sid: string) => {
     const recoveryId = bashRecoveryIdRef.current + 1;
     bashRecoveryIdRef.current = recoveryId;
 
     while (
-      bashRunningRef.current
+      mountedRef.current
+      && bashRunningRef.current
       && bashRecoveryIdRef.current === recoveryId
       && sessionIdRef.current === sid
     ) {
       await delay(BASH_STATE_RECONCILE_MS);
       try {
-        const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`);
+        const requestedRuntimeId = runtimeIdRef.current;
+        const res = await fetch(`/api/agent/${encodeURIComponent(requestedRuntimeId ?? sid)}`);
         if (!res.ok) continue;
         const data = await res.json() as { state?: AgentStateResponse };
+        if (bashRecoveryIdRef.current !== recoveryId) return;
+        if (followRuntimeState(data.state, sid, requestedRuntimeId)) continue;
+        sid = sessionIdRef.current ?? sid;
         if (data.state?.isBashRunning) continue;
 
         await loadSession(sid);
@@ -1052,7 +1240,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         // Keep polling while the page is mounted; network recovery is transparent.
       }
     }
-  }, [loadSession]);
+  }, [loadSession, followRuntimeState]);
 
   // Reconcile client streaming state with the server. When SSE events are
   // missed (network drop, mobile tab backgrounded, half-open connection),
@@ -1063,7 +1251,8 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     if (!agentRunningRef.current) return;
     const runId = promptRunIdRef.current;
     try {
-      const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`);
+      const requestedRuntimeId = runtimeIdRef.current;
+      const res = await fetch(`/api/agent/${encodeURIComponent(requestedRuntimeId ?? sid)}`);
       if (!res.ok) return;
       const data = await res.json() as { running?: boolean; state?: AgentStateResponse };
       // A slow response can straddle a run boundary (previous run finished
@@ -1071,6 +1260,8 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       // flight) — everything in it is stale, drop it.
       if (promptRunIdRef.current !== runId) return;
       const state = data.state;
+      if (followRuntimeState(state, sid, requestedRuntimeId)) return;
+      sid = sessionIdRef.current ?? sid;
       // Mirror compaction state unconditionally: a missed compaction_end
       // would otherwise leave the "Stop compaction" UI stuck. No state
       // (wrapper destroyed) means nothing is compacting.
@@ -1090,12 +1281,13 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     } catch {
       // Network still down — the next poll / visibility / online tick retries.
     }
-  }, [finishPromptWithoutStream]);
+  }, [finishPromptWithoutStream, followRuntimeState]);
   const refreshContextUsage = useCallback(async (sid: string, runId = promptRunIdRef.current) => {
     const requestId = contextUsageRequestIdRef.current + 1;
     contextUsageRequestIdRef.current = requestId;
     try {
-      const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`);
+      const requestedRuntimeId = runtimeIdRef.current;
+      const res = await fetch(`/api/agent/${encodeURIComponent(requestedRuntimeId ?? sid)}`);
       if (!res.ok) return;
       const data = await res.json() as { state?: AgentStateResponse };
       if (
@@ -1103,11 +1295,15 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         || sessionIdRef.current !== sid
         || promptRunIdRef.current !== runId
       ) return;
+      if (followRuntimeState(data.state, sid, requestedRuntimeId)) return;
+      if (data.state?.model && !modelSwitchPendingRef.current) {
+        setCurrentModelOverride({ provider: data.state.model.provider, modelId: data.state.model.id });
+      }
       if (data.state?.contextUsage !== undefined) setContextUsage(data.state.contextUsage ?? null);
     } catch {
       // The next refresh retries; state reconciliation owns error recovery.
     }
-  }, []);
+  }, [followRuntimeState]);
 
   // Context usage changes after each model/tool turn, not only when the prompt
   // settles. Poll the lightweight state endpoint while the session is active
@@ -1154,6 +1350,12 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
 
   const handleAgentEvent = useCallback((event: AgentEvent) => {
     switch (event.type) {
+      case "connected":
+      case "session_changed":
+        if (typeof event.sessionId === "string") {
+          followSessionIdentity(event.sessionId, typeof event.runtimeId === "string" ? event.runtimeId : undefined);
+        }
+        break;
       case "agent_start":
         cancelEventStreamGrace();
         sdkAgentActiveRef.current = true;
@@ -1171,10 +1373,13 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         setRetryInfo(null);
         dispatch({ type: "end" });
         if (sessionIdRef.current) {
-          loadSession(sessionIdRef.current);
-          fetch(`/api/agent/${encodeURIComponent(sessionIdRef.current)}`)
+          const sid = sessionIdRef.current;
+          loadSession(sid);
+          const requestedRuntimeId = runtimeIdRef.current;
+          fetch(`/api/agent/${encodeURIComponent(requestedRuntimeId ?? sid)}`)
             .then((r) => r.json())
             .then((d: { state?: AgentStateResponse }) => {
+              if (followRuntimeState(d.state, sid, requestedRuntimeId)) return;
               if (d.state?.contextUsage !== undefined) setContextUsage(d.state.contextUsage ?? null);
               if (d.state?.systemPrompt !== undefined) setSystemPrompt(d.state.systemPrompt ?? null);
               if (d.state?.extensionStatuses !== undefined) setExtensionStatuses(d.state.extensionStatuses ?? []);
@@ -1203,7 +1408,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
           void loadSession(sid);
           scheduleEventStreamClose(sid);
         }
-        if (wasRunning) onAgentEnd?.();
+        if (wasRunning) onAgentEnd?.(sessionIdRef.current ?? undefined);
         break;
       }
       case "prompt_done":
@@ -1423,7 +1628,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         handleExtensionUiRequest(event as ExtensionUiRequest);
         break;
     }
-  }, [addNotice, cancelEventStreamGrace, handleExtensionUiRequest, loadSession, notifyPromptStage, onAgentEnd, refreshContextUsage, scheduleEventStreamClose, settleUiStage]);
+  }, [addNotice, cancelEventStreamGrace, handleExtensionUiRequest, loadSession, notifyPromptStage, onAgentEnd, followSessionIdentity, followRuntimeState, refreshContextUsage, scheduleEventStreamClose, settleUiStage]);
   handleAgentEventRef.current = handleAgentEvent;
 
   const handleSend = useCallback(async (message: string, images?: AttachedImage[]) => {
@@ -1477,32 +1682,34 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
           if (selectedModel) {
             setPendingModel(selectedModel);
             if (existingSid) {
-              await sendAgentCommand(sid, { type: "set_model", provider: selectedModel.provider, modelId: selectedModel.modelId });
+              await sendAgentCommand(sid, { type: "set_model", provider: selectedModel.provider, modelId: selectedModel.modelId }, runtimeIdRef);
             }
           }
-          await ensureEventsConnected(sid);
+          await ensureEventsConnected(sessionIdRef.current ?? sid);
+          sentSessionId = sessionIdRef.current ?? sid;
           promptRequestStarted = true;
-          await sendAgentCommand(sid, {
+          await sendAgentCommand(sentSessionId, {
             type: "prompt",
             message,
             ...(piImages?.length ? { images: piImages } : {}),
-          });
+          }, runtimeIdRef);
           promoteNewSession(1, message);
         }
       } else if (session) {
-        sentSessionId = session.id;
-        await ensureEventsConnected(session.id);
+        await ensureEventsConnected(sessionIdRef.current ?? session.id);
+        sentSessionId = sessionIdRef.current ?? session.id;
         promptRequestStarted = true;
-        await sendAgentCommand(session.id, {
+        await sendAgentCommand(sentSessionId, {
           type: "prompt",
           message,
           ...(piImages?.length ? { images: piImages } : {}),
-        });
+        }, runtimeIdRef);
       }
       if (isSlashCommandPrompt && sentSessionId) {
         void waitForPromptSettlement(sentSessionId, promptRunId);
       }
     } catch (e) {
+      if (!mountedRef.current) return;
       console.error("Failed to send message:", e);
       const definitivelyRejected = !promptRequestStarted || isPromptRejectedError(e);
       // A transport/proxy failure after dispatch is ambiguous: the server may
@@ -1532,7 +1739,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       opts.chatInputRef?.current?.restoreSubmission?.(
         message,
         images?.map(({ data, mimeType }) => ({ data, mimeType })),
-        session?.id ?? sentSessionId ?? undefined,
+        sessionIdRef.current ?? sentSessionId ?? session?.id ?? undefined,
       );
       optimisticUserMessageKeyRef.current = null;
       setAgentRunning(false);
@@ -1555,13 +1762,13 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         type: "bash",
         command,
         excludeFromContext,
-      });
+      }, runtimeIdRef);
       await loadSession(sid);
       promoteNewSession(1, inputText);
     } catch (e) {
       console.error("Failed to execute shell command:", e);
       addNotice({ type: "error", message: e instanceof Error ? e.message : String(e) });
-      opts.chatInputRef?.current?.insertIfEmpty(inputText);
+      if (mountedRef.current) opts.chatInputRef?.current?.insertIfEmpty(inputText);
     } finally {
       bashRunningRef.current = false;
       setPendingBash(null);
@@ -1575,14 +1782,14 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     if (!sid) return;
     if (bashRunningRef.current) {
       try {
-        await sendAgentCommand(sid, { type: "abort_bash" });
+        await sendAgentCommand(sid, { type: "abort_bash" }, runtimeIdRef);
       } catch (e) {
         console.error("Failed to abort bash:", e);
       }
       return;
     }
     try {
-      await sendAgentCommand(sid, { type: "abort" });
+      await sendAgentCommand(sid, { type: "abort" }, runtimeIdRef);
     } catch (e) {
       console.error("Failed to abort:", e);
     }
@@ -1603,10 +1810,10 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       const result = await sendAgentCommand<{ cancelled?: boolean; newSessionId?: string }>(sid, {
         type: "fork",
         ...(entryId ? { entryId } : {}),
-      });
+      }, runtimeIdRef);
       const { cancelled, newSessionId } = result ?? {};
       if (!cancelled && newSessionId) {
-        onSessionForked?.(newSessionId);
+        if (mountedRef.current) onSessionForked?.(newSessionId);
         return { forked: true };
       }
       return { forked: false, error: "Fork was cancelled" };
@@ -1622,7 +1829,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     if (bashRunningRef.current) return;
     const sid = sessionIdRef.current;
     if (!sid) return;
-    sendAgentCommand(sid, { type: "navigate_tree", targetId: entryId }).catch(() => {});
+    sendAgentCommand(sid, { type: "navigate_tree", targetId: entryId }, runtimeIdRef).catch(() => {});
     setActiveLeafId(entryId);
     await loadContext(sid, entryId);
   }, [loadContext]);
@@ -1632,9 +1839,9 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     setActiveLeafId(leafId);
     const sid = sessionIdRef.current;
     if (!sid) return;
-    await loadContext(sid, leafId);
-    if (leafId) {
-      sendAgentCommand(sid, { type: "navigate_tree", targetId: leafId }).catch(() => {});
+    if (!await loadContext(sid, leafId)) return;
+    if (leafId && mountedRef.current && sessionIdRef.current) {
+      sendAgentCommand(sessionIdRef.current, { type: "navigate_tree", targetId: leafId }, runtimeIdRef).catch(() => {});
     }
   }, [loadContext]);
 
@@ -1647,7 +1854,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       const sid = sessionIdRef.current ?? await ensuringNewSessionRef.current;
       if (!sid) return;
       try {
-        await sendAgentCommand(sid, { type: "set_model", provider, modelId });
+        await sendAgentCommand(sid, { type: "set_model", provider, modelId }, runtimeIdRef);
       } catch (e) {
         console.error("Failed to set model:", e);
       }
@@ -1661,7 +1868,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     setCurrentModelOverride(target);
     setModelSwitching(true);
     try {
-      await sendAgentCommand(sid, { type: "set_model", provider, modelId });
+      await sendAgentCommand(sid, { type: "set_model", provider, modelId }, runtimeIdRef);
       // Pi persists model_change synchronously. Reload the canonical session so
       // the model, thinking level, and active leaf all advance together.
       modelSwitchPendingRef.current = false;
@@ -1710,7 +1917,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     const sid = sessionIdRef.current ?? (isNew ? await ensuringNewSessionRef.current : null);
     if (!sid) return;
     try {
-      await sendAgentCommand(sid, { type: "set_role_model", role });
+      await sendAgentCommand(sid, { type: "set_role_model", role }, runtimeIdRef);
       if (!isNew) setCurrentModelOverride({ provider: resolved.provider, modelId: resolved.modelId });
     } catch (e) {
       console.error("Failed to set role model:", e);
@@ -1724,7 +1931,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     setCompactError(null);
     setCompactResult(null);
     try {
-      const result = await sendAgentCommand<CompactCommandResult>(sid, { type: "compact" });
+      const result = await sendAgentCommand<CompactCommandResult>(sid, { type: "compact" }, runtimeIdRef);
       setCompactResult(readCompactResult(result, "manual"));
       await loadSession(sid, true);
     } catch (e) {
@@ -1792,7 +1999,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
           const result = await sendAgentCommand<CompactCommandResult>(sid, {
             type: "compact",
             ...(args ? { customInstructions: args } : {}),
-          });
+          }, runtimeIdRef);
           setCompactResult(readCompactResult(result, "manual"));
           if (await loadSession(sid, true)) promoteNewSession();
           return complete({ handled: true, message: "Compacted context" });
@@ -1800,7 +2007,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
 
         case "reload": {
           if (!sid) return complete({ handled: true, error: "No active session to reload" });
-          await sendAgentCommand(sid, { type: "reload" });
+          await sendAgentCommand(sid, { type: "reload" }, runtimeIdRef);
           await Promise.all([
             loadSession(sid, false, true),
             loadTools(sid),
@@ -1813,24 +2020,25 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         case "name": {
           if (!sid) return complete({ handled: true, error: "No active session to name" });
           if (!args) return complete({ handled: true, error: "Usage: /name <name>" });
-          await sendAgentCommand(sid, { type: "set_session_name", name: args });
+          await sendAgentCommand(sid, { type: "set_session_name", name: args }, runtimeIdRef);
           if (await loadSession(sid)) promoteNewSession();
           return complete({ handled: true, message: `Session renamed to ${args}` });
         }
 
         case "session": {
           if (!sid) return complete({ handled: true, error: "No active session" });
-          const stats = await sendAgentCommand<SessionStatsInfo>(sid, { type: "get_session_stats" });
+          const stats = await sendAgentCommand<SessionStatsInfo>(sid, { type: "get_session_stats" }, runtimeIdRef);
           if (stats) {
             setSessionStatsOverride(stats);
           }
+          if (!mountedRef.current) return { handled: true };
           onSessionStatsPanelOpen?.();
           return complete({ handled: true, action: "openSessionStats" });
         }
 
         case "copy": {
           if (!sid) return complete({ handled: true, error: "No active session" });
-          const data = await sendAgentCommand<LastAssistantTextResponse>(sid, { type: "get_last_assistant_text" });
+          const data = await sendAgentCommand<LastAssistantTextResponse>(sid, { type: "get_last_assistant_text" }, runtimeIdRef);
           const textToCopy = data?.text ?? "";
           if (!textToCopy) return complete({ handled: true, error: "No assistant message to copy" });
           await navigator.clipboard.writeText(textToCopy);
@@ -1848,7 +2056,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
 
         case "goal": {
           if (!sid) return complete({ handled: true, error: "No active session" });
-          const result = await sendAgentCommand<GoalCommandResponse>(sid, { type: "goal", args });
+          const result = await sendAgentCommand<GoalCommandResponse>(sid, { type: "goal", args }, runtimeIdRef);
           setGoalStatus(result?.status ?? null);
           if (result?.error) return complete({ handled: true, error: result.error });
           // `/goal show` output belongs in the transcript, not a toast that
@@ -1877,24 +2085,28 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
           setAgentRunning(true);
           setAgentPhase({ kind: "running_command" });
           try {
-            await ensureEventsConnected(sid);
-            const result = await sendAgentCommand<{ cancelled?: boolean }>(sid, {
+            await ensureEventsConnected(sessionIdRef.current ?? sid);
+            const currentSid = sessionIdRef.current ?? sid;
+            const result = await sendAgentCommand<{ cancelled?: boolean }>(currentSid, {
               type: "handoff",
               ...(args ? { customInstructions: args } : {}),
-            });
+            }, runtimeIdRef);
             if (!result || result.cancelled) {
               return complete({ handled: true, error: "Handoff cancelled" });
             }
             // omp 18 hands off in place, so the session keeps its id and gains
             // a handoff compaction entry: reload this transcript rather than
             // navigating to a replacement session.
-            if (await loadSession(sid, true)) promoteNewSession();
+            if (mountedRef.current && await loadSession(sessionIdRef.current ?? currentSid, true)) promoteNewSession();
             return complete({ handled: true, message: "Context handed off and compacted in place" });
           } finally {
-            agentRunningRef.current = false;
-            setAgentRunning(false);
-            setAgentPhase(null);
-            if (sessionIdRef.current === sid) scheduleEventStreamClose(sid);
+            if (mountedRef.current) {
+              agentRunningRef.current = false;
+              setAgentRunning(false);
+              setAgentPhase(null);
+              const finalSid = sessionIdRef.current;
+              if (finalSid) scheduleEventStreamClose(finalSid);
+            }
           }
         }
 
@@ -1907,7 +2119,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
           }>(sid, {
             type: "execute_slash_command",
             message: text,
-          });
+          }, runtimeIdRef);
           if (!result?.handled) return { handled: false };
           const output = result.output?.filter((line) => line.trim()).join("\n\n") ?? "";
           if (output) appendCommandOutput(output);
@@ -1936,7 +2148,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         type: "steer",
         message,
         ...(piImages?.length ? { images: piImages } : {}),
-      });
+      }, runtimeIdRef);
     } catch (e) {
       console.error("Failed to steer:", e);
     }
@@ -1956,7 +2168,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         message,
         streamingBehavior: behavior,
         ...(piImages?.length ? { images: piImages } : {}),
-      });
+      }, runtimeIdRef);
     } catch (e) {
       console.error("Failed to queue prompt:", e);
     }
@@ -1971,7 +2183,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         type: "follow_up",
         message,
         ...(piImages?.length ? { images: piImages } : {}),
-      });
+      }, runtimeIdRef);
     } catch (e) {
       console.error("Failed to follow up:", e);
     }
@@ -1981,7 +2193,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     const sid = sessionIdRef.current;
     if (!sid) return;
     try {
-      await sendAgentCommand(sid, { type: "abort_compaction" });
+      await sendAgentCommand(sid, { type: "abort_compaction" }, runtimeIdRef);
     } catch (e) {
       console.error("Failed to abort compaction:", e);
     }
@@ -1991,12 +2203,12 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     const sid = sessionIdRef.current;
     if (!sid) return;
     try {
-      const result = await sendAgentCommand<{ steering?: string[]; followUp?: string[] }>(sid, { type: "clear_queue" });
+      const result = await sendAgentCommand<{ steering?: string[]; followUp?: string[] }>(sid, { type: "clear_queue" }, runtimeIdRef);
       // clearQueue also emits an empty queue_update, but that only reaches us
       // while SSE is connected — clear locally so idle recalls update the UI.
       setQueuedMessages({ steering: [], followUp: [] });
       const texts = [...(result?.steering ?? []), ...(result?.followUp ?? [])];
-      if (texts.length > 0) {
+      if (mountedRef.current && texts.length > 0) {
         opts.chatInputRef?.current?.prependText(texts.join("\n\n"));
       }
     } catch (e) {
@@ -2014,7 +2226,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     const sid = sessionIdRef.current ?? await ensuringNewSessionRef.current;
     if (!sid) return;
     try {
-      await sendAgentCommand(sid, { type: "set_thinking_level", level });
+      await sendAgentCommand(sid, { type: "set_thinking_level", level }, runtimeIdRef);
       await loadSession(sid);
     } catch (e) {
       console.error("Failed to set thinking level:", e);
@@ -2029,7 +2241,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     const sid = sessionIdRef.current ?? await ensuringNewSessionRef.current;
     if (!sid) return;
     try {
-      await sendAgentCommand(sid, { type: "set_tools", toolNames });
+      await sendAgentCommand(sid, { type: "set_tools", toolNames }, runtimeIdRef);
     } catch (e) {
       console.error("Failed to set tools:", e);
     }
@@ -2084,13 +2296,23 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     }
   }, [setAutoFollow]);
 
+  const displayedSessionIdRef = useRef(session?.id);
+  useEffect(() => {
+    if (session?.id && session.id !== displayedSessionIdRef.current) {
+      displayedSessionIdRef.current = session.id;
+      void loadSession(session.id);
+    }
+  }, [session?.id, loadSession]);
+
   // Load session on mount
   useEffect(() => {
     if (session) {
       sessionIdRef.current = session.id;
       loadSession(session.id, true, true).then((agentState) => {
+        const sid = sessionIdRef.current;
+        if (!mountedRef.current || !sid) return;
         if (agentState?.running) {
-          loadTools(session.id);
+          loadTools(sid);
           if (
             agentState.state?.isStreaming
             || agentState.state?.isPromptRunning
@@ -2102,18 +2324,18 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
             setAgentRunning(true);
             setAgentPhase(agentState.state.isStreaming ? { kind: "waiting_model" } : { kind: "running_command" });
             dispatch({ type: "start" });
-            void connectEvents(session.id);
+            void connectEvents(sid);
             if (!agentState.state.isStreaming && agentState.state.isPromptRunning) {
-              void waitForPromptSettlement(session.id);
+              void waitForPromptSettlement(sid);
             }
           }
           if (agentState.state?.isBashRunning) {
             bashRunningRef.current = true;
             setBashRunning(true);
-            void waitForBashSettlement(session.id);
+            void waitForBashSettlement(sid);
           }
           if ((agentState.state?.subagents?.length ?? 0) > 0) {
-            void connectEvents(session.id);
+            void connectEvents(sid);
           }
         }
         const state = agentState?.state;
diff --git a/lib/agent-client.test.mjs b/lib/agent-client.test.mjs
index 5d7d0f4268..0203fba7b7 100644
--- a/lib/agent-client.test.mjs
+++ b/lib/agent-client.test.mjs
@@ -6,7 +6,7 @@ const jiti = createJiti(import.meta.url, {
   interopDefault: true,
   moduleCache: false,
 });
-const { AgentCommandError, isPromptRejectedError, sendAgentCommand } = await jiti.import("./agent-client.ts");
+const { AgentCommandError, isPromptRejectedError, sendAgentCommand, canApplySessionIdentity } = await jiti.import("./agent-client.ts");
 
 test("agent command HTTP rejections are distinguishable from transport failures", async (t) => {
   const originalFetch = globalThis.fetch;
@@ -37,12 +37,15 @@ test("agent command HTTP rejections are distinguishable from transport failures"
   );
 
   const transportError = new TypeError("connection reset");
+  const runtime = { current: "runtime:live" };
+  let transportAttempts = 0;
   globalThis.fetch = async () => {
+    transportAttempts += 1;
     throw transportError;
   };
 
   await assert.rejects(
-    sendAgentCommand("session-id", { type: "prompt", message: "hello" }),
+    sendAgentCommand("session-id", { type: "prompt", message: "hello" }, runtime),
     (error) => {
       assert.equal(error, transportError);
       assert.equal(error instanceof AgentCommandError, false);
@@ -50,6 +53,8 @@ test("agent command HTTP rejections are distinguishable from transport failures"
       return true;
     },
   );
+  assert.equal(transportAttempts, 1);
+  assert.equal(runtime.current, "runtime:live");
 });
 
 test("only an explicit negative prompt acknowledgement is definitive", () => {
@@ -62,3 +67,62 @@ test("only an explicit negative prompt acknowledgement is definitive", () => {
     false,
   );
 });
+
+
+test("an explicitly expired runtime retries its confirmed final session once", async (t) => {
+  const originalFetch = globalThis.fetch;
+  t.after(() => { globalThis.fetch = originalFetch; });
+  const requests = [];
+  const relocations = [];
+  const runtime = { current: "runtime:expired", onIdentity: (identity, request) => {
+    relocations.push([identity, request]);
+  } };
+  const command = { type: "set_model", provider: "provider", modelId: "model" };
+  globalThis.fetch = async (url, options) => {
+    requests.push({ url, body: JSON.parse(options.body) });
+    return requests.length === 1
+      ? Response.json({ error: "Runtime session expired", code: "runtime_expired", accepted: false, sessionId: "final-session" }, { status: 404 })
+      : Response.json({ success: true, data: { updated: true }, sessionId: "next-session", runtimeId: "runtime:new" });
+  };
+  assert.deepEqual(await sendAgentCommand("canonical-session", command, runtime), { updated: true });
+  assert.deepEqual(requests, [
+    { url: "/api/agent/runtime%3Aexpired", body: command },
+    { url: "/api/agent/final-session", body: command },
+  ]);
+  assert.equal(runtime.current, "runtime:new");
+  assert.deepEqual(relocations, [
+    [{ sessionId: "final-session", runtimeId: null }, { sessionId: "canonical-session", runtimeId: "runtime:expired" }],
+    [{ sessionId: "next-session", runtimeId: "runtime:new" }, { sessionId: "final-session", runtimeId: null }],
+  ]);
+
+  requests.length = 0;
+  runtime.current = "runtime:unknown";
+  globalThis.fetch = async (url) => {
+    requests.push(url);
+    return Response.json({ error: "Runtime session expired", code: "runtime_expired", accepted: false }, { status: 404 });
+  };
+  await assert.rejects(sendAgentCommand("stale-session", command, runtime), isPromptRejectedError);
+  assert.deepEqual(requests, ["/api/agent/runtime%3Aunknown"]);
+  assert.equal(runtime.current, "runtime:unknown");
+});
+
+
+test("a command-created fallback binds its canonical ID and runtime", async (t) => {
+  const originalFetch = globalThis.fetch;
+  t.after(() => { globalThis.fetch = originalFetch; });
+  const identities = [];
+  const runtime = { current: null, onIdentity: (identity) => { identities.push(identity); } };
+  globalThis.fetch = async () => Response.json({ success: true, data: [], sessionId: "fallback", runtimeId: "runtime:new" });
+  assert.deepEqual(await sendAgentCommand("historical", { type: "get_tools" }, runtime), []);
+  assert.equal(runtime.current, "runtime:new");
+  assert.deepEqual(identities, [{ sessionId: "fallback", runtimeId: "runtime:new" }]);
+});
+
+test("delayed identity responses cannot roll a continued runtime backward", () => {
+  const request = { sessionId: "a", runtimeId: "runtime:one" };
+  const response = { sessionId: "b", runtimeId: "runtime:one" };
+  assert.equal(canApplySessionIdentity(request, response, request), true);
+  assert.equal(canApplySessionIdentity(response, response, request), true);
+  assert.equal(canApplySessionIdentity({ sessionId: "c", runtimeId: "runtime:one" }, response, request), false);
+  assert.equal(canApplySessionIdentity({ sessionId: "a", runtimeId: "runtime:two" }, response, request), false);
+});
diff --git a/lib/agent-client.ts b/lib/agent-client.ts
index e30e7b8510..be2da6e971 100644
--- a/lib/agent-client.ts
+++ b/lib/agent-client.ts
@@ -1,3 +1,5 @@
+import { clearSessionContinuation } from "./workspace-memory";
+
 // Client-side helper for POST /api/agent/[id].
 //
 // Every /api/agent/[id] route returns one of:
@@ -21,15 +23,35 @@ export class AgentCommandError extends Error {
 
 export function isPromptRejectedError(error: unknown): error is AgentCommandError {
   return error instanceof AgentCommandError
-    && error.code === "prompt_rejected"
+    && (error.code === "prompt_rejected" || error.code === "runtime_expired")
     && error.accepted === false;
 }
 
+export interface SessionIdentity {
+  sessionId: string;
+  runtimeId: string | null;
+}
+
+export interface RuntimeSessionBinding {
+  current: string | null;
+  onIdentity?: (identity: SessionIdentity, request: SessionIdentity) => boolean | void;
+}
+
+/** Accept a response only while its request still owns the selected identity. */
+export function canApplySessionIdentity(current: SessionIdentity, identity: SessionIdentity, request: SessionIdentity): boolean {
+  return (current.sessionId === identity.sessionId && current.runtimeId === identity.runtimeId)
+    || (current.runtimeId === request.runtimeId
+      && (current.sessionId === request.sessionId || current.sessionId === identity.sessionId));
+}
+
 export async function sendAgentCommand<T = unknown>(
   sessionId: string,
   command: Record<string, unknown>,
+  runtime?: RuntimeSessionBinding,
 ): Promise<T> {
-  const res = await fetch(`/api/agent/${encodeURIComponent(sessionId)}`, {
+  const runtimeId = runtime?.current ?? null;
+  const request = { sessionId, runtimeId };
+  const res = await fetch(`/api/agent/${encodeURIComponent(runtimeId ?? sessionId)}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(command),
@@ -40,8 +62,19 @@ export async function sendAgentCommand<T = unknown>(
     error?: string;
     code?: string;
     accepted?: boolean;
+    sessionId?: string;
+    runtimeId?: string;
   };
   if (!res.ok || body.error) {
+    // Retry only when the server guarantees that the expired handle executed nothing.
+    if (runtimeId && runtime?.current === runtimeId && res.status === 404
+      && body.code === "runtime_expired" && body.accepted === false && body.sessionId) {
+      if (runtime.onIdentity?.({ sessionId: body.sessionId, runtimeId: null }, request) !== false) {
+        runtime.current = null;
+        clearSessionContinuation(undefined, runtimeId);
+        return sendAgentCommand<T>(body.sessionId, command, runtime);
+      }
+    }
     throw new AgentCommandError(
       body.error ?? `HTTP ${res.status}`,
       res.status,
@@ -49,5 +82,9 @@ export async function sendAgentCommand<T = unknown>(
       body.accepted,
     );
   }
+  if (runtime && runtime.current === runtimeId && body.sessionId && body.runtimeId) {
+    const identity = { sessionId: body.sessionId, runtimeId: body.runtimeId };
+    if (runtime.onIdentity?.(identity, request) !== false) runtime.current = body.runtimeId;
+  }
   return body.data as T;
 }
diff --git a/lib/rpc-manager.ts b/lib/rpc-manager.ts
index a67728475c..0b834ca0a6 100644
--- a/lib/rpc-manager.ts
+++ b/lib/rpc-manager.ts
@@ -280,6 +280,7 @@ export async function getAvailableSlashCommands(session: AgentSessionLike): Prom
 // ============================================================================
 
 export class AgentSessionWrapper {
+  readonly runtimeId = `runtime:${randomUUID()}`;
   private listeners: EventListener[] = [];
   private pendingUiResponses = new Map<string, PendingUiResponse>();
   private pendingUiRequests = new Map<string, AgentEvent>();
@@ -724,7 +725,26 @@ export class AgentSessionWrapper {
   }
 
 
+  syncSessionIdentity(): void {
+    const registry = globalThis.__ompSessions;
+    const currentId = this.sessionId;
+    if (!registry || registry.get(currentId) === this) return;
+    let moved = false;
+    for (const [id, session] of registry) {
+      if (session !== this) continue;
+      registry.delete(id);
+      moved = true;
+    }
+    if (!moved) return;
+    registry.set(currentId, this);
+    if (this.sessionFile) cacheSessionPath(currentId, this.sessionFile);
+    invalidateSessionListCache();
+    // Existing streams still hold this wrapper after its registry key moves.
+    for (const listener of this.listeners) listener({ type: "session_changed", sessionId: currentId, runtimeId: this.runtimeId });
+  }
+
   private emit(event: AgentEvent): void {
+    this.syncSessionIdentity();
     for (const l of this.listeners) l(event);
   }
 
@@ -836,6 +856,7 @@ export class AgentSessionWrapper {
         const contextUsage = this.inner.getContextUsage();
         return {
           sessionId: this.inner.sessionId,
+          runtimeId: this.runtimeId,
           sessionFile: this.inner.sessionFile ?? "",
           isStreaming: this.inner.isStreaming,
           isPromptRunning: this.promptRunning,
@@ -1174,6 +1195,10 @@ export class AgentSessionWrapper {
   destroy(): void {
     if (!this._alive) return;
     this._alive = false;
+    const finalIds = globalThis.__ompFinalSessionIds ??= new Map<string, string>();
+    finalIds.set(this.runtimeId, this.sessionId);
+    // A bounded continuation record, never a historical-session alias.
+    while (finalIds.size > 1024) finalIds.delete(finalIds.keys().next().value!);
     if (this.idleTimer) clearTimeout(this.idleTimer);
     if (this.inner.isBashRunning) this.inner.abortBash();
     this.unsubscribe?.();
@@ -1188,6 +1213,11 @@ export class AgentSessionWrapper {
       void this.inner.dispose?.();
     } finally {
       try {
+        // Runtime fallback can move this wrapper away from its startup ID.
+        // Remove only this instance, preserving separately reopened sessions.
+        for (const [id, session] of globalThis.__ompSessions ?? []) {
+          if (session === this) globalThis.__ompSessions?.delete(id);
+        }
         this.onDestroyCallback?.();
       } finally {
         notifyRunningChange();
@@ -1545,6 +1575,7 @@ export class AgentSessionWrapper {
 
 declare global {
   var __ompSessions: Map<string, AgentSessionWrapper> | undefined;
+  var __ompFinalSessionIds: Map<string, string> | undefined;
   var __ompStartLocks: Map<string, Promise<{ session: AgentSessionWrapper; realSessionId: string }>> | undefined;
   var __ompStartingSessionCwds: Map<string, number> | undefined;
   var __ompRunningListeners: Set<(ids: string[]) => void> | undefined;
@@ -1558,6 +1589,17 @@ function getRegistry(): Map<string, AgentSessionWrapper> {
     process.once("SIGINT", cleanup);
     process.once("SIGTERM", cleanup);
   }
+  for (const session of globalThis.__ompSessions.values()) {
+    if (Object.getPrototypeOf(session) === AgentSessionWrapper.prototype) continue;
+    // HMR retains pre-identity wrappers, including their SDK run and listeners.
+    // Upgrade only wrapper instances carrying the existing private state.
+    if (!Array.isArray(Reflect.get(session, "listeners"))) continue;
+    if (!session.runtimeId) Object.defineProperty(session, "runtimeId", { value: `runtime:${randomUUID()}` });
+    // The old manager callback deleted the startup ID even after relocation.
+    // Current destroy() removes entries by wrapper identity instead.
+    Reflect.set(session, "onDestroyCallback", null);
+    Object.setPrototypeOf(session, AgentSessionWrapper.prototype);
+  }
   return globalThis.__ompSessions;
 }
 
@@ -1591,8 +1633,22 @@ function trackStartingSession(cwd: string): () => void {
   };
 }
 
+export function getFinalRpcSessionId(runtimeId: string): string | undefined {
+  return globalThis.__ompFinalSessionIds?.get(runtimeId);
+}
+
 export function getRpcSession(sessionId: string): AgentSessionWrapper | undefined {
-  return getRegistry().get(sessionId);
+  const registry = getRegistry();
+  // Canonical history IDs never redirect to another transcript. Only an
+  // explicit runtime handle follows the wrapper when the SDK changes its ID.
+  for (const candidate of [...registry.values()]) {
+    if (candidate.isAlive()) candidate.syncSessionIdentity?.();
+  }
+  const registered = registry.get(sessionId);
+  if (registered?.isAlive() && registered.sessionId === sessionId) return registered;
+  return [...registry.values()].find(
+    (candidate) => candidate.isAlive() && (candidate.sessionId === sessionId || candidate.runtimeId === sessionId),
+  );
 }
 
 function runtimeMessageText(entry: SessionMessageEntry): string {
@@ -1678,6 +1734,19 @@ export async function destroyRpcSessionsForCwd(cwd: string): Promise<number> {
   return sessions.length;
 }
 
+// Include idle wrappers so a run that changes ID and finishes between polls
+// is attributed to its final transcript rather than its historical ID.
+export function getRpcSessionActivitySnapshot() {
+  const runningSessionIds = new Set<string>();
+  const sessionIdsByRuntimeId: Record<string, string> = Object.fromEntries(globalThis.__ompFinalSessionIds ?? []);
+  for (const session of getRegistry().values()) {
+    if (!session.isAlive()) continue;
+    sessionIdsByRuntimeId[session.runtimeId] = session.sessionId;
+    if (session.isRunning()) runningSessionIds.add(session.sessionId);
+  }
+  return { runningSessionIds: [...runningSessionIds], sessionIdsByRuntimeId };
+}
+
 export function getRunningRpcSessionIds(): string[] {
   const ids = new Set<string>();
   for (const [sessionId, session] of getRegistry()) {
@@ -1747,8 +1816,8 @@ export async function startRpcSession(
   const registry = getRegistry();
   const locks = getLocks();
 
-  const existing = registry.get(sessionId);
-  if (existing?.isAlive()) return { session: existing, realSessionId: sessionId };
+  const existing = getRpcSession(sessionId);
+  if (existing?.isAlive()) return { session: existing, realSessionId: existing.sessionId };
 
   const inflight = locks.get(sessionId);
   if (inflight) return inflight;
@@ -1867,7 +1936,6 @@ export async function startRpcSession(
       const realSessionFile = inner.sessionFile as string | undefined;
       if (realSessionFile) cacheSessionPath(realSessionId, realSessionFile);
 
-      wrapper.onDestroy(() => registry.delete(realSessionId));
       registry.set(realSessionId, wrapper);
       wrapper.beginExtensionBinding({ forceEmptySystemPrompt: toolNames?.length === 0 });
 
diff --git a/lib/rpc-session-info.test.mjs b/lib/rpc-session-info.test.mjs
index 469a3c5b18..d27002b089 100644
--- a/lib/rpc-session-info.test.mjs
+++ b/lib/rpc-session-info.test.mjs
@@ -9,7 +9,7 @@ const jiti = createJiti(import.meta.url, {
   interopDefault: true,
   moduleCache: false,
 });
-const { getRpcSessionInfos } = await jiti.import("./rpc-manager.ts");
+const { AgentSessionWrapper, getRpcSession, getRpcSessionInfos, getRpcSessionActivitySnapshot, getFinalRpcSessionId, startRpcSession } = await jiti.import("./rpc-manager.ts");
 
 function makeRuntimeSession({ id, filePath, running, entries }) {
   const timestamp = "2026-08-12T01:02:03.000Z";
@@ -91,3 +91,133 @@ test("keeps an idle runtime visible once its JSONL file exists", (t) => {
   assert.equal(infos.length, 1);
   assert.equal(infos[0].transient, false);
 });
+
+test("moves a live wrapper across successive IDs without redirecting historical sessions", async (t) => {
+  const previousRegistry = globalThis.__ompSessions;
+  const previousFinalIds = globalThis.__ompFinalSessionIds;
+  globalThis.__ompFinalSessionIds = new Map();
+  const inner = { sessionId: "original-session", isBashRunning: false };
+  const eventBus = { on: () => () => {} };
+  const wrapper = new AgentSessionWrapper(inner, eventBus);
+  const events = [];
+  const disconnect = wrapper.onEvent((event) => events.push(event));
+  const runtimeId = wrapper.runtimeId;
+  let running = true;
+  wrapper.isRunning = () => running;
+  let historical;
+  globalThis.__ompSessions = new Map([[inner.sessionId, wrapper]]);
+  t.after(() => {
+    wrapper.destroy();
+    historical?.destroy();
+    globalThis.__ompSessions = previousRegistry;
+    globalThis.__ompFinalSessionIds = previousFinalIds;
+  });
+
+  assert.deepEqual(getRpcSessionActivitySnapshot(), {
+    runningSessionIds: ["original-session"],
+    sessionIdsByRuntimeId: { [runtimeId]: "original-session" },
+  });
+  inner.sessionId = "fallback-session";
+  assert.deepEqual(getRpcSessionActivitySnapshot(), {
+    runningSessionIds: ["fallback-session"],
+    sessionIdsByRuntimeId: { [runtimeId]: "fallback-session" },
+  });
+  running = false;
+  assert.deepEqual(getRpcSessionActivitySnapshot(), {
+    runningSessionIds: [],
+    sessionIdsByRuntimeId: { [runtimeId]: "fallback-session" },
+  });
+  running = true;
+  assert.equal(getRpcSession(inner.sessionId), wrapper);
+  assert.equal(getRpcSession("original-session"), undefined);
+  assert.equal(getRpcSession(inner.sessionId), wrapper);
+  assert.deepEqual([...globalThis.__ompSessions.keys()], [inner.sessionId]);
+  // Reusing the current ID must not create a second agent or open a transcript.
+  const resumed = await startRpcSession(inner.sessionId, "/missing/session.jsonl", undefined);
+  assert.equal(resumed.session, wrapper);
+  assert.equal(resumed.realSessionId, inner.sessionId);
+
+  inner.sessionId = "second-fallback-session";
+  assert.equal(getRpcSession("fallback-session"), undefined);
+  assert.equal(getRpcSession("fallback-session"), undefined);
+  assert.equal(getRpcSession("original-session"), undefined);
+  assert.equal(getRpcSession(inner.sessionId), wrapper);
+  assert.deepEqual([...globalThis.__ompSessions.keys()], [inner.sessionId]);
+
+  // A second tab reopening B gets its own wrapper, not C's transcript.
+  historical = new AgentSessionWrapper({ sessionId: "fallback-session", isBashRunning: false }, eventBus);
+  globalThis.__ompSessions.set(historical.sessionId, historical);
+  assert.equal(getRpcSession("fallback-session"), historical);
+  const reopened = await startRpcSession("fallback-session", "/missing/session.jsonl", undefined);
+  assert.equal(reopened.session, historical);
+  assert.equal(reopened.realSessionId, "fallback-session");
+
+  assert.deepEqual(events.filter((event) => event.type === "session_changed"), [
+    { type: "session_changed", sessionId: "fallback-session", runtimeId },
+    { type: "session_changed", sessionId: "second-fallback-session", runtimeId },
+  ]);
+  // A disconnected tab can recover the next identity without aliasing B or C.
+  disconnect();
+  inner.sessionId = "disconnected-fallback-session";
+  wrapper.syncSessionIdentity();
+  assert.equal(getRpcSession("second-fallback-session"), undefined);
+  assert.equal(getRpcSession(runtimeId), wrapper);
+  assert.equal(getRpcSession(runtimeId).sessionId, inner.sessionId);
+  const recovered = await startRpcSession(runtimeId, "/missing/session.jsonl", undefined);
+  assert.equal(recovered.session, wrapper);
+  assert.equal(recovered.realSessionId, inner.sessionId);
+  assert.equal(getRpcSession("fallback-session"), historical);
+  assert.equal(events.filter((event) => event.type === "session_changed").length, 2);
+
+  wrapper.destroy();
+  assert.equal(getRpcSession(runtimeId), undefined);
+  assert.equal(getFinalRpcSessionId(runtimeId), inner.sessionId);
+  assert.equal(getRpcSessionActivitySnapshot().sessionIdsByRuntimeId[runtimeId], inner.sessionId);
+  assert.equal(getRpcSession(inner.sessionId), undefined);
+  assert.equal(getRpcSession("fallback-session"), historical);
+  assert.deepEqual([...globalThis.__ompSessions.keys()], ["fallback-session"]);
+});
+
+
+test("upgrades a retained wrapper without replacing its active SDK session", (t) => {
+  const previousRegistry = globalThis.__ompSessions;
+  const previousFinalIds = globalThis.__ompFinalSessionIds;
+  globalThis.__ompFinalSessionIds = new Map();
+  const inner = { sessionId: "before-hmr", isStreaming: true, isBashRunning: false };
+  const wrapper = new AgentSessionWrapper(inner, { on: () => () => {} });
+  const events = [];
+  wrapper.onEvent((event) => events.push(event));
+  wrapper.onDestroy(() => globalThis.__ompSessions.delete("before-hmr"));
+  let reopened;
+  const legacyPrototype = Object.create(AgentSessionWrapper.prototype);
+  Object.defineProperty(legacyPrototype, "syncSessionIdentity", { value: undefined });
+  Object.setPrototypeOf(wrapper, legacyPrototype);
+  delete wrapper.runtimeId;
+  globalThis.__ompSessions = new Map([[inner.sessionId, wrapper]]);
+  t.after(() => {
+    wrapper.destroy();
+    reopened?.destroy();
+    globalThis.__ompSessions = previousRegistry;
+    globalThis.__ompFinalSessionIds = previousFinalIds;
+  });
+
+  inner.sessionId = "after-hmr-fallback";
+  assert.equal(getRpcSession("before-hmr"), undefined);
+  assert.equal(wrapper.inner, inner);
+  assert.equal(wrapper.isRunning(), true);
+  assert.match(wrapper.runtimeId, /^runtime:/);
+  const runtimeId = wrapper.runtimeId;
+  assert.equal(getRpcSession(runtimeId), wrapper);
+  assert.equal(wrapper.runtimeId, runtimeId);
+  // A previous identity-aware module also needs its implementation upgraded.
+  Object.setPrototypeOf(wrapper, Object.create(AgentSessionWrapper.prototype));
+  assert.equal(getRpcSession(runtimeId), wrapper);
+  assert.equal(Object.getPrototypeOf(wrapper), AgentSessionWrapper.prototype);
+  assert.equal(wrapper.runtimeId, runtimeId);
+  assert.equal(getRpcSession("before-hmr"), undefined);
+  assert.deepEqual(events, [{ type: "session_changed", sessionId: inner.sessionId, runtimeId }]);
+  reopened = new AgentSessionWrapper({ sessionId: "before-hmr", isBashRunning: false }, { on: () => () => {} });
+  globalThis.__ompSessions.set("before-hmr", reopened);
+  wrapper.destroy();
+  assert.equal(getRpcSession("before-hmr"), reopened);
+});
diff --git a/lib/types.ts b/lib/types.ts
index d8f5a09acd..13c89b55d7 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -392,6 +392,8 @@ export interface SessionTreeNode {
 }
 
 export interface SessionInfo {
+  /** Client continuation handle; never a persisted transcript ID or history alias. */
+  runtimeId?: string;
   path: string;
   id: string;
   cwd: string;
diff --git a/lib/workspace-memory.test.mjs b/lib/workspace-memory.test.mjs
index cfaf2f6e2b..147d67957d 100644
--- a/lib/workspace-memory.test.mjs
+++ b/lib/workspace-memory.test.mjs
@@ -8,6 +8,10 @@ const {
   setLastOpenSession,
   clearLastOpen,
   workspaceKeyOf,
+  getSessionContinuation,
+  rememberSessionContinuation,
+  clearSessionContinuation,
+  restoreSessionContinuation,
 } = await jiti.import("./workspace-memory.ts");
 
 function createStorage(initial = {}) {
@@ -123,3 +127,30 @@ test("workspaceKeyOf prefers projectRoot over cwd", () => {
   assert.equal(workspaceKeyOf({ cwd: "/plain/dir", projectRoot: null }), "/plain/dir");
   assert.equal(workspaceKeyOf({ cwd: "/plain/dir" }), "/plain/dir");
 });
+
+
+test("a tab restores only its active runtime and explicit history selection clears it", () => {
+  const tab = createStorage();
+  rememberSessionContinuation("session-a", "runtime:live", tab);
+  assert.equal(getSessionContinuation("session-a", tab), "runtime:live");
+  assert.equal(getSessionContinuation("session-b", tab), undefined);
+  assert.equal(getSessionContinuation("session-a", createStorage()), undefined);
+  rememberSessionContinuation("session-b", "runtime:live", tab);
+  assert.equal(getSessionContinuation("session-a", tab), undefined);
+  assert.equal(getSessionContinuation("session-b", tab), "runtime:live");
+  clearSessionContinuation(tab, "runtime:older");
+  assert.equal(getSessionContinuation("session-b", tab), "runtime:live");
+  clearSessionContinuation(tab, "runtime:live");
+  assert.equal(getSessionContinuation("session-b", tab), undefined);
+});
+
+
+test("restores a relocated transient session when its original row is absent", () => {
+  const tab = createStorage();
+  rememberSessionContinuation("unflushed-a", "runtime:live", tab);
+  const current = { id: "live-b", cwd: "/project", transient: true };
+  assert.deepEqual(restoreSessionContinuation("unflushed-a", [current], { "runtime:live": "live-b" }, tab), {
+    ...current, runtimeId: "runtime:live",
+  });
+  assert.equal(restoreSessionContinuation("unflushed-a", [current], { "runtime:live": "live-b" }, createStorage()), undefined);
+});
diff --git a/lib/workspace-memory.ts b/lib/workspace-memory.ts
index f063fa0aff..d7592f86bc 100644
--- a/lib/workspace-memory.ts
+++ b/lib/workspace-memory.ts
@@ -1,3 +1,5 @@
+import type { SessionInfo } from "./types";
+
 /**
  * Per-workspace "last open session" memory.
  *
@@ -96,3 +98,47 @@ export function workspaceKeyOf(session: {
 }): string {
   return session.projectRoot ?? session.cwd;
 }
+
+
+// A single per-tab continuation survives refresh without aliasing history in
+// other tabs. Explicit session selection clears it before opening history.
+const CONTINUATION_KEY = "pi-web:active-runtime";
+
+function getTabStorage(): StorageLike | null {
+  if (typeof window === "undefined") return null;
+  try { return window.sessionStorage; } catch { return null; }
+}
+
+export function getSessionContinuation(sessionId: string, storage: StorageLike | null = getTabStorage()): string | undefined {
+  try {
+    const record = JSON.parse(storage?.getItem(CONTINUATION_KEY) ?? "null");
+    return record?.sessionId === sessionId && typeof record.runtimeId === "string" && record.runtimeId.startsWith("runtime:")
+      ? record.runtimeId : undefined;
+  } catch { return undefined; }
+}
+
+export function rememberSessionContinuation(sessionId: string, runtimeId: string, storage: StorageLike | null = getTabStorage()): void {
+  try { storage?.setItem(CONTINUATION_KEY, JSON.stringify({ sessionId, runtimeId })); } catch { /* Storage is optional. */ }
+}
+
+export function clearSessionContinuation(storage: StorageLike | null = getTabStorage(), expectedRuntimeId?: string): void {
+  try {
+    if (expectedRuntimeId && JSON.parse(storage?.getItem(CONTINUATION_KEY) ?? "null")?.runtimeId !== expectedRuntimeId) return;
+    storage?.removeItem(CONTINUATION_KEY);
+  } catch { /* Storage is optional. */ }
+}
+
+
+/** Resolve a saved tab continuation before requiring its old history row. */
+export function restoreSessionContinuation(
+  sessionId: string,
+  sessions: SessionInfo[],
+  sessionIdsByRuntimeId: Record<string, string> = {},
+  storage: StorageLike | null = getTabStorage(),
+): SessionInfo | undefined {
+  const runtimeId = getSessionContinuation(sessionId, storage);
+  const canonicalId = runtimeId ? sessionIdsByRuntimeId[runtimeId] ?? sessionId : sessionId;
+  const session = sessions.find((entry) => entry.id === canonicalId)
+    ?? sessions.find((entry) => entry.id === sessionId);
+  return session ? { ...session, id: canonicalId, runtimeId } : undefined;
+}