diff --git a/apps/ade-cli/README.md b/apps/ade-cli/README.md
index 36e487017..da8cd04e2 100644
--- a/apps/ade-cli/README.md
+++ b/apps/ade-cli/README.md
@@ -382,7 +382,8 @@ ade terminal resume --terminal session-id --text
 ade new chat --mode chat --lane lane-id --provider codex --model openai/gpt-5.6-sol --reasoning-effort xhigh --no-fast --permissions full-auto --prompt "fix failing tests"
 ade new chat --mode cli --lane lane-id --provider codex --model openai/gpt-5.6-sol --reasoning-effort xhigh --no-fast --permissions full-auto --prompt "fix failing tests"
 ade new chat --mode chat --lane auto --lane-name fix-checkout-flow --prompt "fix failing tests"
-ade new chat --mode chat --lane lane-id --type subagent --prompt "repro the flake"   # --type subagent|peer|none (chat mode only): cosmetic relationship + completion-report policy — subagent wakes the parent on completion, peer leaves a quiet note, none (default) is silent; a typed agent is still a full agent
+ade new chat --mode chat --lane lane-id --type subagent --prompt "repro the flake"   # --type subagent|peer|none: cosmetic relationship + completion-report policy — subagent wakes the parent on completion, peer leaves a quiet note, none (default) is silent; a typed agent is still a full agent
+ade new chat --mode cli --lane lane-id --provider codex --type peer --parent chat-session-id --prompt "review the diff"   # agent-provider CLI sessions record spawn lineage without becoming attached terminals; shell sessions do not record lineage
 ade chat list --lane lane-id --include-automation --no-archived --text
 ade chat create --lane lane-id --provider codex --model openai/gpt-5.6-sol --permissions full-auto --print-config --json
 ade chat create --lane lane-id --provider codex --no-parent   # spawned chats default their parent to $ADE_CHAT_SESSION_ID; --parent <session> overrides, --no-parent opts out
diff --git a/apps/ade-cli/src/adeRpcServer.test.ts b/apps/ade-cli/src/adeRpcServer.test.ts
index 14ca2a6d4..abc88e2f1 100644
--- a/apps/ade-cli/src/adeRpcServer.test.ts
+++ b/apps/ade-cli/src/adeRpcServer.test.ts
@@ -1763,6 +1763,61 @@ describe("adeRpcServer", () => {
     });
   });
 
+  it("persists CLI spawn lineage in resume metadata without assigning terminal ownership", async () => {
+    const fixture = createRuntime();
+    fixture.runtime.sessionService.get.mockReturnValue({
+      id: "session-1",
+      laneId: "lane-1",
+      ptyId: "pty-1",
+      tracked: true,
+      toolType: "codex",
+      title: "Codex",
+      status: "running",
+      resumeCommand: null,
+      resumeMetadata: {
+        provider: "codex",
+        targetKind: "thread",
+        targetId: null,
+        launch: { permissionMode: "default" },
+        orchestrationParentSessionId: "parent-session-1",
+        spawnKind: "peer",
+      },
+      chatSessionId: null,
+      orchestrationParentSessionId: "parent-session-1",
+      spawnKind: "peer",
+    });
+    const handler = createAdeRpcRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
+
+    await initialize(handler, { role: "orchestrator" });
+    const response = await callTool(handler, "start_cli_session", {
+      laneId: "lane-1",
+      provider: "codex",
+      orchestrationParentSessionId: "  parent-session-1  ",
+      spawnKind: "peer",
+    });
+
+    expect(response?.isError).toBeUndefined();
+    const createCall = fixture.runtime.ptyService.create.mock.calls.at(-1)?.[0];
+    expect(createCall).toEqual(expect.objectContaining({
+      resumeMetadata: expect.objectContaining({
+        provider: "codex",
+        targetKind: "thread",
+        orchestrationParentSessionId: "parent-session-1",
+        spawnKind: "peer",
+      }),
+      spawnLineage: {
+        parentChatSessionId: "parent-session-1",
+        spawnKind: "peer",
+      },
+    }));
+    expect(createCall).not.toHaveProperty("chatSessionId");
+    expect(response.structuredContent.session).toEqual(expect.objectContaining({
+      orchestrationParentSessionId: "parent-session-1",
+      spawnKind: "peer",
+      chatSessionId: null,
+    }));
+  });
+
   it("preserves wide start_cli_session terminal dimensions", async () => {
     const fixture = createRuntime();
     fixture.runtime.sessionService.get.mockReturnValue({
diff --git a/apps/ade-cli/src/adeRpcServer.ts b/apps/ade-cli/src/adeRpcServer.ts
index dcd468ff2..a333d1103 100644
--- a/apps/ade-cli/src/adeRpcServer.ts
+++ b/apps/ade-cli/src/adeRpcServer.ts
@@ -59,7 +59,7 @@ import {
   type LaunchProfile,
   type TrackedCliLaunchCommand,
 } from "../../desktop/src/shared/cliLaunch";
-import type { AgentChatPermissionMode, TerminalSessionSummary } from "../../desktop/src/shared/types";
+import type { AgentChatPermissionMode, AgentChatSpawnKind, TerminalResumeMetadata, TerminalSessionSummary } from "../../desktop/src/shared/types";
 import type { AdeRuntime } from "./bootstrap";
 import {
   recordUsageInteraction,
@@ -72,6 +72,7 @@ import { getSharedModelPickerStore } from "./services/modelPickerStore";
 import { resolveLaneCreateRemoteBase } from "./services/laneCreateRemoteBase";
 import { BUILT_IN_BROWSER_ACTOR_CAPABILITY_PARAM } from "./services/builtInBrowser/desktopBridgeMethods";
 import { resolveCodexComputerUseMcpConfig } from "../../desktop/src/main/utils/codexComputerUse";
+import { parseTrackedCliLaunchConfig } from "../../desktop/src/main/utils/terminalSessionSignals";
 
 // Cross-surface (desktop + TUI + iOS) model picker favorites & recents.
 // Backed by the per-project cr-sqlite CRR DB (runtime.db) so the three surfaces
@@ -337,6 +338,8 @@ const TOOL_SPECS: ToolSpec[] = [
         codexFastMode: { type: "boolean", deprecated: true },
         cwd: { type: "string" },
         chatSessionId: { type: "string" },
+        orchestrationParentSessionId: { type: "string", minLength: 1 },
+        spawnKind: { type: "string", enum: ["subagent", "peer", "none"] },
         tracked: { type: "boolean", default: true }
       }
     }
@@ -1708,6 +1711,18 @@ function parseCliSessionPermissionMode(value: unknown): AgentChatPermissionMode
   );
 }
 
+function parseCliSessionSpawnKind(value: unknown): AgentChatSpawnKind | null {
+  if (value == null) return null;
+  const spawnKind = asTrimmedString(value).toLowerCase();
+  if (spawnKind === "subagent" || spawnKind === "peer" || spawnKind === "none") {
+    return spawnKind;
+  }
+  throw new JsonRpcError(
+    JsonRpcErrorCode.invalidParams,
+    "spawnKind must be one of subagent, peer, or none",
+  );
+}
+
 function clampInteger(value: unknown, fallback: number, min: number, max: number): number {
   const raw = typeof value === "number" && Number.isFinite(value) ? value : fallback;
   return Math.max(min, Math.min(max, Math.floor(raw)));
@@ -3589,6 +3604,10 @@ async function runTool(args: {
     const laneId = assertNonEmptyString(toolArgs.laneId, "laneId");
     const provider = parseCliSessionProvider(toolArgs.provider);
     const permissionMode = parseCliSessionPermissionMode(toolArgs.permissionMode);
+    const orchestrationParentSessionId = toolArgs.orchestrationParentSessionId == null
+      ? null
+      : assertNonEmptyString(toolArgs.orchestrationParentSessionId, "orchestrationParentSessionId");
+    const spawnKind = parseCliSessionSpawnKind(toolArgs.spawnKind);
     try {
       validateLaunchProfilePermissionMode(provider, permissionMode);
     } catch (err) {
@@ -3634,6 +3653,17 @@ async function runTool(args: {
         ...(provider === "codex" ? { codexComputerUse } : {}),
       });
     })();
+    const toolType = LAUNCH_PROFILE_TOOL_TYPE[provider];
+    const resumeMetadata: TerminalResumeMetadata | null = isCliProvider(provider)
+      ? {
+          provider,
+          targetKind: provider === "codex" ? "thread" : "session",
+          targetId: provider === "claude" ? preassignedSessionId ?? null : null,
+          launch: parseTrackedCliLaunchConfig(launchFields.startupCommand ?? "", toolType) ?? {},
+          ...(orchestrationParentSessionId ? { orchestrationParentSessionId } : {}),
+          ...(spawnKind ? { spawnKind } : {}),
+        }
+      : null;
 
     const created = await ptyService.create({
       ...(preassignedSessionId ? { sessionId: preassignedSessionId } : {}),
@@ -3643,7 +3673,11 @@ async function runTool(args: {
       rows,
       title,
       tracked: toolArgs.tracked !== false,
-      toolType: LAUNCH_PROFILE_TOOL_TYPE[provider],
+      toolType,
+      ...(resumeMetadata ? { resumeMetadata } : {}),
+      ...(isCliProvider(provider) && orchestrationParentSessionId
+        ? { spawnLineage: { parentChatSessionId: orchestrationParentSessionId, spawnKind } }
+        : {}),
       ...(asOptionalTrimmedString(toolArgs.cwd) ? { cwd: asOptionalTrimmedString(toolArgs.cwd)! } : {}),
       ...(asOptionalTrimmedString(toolArgs.chatSessionId) ? { chatSessionId: asOptionalTrimmedString(toolArgs.chatSessionId) } : {}),
       ...launchFields,
diff --git a/apps/ade-cli/src/cli.test.ts b/apps/ade-cli/src/cli.test.ts
index 37cf43a83..d073b88ab 100644
--- a/apps/ade-cli/src/cli.test.ts
+++ b/apps/ade-cli/src/cli.test.ts
@@ -2442,6 +2442,90 @@ describe("ADE CLI", () => {
       expect((staticPlan.value as { launch: Record<string, unknown> }).launch.orchestrationParentSessionId)
         .toBe("parent-session-1");
     });
+
+    it("ade new chat --mode cli records the env parent as spawn lineage without terminal ownership", () => {
+      process.env.ADE_CHAT_SESSION_ID = "parent-session-1";
+      const plan = buildCliPlan([
+        "new", "chat",
+        "--mode", "cli",
+        "--lane", "lane-1",
+        "--provider", "codex",
+        "--type", "peer",
+        "--print-config",
+      ]);
+      const staticPlan = expectStaticPlan(plan);
+      const launch = (staticPlan.value as { launch: Record<string, unknown> }).launch;
+      expect(launch.orchestrationParentSessionId).toBe("parent-session-1");
+      expect(launch.spawnKind).toBe("peer");
+      expect(launch).not.toHaveProperty("chatSessionId");
+    });
+
+    it("ade new chat --mode cli --no-parent leaves the terminal unlinked", () => {
+      process.env.ADE_CHAT_SESSION_ID = "parent-session-1";
+      const plan = buildCliPlan([
+        "new", "chat",
+        "--mode", "cli",
+        "--lane", "lane-1",
+        "--provider", "codex",
+        "--no-parent",
+        "--print-config",
+      ]);
+      const staticPlan = expectStaticPlan(plan);
+      const launch = (staticPlan.value as { launch: Record<string, unknown> }).launch;
+      expect(launch).not.toHaveProperty("orchestrationParentSessionId");
+      expect(launch).not.toHaveProperty("chatSessionId");
+    });
+
+    it("--auto-create-lane keeps --parent as the spawn-lineage session, not the lane parent", () => {
+      delete process.env.ADE_CHAT_SESSION_ID;
+      const plan = buildCliPlan([
+        "new", "chat",
+        "--mode", "chat",
+        "--auto-create-lane",
+        "--lane-name", "spawn-target",
+        "--provider", "codex",
+        "--parent", "parent-session-1",
+        "--print-config",
+      ]);
+      const staticPlan = expectStaticPlan(plan);
+      const value = staticPlan.value as { launch: Record<string, unknown>; createLane?: Record<string, unknown> };
+      expect(value.launch.orchestrationParentSessionId).toBe("parent-session-1");
+      expect(value.createLane ?? {}).not.toHaveProperty("parentLaneId");
+    });
+
+    it("--auto-create-lane --parent-lane still sets the lane parent without touching lineage", () => {
+      delete process.env.ADE_CHAT_SESSION_ID;
+      const plan = buildCliPlan([
+        "new", "chat",
+        "--mode", "chat",
+        "--auto-create-lane",
+        "--lane-name", "spawn-target",
+        "--provider", "codex",
+        "--parent-lane", "lane-parent-1",
+        "--print-config",
+      ]);
+      const staticPlan = expectStaticPlan(plan);
+      const value = staticPlan.value as { launch: Record<string, unknown>; createLane?: Record<string, unknown> };
+      expect(value.createLane?.parentLaneId).toBe("lane-parent-1");
+      expect(value.launch).not.toHaveProperty("orchestrationParentSessionId");
+    });
+
+    it("does not record spawn lineage for plain shell terminals", () => {
+      process.env.ADE_CHAT_SESSION_ID = "parent-session-1";
+      const plan = buildCliPlan([
+        "new", "chat",
+        "--mode", "cli",
+        "--lane", "lane-1",
+        "--provider", "shell",
+        "--type", "peer",
+        "--print-config",
+      ]);
+      const staticPlan = expectStaticPlan(plan);
+      const launch = (staticPlan.value as { launch: Record<string, unknown> }).launch;
+      expect(launch.provider).toBe("shell");
+      expect(launch).not.toHaveProperty("orchestrationParentSessionId");
+      expect(launch).not.toHaveProperty("spawnKind");
+    });
   });
 
   it("prints chat create --prompt dry-run with the follow-up send", () => {
@@ -5680,6 +5764,15 @@ describe("ADE CLI", () => {
     expect(newChatHelp.kind).toBe("help");
     if (newChatHelp.kind !== "help") return;
     expect(newChatHelp.text).toContain("--type <subagent|peer|none>");
+    expect(newChatHelp.text).toContain("Override with --parent <sessionId>");
+    expect(newChatHelp.text).toContain("plain shell terminals don't record lineage");
+
+    const newHelp = buildCliPlan(["new", "--help"]);
+    expect(newHelp.kind).toBe("help");
+    if (newHelp.kind !== "help") return;
+    expect(newHelp.text).toContain("--type <subagent|peer|none>");
+    expect(newHelp.text).toContain("--parent <sessionId>");
+    expect(newHelp.text).toContain("Plain shell terminals do not record lineage");
 
     const laneCommandHelp = buildCliPlan(["help", "lanes"]);
     expect(laneCommandHelp.kind).toBe("help");
diff --git a/apps/ade-cli/src/cli.ts b/apps/ade-cli/src/cli.ts
index 123d3fadb..206534e44 100644
--- a/apps/ade-cli/src/cli.ts
+++ b/apps/ade-cli/src/cli.ts
@@ -1378,6 +1378,12 @@ const HELP_BY_COMMAND: Record<string, string> = {
     --no-fast, --standard  Disable fast service tier explicitly.
     --prompt <text>        First chat message or CLI initial input.
 
+  Spawn lineage:
+    In tracked agent shells, chat mode and agent-provider CLI mode default
+    their parent to $ADE_CHAT_SESSION_ID. Use --parent <sessionId> to override
+    it or --no-parent to opt out. CLI terminals record lineage without taking
+    attached-terminal ownership. Plain shell terminals do not record lineage.
+
   Compatibility:
     ade chat create still creates persistent Work chats.
     ade shell start-cli still starts tracked provider CLI sessions.
@@ -1397,6 +1403,12 @@ const HELP_BY_COMMAND: Record<string, string> = {
   The command defaults to the current ADE lane when ADE_LANE_ID is set. Use
   --auto-create-lane or --lane auto to create a lane before launching.
   --type <subagent|peer|none> sets only the cosmetic relationship and completion-report policy; a typed agent is a full agent. subagent wakes the parent, peer leaves a quiet note, and none (default) sends no report.
+
+  Spawn lineage: when run from a tracked agent shell (ADE_CHAT_SESSION_ID set),
+  the new session links back to the spawning chat. In CLI mode, the terminal
+  shows that spawn lineage on its own sidebar card and links back to the chat
+  (agent providers only — plain shell terminals don't record lineage).
+  Override with --parent <sessionId>; opt out with --no-parent.
 `,
   lanes: `${ADE_BANNER}
   Lanes
@@ -2535,12 +2547,12 @@ function readLaneId(args: string[]): string | null {
 }
 
 /**
- * Parent chat-session lineage for spawned chat sessions. Defaults to the
- * spawning agent's own session — ADE injects ADE_CHAT_SESSION_ID into every
- * tracked agent shell (chat runtimes and tracked CLI/PTY sessions) — so a
- * child created via `ade chat create` links back to the chat that spawned it
- * instead of becoming an orphan. `--parent <sessionId>` overrides the
- * default; `--no-parent` opts out entirely.
+ * Parent chat-session lineage for spawned chat and agent-provider CLI
+ * sessions. Defaults to the spawning agent's own session — ADE injects
+ * ADE_CHAT_SESSION_ID into every tracked agent shell (chat runtimes and
+ * tracked CLI/PTY sessions). `--parent <sessionId>` overrides the default;
+ * `--no-parent` opts out entirely. CLI callers keep chatSessionId separate
+ * because that field represents attached-terminal ownership, not lineage.
  */
 function readParentSessionId(args: string[]): string | undefined {
   const override = readValue(args, ["--parent", "--parent-session", "--parent-session-id"]);
@@ -4163,7 +4175,11 @@ function resolveNewChatLaneArgs(args: string[], prompt: string | null): {
   maybePut(createLaneArgs, "description", readValue(args, ["--description", "--desc"]));
   maybePut(createLaneArgs, "baseBranch", readValue(args, ["--base", "--base-branch"]));
   maybePut(createLaneArgs, "branchName", readValue(args, ["--branch-name"]));
-  maybePut(createLaneArgs, "parentLaneId", readValue(args, ["--parent", "--parent-lane", "--parent-lane-id"]));
+  // No bare `--parent` alias here: in `ade new chat` that flag is documented as
+  // the spawn-lineage parent SESSION (readParentSessionId), and this resolver
+  // runs first — consuming it would silently eat the lineage flag whenever
+  // --auto-create-lane is used. Lane parentage keeps the explicit aliases.
+  maybePut(createLaneArgs, "parentLaneId", readValue(args, ["--parent-lane", "--parent-lane-id"]));
   return { laneId: null, autoCreateLane: true, createLaneArgs };
 }
 
@@ -4184,7 +4200,7 @@ function buildNewChatPlan(args: string[], defaultMode: "chat" | "cli"): CliPlan
   const reasoningEffort = readValue(args, ["--reasoning-effort", "--effort", "--reasoning"]);
   const permissionMode = readValue(args, ["--permission-mode", "--permissions"]);
   const spawnTypeArg = readValue(args, ["--type", "--spawn-type"]);
-  const spawnKind = mode === "chat" ? spawnTypeArg?.trim().toLowerCase() : undefined;
+  const spawnKind = spawnTypeArg?.trim().toLowerCase();
   const fastMode = readFastModeFlag(args);
   const title = readValue(args, ["--title"]);
   const printConfig = readFlag(args, ["--print-config", "--dry-run"]);
@@ -4218,10 +4234,10 @@ function buildNewChatPlan(args: string[], defaultMode: "chat" | "cli"): CliPlan
   };
 
   // Consume the flags in both modes so they never leak into the generic arg
-  // bag; lineage only applies to chat mode (a PTY session is not a chat
-  // record, so there is nothing to link).
+  // bag. Both chat and CLI modes record the same spawn lineage fields; CLI
+  // sessions keep chatSessionId free for true attached-terminal ownership.
   const parentSessionId = readParentSessionId(args);
-  const orchestrationParentSessionId = mode === "chat" ? parentSessionId : undefined;
+  const orchestrationParentSessionId = parentSessionId;
   const launchArgs = mode === "chat"
     ? collectGenericObjectArgs(args, {
         provider,
@@ -4249,6 +4265,10 @@ function buildNewChatPlan(args: string[], defaultMode: "chat" | "cli"): CliPlan
         modelId: modelArg,
         reasoningEffort,
         ...(fastMode !== undefined ? { fastMode, codexFastMode: fastMode } : {}),
+        // Spawn lineage rides on resume metadata, which only agent providers
+        // have — plain shell terminals can't persist it, so don't pretend.
+        ...(provider !== "shell" && orchestrationParentSessionId ? { orchestrationParentSessionId } : {}),
+        ...(provider !== "shell" && spawnKind ? { spawnKind } : {}),
         cols: readIntOption(args, ["--cols"], 120),
         rows: readIntOption(args, ["--rows"], 36),
         cwd: readValue(args, ["--cwd"]),
diff --git a/apps/ade-cli/src/tuiClient/__tests__/Drawer.test.tsx b/apps/ade-cli/src/tuiClient/__tests__/Drawer.test.tsx
index 8cb0b914b..c6d0c2037 100644
--- a/apps/ade-cli/src/tuiClient/__tests__/Drawer.test.tsx
+++ b/apps/ade-cli/src/tuiClient/__tests__/Drawer.test.tsx
@@ -134,6 +134,25 @@ describe("Drawer closed CLI sessions", () => {
     });
   });
 
+  it("projects spawn lineage from tracked CLI resume metadata", () => {
+    const summary = terminalSessionToChatSummary(terminal({
+      terminalId: "cli-subagent",
+      resumeMetadata: {
+        provider: "codex",
+        targetKind: "session",
+        targetId: "cli-subagent",
+        launch: {},
+        orchestrationParentSessionId: "parent-chat",
+        spawnKind: "subagent",
+      },
+    }));
+
+    expect(summary).toMatchObject({
+      orchestrationParentSessionId: "parent-chat",
+      spawnKind: "subagent",
+    });
+  });
+
   it.each([
     ["failed status", { status: "failed", exitCode: 1, runtimeState: "killed" }, "failed"],
     ["non-zero exit", { status: "completed", exitCode: 2, runtimeState: "exited" }, "failed"],
@@ -172,6 +191,61 @@ describe("Drawer closed CLI sessions", () => {
 });
 
 describe("Drawer lane and chat navigation layout", () => {
+  it("renders compact spawn-kind markers for chat and tracked CLI rows", () => {
+    const chat: AgentChatSessionSummary = {
+      sessionId: "chat-subagent",
+      laneId: "lane-1",
+      provider: "claude",
+      model: "claude-code",
+      title: "Chat child",
+      status: "idle",
+      startedAt: "2026-05-12T11:30:00.000Z",
+      endedAt: null,
+      lastActivityAt: "2026-05-12T11:31:00.000Z",
+      lastOutputPreview: null,
+      summary: null,
+      nextWakeAt: null,
+      orchestrationParentSessionId: "parent-chat",
+      spawnKind: "subagent",
+    };
+    const cli = terminalSessionToChatSummary(terminal({
+      terminalId: "cli-peer",
+      resumeMetadata: {
+        provider: "codex",
+        targetKind: "session",
+        targetId: "cli-peer",
+        launch: {},
+        orchestrationParentSessionId: "parent-chat",
+        spawnKind: "peer",
+      },
+    }));
+
+    const baseProps = {
+      lanes: [lane("lane-1", "Feature", "feature/spawn-kind", "2026-05-12T11:55:00.000Z")],
+      activeLaneId: "lane-1",
+      activeSessionId: null,
+      browsingLaneId: "lane-1",
+      selectedLaneIndex: 0,
+      selectedChatIndex: -1,
+      panelHeight: 30,
+    };
+    const chatFrame = stripAnsi(render(
+      <Drawer
+        {...baseProps}
+        sessions={[chat]}
+      />,
+    ).lastFrame() ?? "");
+    const cliFrame = stripAnsi(render(
+      <Drawer
+        {...baseProps}
+        sessions={[cli]}
+      />,
+    ).lastFrame() ?? "");
+
+    expect(chatFrame).toContain("Chat child sub");
+    expect(cliFrame).toContain("Codex CLI peer");
+  });
+
   it("puts the primary lane first and removes old header/footer controls", () => {
     const frame = stripAnsi(render(
       <Drawer
diff --git a/apps/ade-cli/src/tuiClient/app.tsx b/apps/ade-cli/src/tuiClient/app.tsx
index d23a7a01a..046a6fa08 100644
--- a/apps/ade-cli/src/tuiClient/app.tsx
+++ b/apps/ade-cli/src/tuiClient/app.tsx
@@ -890,6 +890,7 @@ export function chatSessionToOptimisticSummary(
     ...(session.orchestrationRunId ? { orchestrationRunId: session.orchestrationRunId } : {}),
     ...(session.orchestrationRole ? { orchestrationRole: session.orchestrationRole } : {}),
     ...(session.orchestrationParentSessionId ? { orchestrationParentSessionId: session.orchestrationParentSessionId } : {}),
+    ...(session.spawnKind ? { spawnKind: session.spawnKind } : {}),
     ...(session.orchestrationTag ? { orchestrationTag: session.orchestrationTag } : {}),
     ...(session.orchestrationStepId ? { orchestrationStepId: session.orchestrationStepId } : {}),
     ...(session.orchestrationBundlePath ? { orchestrationBundlePath: session.orchestrationBundlePath } : {}),
diff --git a/apps/ade-cli/src/tuiClient/closedCliSessions.ts b/apps/ade-cli/src/tuiClient/closedCliSessions.ts
index 7c55dfba2..6cef263e0 100644
--- a/apps/ade-cli/src/tuiClient/closedCliSessions.ts
+++ b/apps/ade-cli/src/tuiClient/closedCliSessions.ts
@@ -80,6 +80,12 @@ export function terminalSessionToChatSummary(
     scheduledWorkPaused: scheduledWorkState?.paused === true,
     scheduledWork: scheduledWorkState?.items ?? [],
     surface: "work",
+    ...(session.resumeMetadata?.orchestrationParentSessionId
+      ? { orchestrationParentSessionId: session.resumeMetadata.orchestrationParentSessionId }
+      : {}),
+    ...(session.resumeMetadata?.spawnKind
+      ? { spawnKind: session.resumeMetadata.spawnKind }
+      : {}),
     terminalStatus: session.status,
     terminalExitCode: session.exitCode,
     terminalRuntimeState: session.runtimeState,
diff --git a/apps/ade-cli/src/tuiClient/components/Drawer.tsx b/apps/ade-cli/src/tuiClient/components/Drawer.tsx
index c220612ff..cee9fb116 100644
--- a/apps/ade-cli/src/tuiClient/components/Drawer.tsx
+++ b/apps/ade-cli/src/tuiClient/components/Drawer.tsx
@@ -635,9 +635,18 @@ function ChatRow({
   // the title truncates ahead of it instead of colliding.
   const tag = session.claudeTag?.trim() ? `#${truncate(session.claudeTag.trim(), 16)}` : null;
   const tagReserve = tag ? tag.length + 1 : 0;
+  // Spawn lineage shares the established trailing-marker slot with chat tags
+  // and durable wakes. Keep the labels compact in the narrow drawer while
+  // still distinguishing subagents from peers; untyped (`none`) work stays
+  // visually quiet, matching the desktop session card.
+  const spawnKind = session.spawnKind === "subagent" || session.spawnKind === "peer"
+    ? session.spawnKind
+    : null;
+  const spawnLabel = spawnKind === "subagent" ? "sub" : spawnKind;
+  const spawnReserve = spawnLabel ? spawnLabel.length + 1 : 0;
   // The age used to reserve trailing room; without it the title can run wider,
   // keeping just a little space for the spinner + active dot.
-  const label = truncate(formatSessionLabel(session), drawerChatLabelWidth(max, wakeReserve + tagReserve));
+  const label = truncate(formatSessionLabel(session), drawerChatLabelWidth(max, wakeReserve + tagReserve + spawnReserve));
   // Selection/hover wins with violet; awaiting-input tints amber as a calm
   // "needs you" signal; otherwise the title sits a touch dimmer under a
   // non-selected lane (dimTitle) than under the focused one.
@@ -652,6 +661,9 @@ function ChatRow({
         {running ? <Text>{"  "}</Text> : <Text color={dot.color} bold={session.awaitingInput}>{dot.glyph} </Text>}
         <Text color={exec.color}>{exec.glyph} </Text>
         <Text color={titleColor}>{label}</Text>
+        {spawnLabel ? (
+          <Text color={spawnKind === "subagent" ? theme.color.violet : theme.color.t4}>{` ${spawnLabel}`}</Text>
+        ) : null}
         {tag ? <Text color={theme.color.t4}>{` ${tag}`}</Text> : null}
         {wake ? <Text color={theme.color.t4}>{` ⏰${wake}`}</Text> : null}
         {running ? <Text> <ActiveChatSpin /></Text> : null}
diff --git a/apps/desktop/src/main/services/pty/ptyService.test.ts b/apps/desktop/src/main/services/pty/ptyService.test.ts
index a695cb64d..ba00a9b61 100644
--- a/apps/desktop/src/main/services/pty/ptyService.test.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.test.ts
@@ -886,6 +886,63 @@ describe("ptyService", () => {
       expect(resolveBuiltInBrowserActorCapability(actorToken)).toBeNull();
     });
 
+    it("exports spawn lineage without replacing the tracked CLI session identity", async () => {
+      const { service, loadPty } = createHarness();
+
+      const result = await service.create({
+        laneId: "lane-1",
+        title: "Codex child",
+        cols: 80,
+        rows: 24,
+        toolType: "codex",
+        command: "codex",
+        spawnLineage: {
+          parentChatSessionId: "parent-session-1",
+          spawnKind: null,
+        },
+      });
+
+      const ptyLib = loadPty.mock.results.at(-1)?.value as { spawn: ReturnType<typeof vi.fn> };
+      const spawnArgs = ptyLib.spawn.mock.calls.at(-1);
+      const opts = spawnArgs?.[2] as { env?: NodeJS.ProcessEnv } | undefined;
+      expect(opts?.env).toEqual(expect.objectContaining({
+        ADE_CHAT_SESSION_ID: result.sessionId,
+        ADE_PARENT_CHAT_SESSION_ID: "parent-session-1",
+        ADE_SPAWN_KIND: "",
+      }));
+      expect(opts?.env?.ADE_CHAT_SESSION_ID).not.toBe("parent-session-1");
+    });
+
+    it("strips inherited parent lineage env when the launch has no spawn lineage", async () => {
+      const previousParent = process.env.ADE_PARENT_CHAT_SESSION_ID;
+      const previousKind = process.env.ADE_SPAWN_KIND;
+      // The daemon can itself run inside a spawned agent shell; those inherited
+      // vars must not leak into terminals created without lineage.
+      process.env.ADE_PARENT_CHAT_SESSION_ID = "inherited-parent";
+      process.env.ADE_SPAWN_KIND = "subagent";
+      try {
+        const { service, loadPty } = createHarness();
+        await service.create({
+          laneId: "lane-1",
+          title: "Codex plain",
+          cols: 80,
+          rows: 24,
+          toolType: "codex",
+          command: "codex",
+        });
+        const ptyLib = loadPty.mock.results.at(-1)?.value as { spawn: ReturnType<typeof vi.fn> };
+        const opts = ptyLib.spawn.mock.calls.at(-1)?.[2] as { env?: NodeJS.ProcessEnv } | undefined;
+        expect(opts?.env).toBeDefined();
+        expect(opts?.env).not.toHaveProperty("ADE_PARENT_CHAT_SESSION_ID");
+        expect(opts?.env).not.toHaveProperty("ADE_SPAWN_KIND");
+      } finally {
+        if (previousParent === undefined) delete process.env.ADE_PARENT_CHAT_SESSION_ID;
+        else process.env.ADE_PARENT_CHAT_SESSION_ID = previousParent;
+        if (previousKind === undefined) delete process.env.ADE_SPAWN_KIND;
+        else process.env.ADE_SPAWN_KIND = previousKind;
+      }
+    });
+
     it("refuses only new tracked CLI launches when storage is exhausted", async () => {
       let exhausted = false;
       const canPerform = vi.fn(() => exhausted
@@ -2063,6 +2120,53 @@ describe("ptyService", () => {
       expect(sessionService.create).toHaveBeenCalledTimes(createCallsBeforeResume);
     });
 
+    it("restores spawn-lineage env from persisted resume metadata on resume", async () => {
+      const { service, sessionService, loadPty } = createHarness();
+      sessionService.create({
+        sessionId: "session-spawned",
+        laneId: "lane-1",
+        ptyId: null,
+        tracked: true,
+        title: "Codex CLI",
+        startedAt: "2026-04-09T12:00:00.000Z",
+        transcriptPath: "/tmp/transcripts/session-spawned.log",
+        toolType: "codex",
+        resumeCommand: "codex --no-alt-screen resume thread-spawned",
+        resumeMetadata: {
+          provider: "codex",
+          targetKind: "thread",
+          targetId: "thread-spawned",
+          launch: { permissionMode: "config-toml" },
+          orchestrationParentSessionId: "parent-session-1",
+          spawnKind: "subagent",
+        },
+      });
+      sessionService.end({
+        sessionId: "session-spawned",
+        endedAt: "2026-04-09T12:30:00.000Z",
+        exitCode: 0,
+        status: "completed",
+      });
+
+      await service.create({
+        sessionId: "session-spawned",
+        laneId: "lane-1",
+        title: "Codex CLI",
+        cols: 80,
+        rows: 24,
+        toolType: "codex",
+        startupCommand: "codex --no-alt-screen resume thread-spawned",
+      });
+
+      const ptyLib = loadPty.mock.results.at(-1)?.value as { spawn: ReturnType<typeof vi.fn> };
+      const opts = ptyLib.spawn.mock.calls.at(-1)?.[2] as { env?: NodeJS.ProcessEnv } | undefined;
+      expect(opts?.env).toEqual(expect.objectContaining({
+        ADE_PARENT_CHAT_SESSION_ID: "parent-session-1",
+        ADE_SPAWN_KIND: "subagent",
+      }));
+      expect(opts?.env?.ADE_CHAT_SESSION_ID).toBe("session-spawned");
+    });
+
     it("backfills a targetless Claude resume command before launching the resumed PTY", async () => {
       (mocks.extractResumeCommandFromOutput as any).mockReturnValueOnce("claude --resume claude-session-123");
       const { service, sessionService, mockPty } = createHarness();
diff --git a/apps/desktop/src/main/services/pty/ptyService.ts b/apps/desktop/src/main/services/pty/ptyService.ts
index 576e7b1db..a686431e1 100644
--- a/apps/desktop/src/main/services/pty/ptyService.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.ts
@@ -371,6 +371,7 @@ function withAdeTerminalContextEnv(env: NodeJS.ProcessEnv, args: {
   laneId: string;
   chatSessionId: string | null;
   ownerSessionId?: string | null;
+  spawnLineage?: PtyCreateArgs["spawnLineage"];
 }): NodeJS.ProcessEnv {
   const next: NodeJS.ProcessEnv = {
     ...env,
@@ -390,6 +391,15 @@ function withAdeTerminalContextEnv(env: NodeJS.ProcessEnv, args: {
     delete next.ADE_CHAT_SESSION_ID;
     delete next.ADE_BROWSER_ACTOR_TOKEN;
   }
+  if (args.spawnLineage) {
+    next.ADE_PARENT_CHAT_SESSION_ID = args.spawnLineage.parentChatSessionId;
+    next.ADE_SPAWN_KIND = args.spawnLineage.spawnKind ?? "";
+  } else {
+    // The daemon itself may run inside a spawned agent shell that inherited
+    // these; without lineage they must not leak into unrelated terminals.
+    delete next.ADE_PARENT_CHAT_SESSION_ID;
+    delete next.ADE_SPAWN_KIND;
+  }
   return next;
 }
 
@@ -3645,11 +3655,25 @@ export function createPtyService({
       if (explicitNoColor && !explicitForceColor) {
         delete baseLaunchEnv.FORCE_COLOR;
       }
+      // Resume launches re-enter create() without args.spawnLineage — recover
+      // it from the persisted resume metadata so a resumed spawned CLI keeps
+      // its parent env (self-reporting + nested lineage).
+      const persistedParentSessionId = isTrackedAgentCliToolType(toolTypeHint)
+        ? existingSession?.resumeMetadata?.orchestrationParentSessionId?.trim() || null
+        : null;
+      const effectiveSpawnLineage = args.spawnLineage
+        ?? (persistedParentSessionId
+          ? {
+              parentChatSessionId: persistedParentSessionId,
+              spawnKind: existingSession?.resumeMetadata?.spawnKind ?? null,
+            }
+          : null);
       const contextLaunchEnv = withAdeTerminalContextEnv(baseLaunchEnv, {
         projectRoot,
         laneId,
         chatSessionId,
         ownerSessionId: isTrackedAgentCliToolType(toolTypeHint) ? sessionId : null,
+        spawnLineage: effectiveSpawnLineage,
       });
       let launchEnv = withInteractiveTerminalColorEnv(
         getAdeCliAgentEnv?.(contextLaunchEnv) ?? contextLaunchEnv,
diff --git a/apps/desktop/src/main/services/sessions/sessionService.test.ts b/apps/desktop/src/main/services/sessions/sessionService.test.ts
index d62188b48..714753e49 100644
--- a/apps/desktop/src/main/services/sessions/sessionService.test.ts
+++ b/apps/desktop/src/main/services/sessions/sessionService.test.ts
@@ -150,6 +150,55 @@ describe("sessionService resume metadata", () => {
     activeDisposers.push(async () => db.close());
   });
 
+  it("projects tracked CLI spawn lineage from resume metadata without assigning a chat owner", async () => {
+    const projectRoot = makeProjectRoot("ade-session-service-lineage-");
+    const dbPath = path.join(projectRoot, ".ade", "ade.db");
+    const db = await openKvDb(dbPath, createLogger() as any);
+    activeDisposers.push(async () => db.close());
+    insertProjectGraph(db);
+    const service = createSessionService({ db });
+
+    service.create({
+      sessionId: "session-lineage",
+      laneId: "lane-1",
+      ptyId: null,
+      tracked: true,
+      title: "Codex CLI child",
+      startedAt: "2026-07-18T04:10:54.789Z",
+      transcriptPath: "/tmp/session-lineage.log",
+      toolType: "codex",
+      resumeMetadata: {
+        provider: "codex",
+        targetKind: "thread",
+        targetId: null,
+        launch: { permissionMode: "default" },
+        orchestrationParentSessionId: "parent-session-1",
+        spawnKind: "subagent",
+      },
+    });
+
+    expect(service.list({ laneId: "lane-1" })).toEqual([
+      expect.objectContaining({
+        id: "session-lineage",
+        chatSessionId: null,
+        orchestrationParentSessionId: "parent-session-1",
+        spawnKind: "subagent",
+      }),
+    ]);
+
+    service.setResumeCommand("session-lineage", "codex resume thread-1");
+    expect(service.get("session-lineage")).toEqual(expect.objectContaining({
+      chatSessionId: null,
+      orchestrationParentSessionId: "parent-session-1",
+      spawnKind: "subagent",
+      resumeMetadata: expect.objectContaining({
+        targetId: "thread-1",
+        orchestrationParentSessionId: "parent-session-1",
+        spawnKind: "subagent",
+      }),
+    }));
+  });
+
   it("preserves Codex approval and sandbox settings when rebuilding the resume command", async () => {
     const projectRoot = makeProjectRoot("ade-session-service-");
     const dbPath = path.join(projectRoot, ".ade", "ade.db");
diff --git a/apps/desktop/src/main/services/sessions/sessionService.ts b/apps/desktop/src/main/services/sessions/sessionService.ts
index 2b71bc7c9..f025cf5ea 100644
--- a/apps/desktop/src/main/services/sessions/sessionService.ts
+++ b/apps/desktop/src/main/services/sessions/sessionService.ts
@@ -11,8 +11,9 @@ import type {
   TerminalSessionSummary,
   TerminalToolType,
   ListSessionsArgs,
-  UpdateSessionMetaArgs
+  UpdateSessionMetaArgs,
 } from "../../../shared/types";
+import { isTrackedAgentCliToolType } from "../../../shared/types";
 import { stripAnsi } from "../../utils/ansiStrip";
 import { readHistoryFileSync } from "../storage/historyCompression";
 import {
@@ -152,6 +153,12 @@ function normalizeResumeMetadata(raw: unknown): TerminalResumeMetadata | null {
   const importedFromAt = typeof importedFromRecord?.importedAt === "string" && importedFromRecord.importedAt.trim().length
     ? importedFromRecord.importedAt.trim()
     : null;
+  const orchestrationParentSessionId = typeof record.orchestrationParentSessionId === "string"
+    ? record.orchestrationParentSessionId.trim()
+    : "";
+  const spawnKind = record.spawnKind === "subagent" || record.spawnKind === "peer" || record.spawnKind === "none"
+    ? record.spawnKind
+    : null;
   if (!provider || !targetKind) return null;
   return {
     provider,
@@ -178,6 +185,8 @@ function normalizeResumeMetadata(raw: unknown): TerminalResumeMetadata | null {
       : {}),
     ...(legacyTarget ? { target: legacyTarget } : {}),
     ...(permissionMode ? { permissionMode } : {}),
+    ...(orchestrationParentSessionId ? { orchestrationParentSessionId } : {}),
+    ...(spawnKind ? { spawnKind } : {}),
   };
 }
 
@@ -363,6 +372,12 @@ export function createSessionService({ db }: { db: AdeDb }) {
       chatSessionId: row.chatSessionId ?? null,
       ownerPid: normalizeOwnerPid(row.ownerPid),
       ownerProcessStartedAt: normalizeOwnerProcessStartedAt(row.ownerProcessStartedAt),
+      ...(isTrackedAgentCliToolType(toolType) && resumeMetadata?.orchestrationParentSessionId
+        ? { orchestrationParentSessionId: resumeMetadata.orchestrationParentSessionId }
+        : {}),
+      ...(isTrackedAgentCliToolType(toolType) && resumeMetadata?.spawnKind
+        ? { spawnKind: resumeMetadata.spawnKind }
+        : {}),
     };
   };
 
@@ -1059,6 +1074,7 @@ export function createSessionService({ db }: { db: AdeDb }) {
         : null;
       const nextMetadata = parsed
         ? {
+            ...currentMetadata,
             provider: parsed.provider,
             targetKind: parsed.provider === "codex" ? "thread" : "session",
             targetId: parsed.targetId ?? currentMetadata?.targetId ?? null,
diff --git a/apps/desktop/src/renderer/browserMock.ts b/apps/desktop/src/renderer/browserMock.ts
index 98f8fad7d..1083123b1 100644
--- a/apps/desktop/src/renderer/browserMock.ts
+++ b/apps/desktop/src/renderer/browserMock.ts
@@ -1244,6 +1244,7 @@ function mockAgentChatSummaryFromSession(session: any): any | null {
     orchestrationRunId: session.orchestrationRunId ?? undefined,
     orchestrationRole: session.orchestrationRole ?? undefined,
     orchestrationParentSessionId: session.orchestrationParentSessionId ?? undefined,
+    spawnKind: session.spawnKind ?? undefined,
     orchestrationTag: session.orchestrationTag ?? undefined,
     orchestrationStepId: session.orchestrationStepId ?? undefined,
     orchestrationBundlePath: session.orchestrationBundlePath ?? undefined,
@@ -4517,6 +4518,7 @@ if (typeof window !== "undefined" && shouldInstallBrowserMock(window)) {
       updateAppearance: resolvedArg(undefined),
       archive: resolvedArg(undefined),
       delete: resolvedArg(undefined),
+      listDeleteProgress: resolved([]),
       cancelDelete: resolvedArg({
         cancelled: false,
         reason: "no active delete",
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
index bfa4d645d..9a1071374 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
@@ -2853,6 +2853,7 @@ export function AgentChatPane({
   initialSessionId,
   initialSessionSummary,
   lockSessionId,
+  sessionTitleById,
   hideSessionTabs = false,
   hideNativeControls = false,
   hideModelControls = false,
@@ -2899,6 +2900,8 @@ export function AgentChatPane({
   initialSessionId?: string | null;
   initialSessionSummary?: AgentChatSessionSummary | null;
   lockSessionId?: string | null;
+  /** Full host-surface title index for locked single-session embeddings. */
+  sessionTitleById?: ReadonlyMap<string, string>;
   hideSessionTabs?: boolean;
   hideNativeControls?: boolean;
   /** Hide model/reasoning/fast controls when the embedding surface owns them. */
@@ -4858,6 +4861,15 @@ export function AgentChatPane({
     return { parentId, parentTitle, spawnKind: selectedSession?.spawnKind ?? null };
   }, [selectedSession?.orchestrationParentSessionId, selectedSession?.sessionId, selectedSession?.spawnKind, sessions]);
 
+  // Resolve a spawned child chat's live title so the Subagents pane's spawned-chat
+  // rows read as the chat they open, not the bare runtime name.
+  const resolveSpawnedChatTitle = useCallback(
+    (id: string): string | null => sessionTitleById?.get(id)?.trim()
+      || sessions.find((s) => s.sessionId === id)?.title?.trim()
+      || null,
+    [sessionTitleById, sessions],
+  );
+
   // Keep configured models selectable unless a caller explicitly constrains
   // this surface. Unconstrained sessions keep their active model visible even
   // when it has fallen out of the discovered catalog.
@@ -9765,6 +9777,7 @@ export function AgentChatPane({
       }}
       onClearSelectedSubagent={() => setSubagentView(null)}
       probeSubagentTranscript={probeSubagentTranscript}
+      resolveSpawnedChatTitle={resolveSpawnedChatTitle}
       capability={selectedSubagentCapability}
       selectedTaskId={subagentView?.taskId ?? null}
       goal={selectedSession?.provider === "codex" ? selectedCodexGoal : null}
@@ -10266,10 +10279,10 @@ export function AgentChatPane({
               ? "border-slate-400/18 bg-slate-400/[0.06] text-slate-300/75 hover:border-slate-300/30 hover:text-slate-100/90"
               : "border-violet-400/20 bg-violet-400/[0.06] text-violet-200/80 hover:border-violet-300/32 hover:text-violet-100",
           )}
-          title={spawnLineage.parentTitle ? `Open spawner: ${spawnLineage.parentTitle}` : "Open spawner"}
+          title={spawnLineage.parentTitle ? `Parent thread: "${spawnLineage.parentTitle}"` : "View parent thread"}
         >
           <span aria-hidden className="shrink-0">↳</span>
-          <span className="min-w-0 truncate">from {spawnLineage.parentTitle ? `"${spawnLineage.parentTitle}"` : "spawner"}</span>
+          <span className="min-w-0 truncate">View parent thread</span>
         </button>
       ) : null}
       {chatTerminalVisible && selectedSessionId ? (
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
index bcaa9fb8a..674ff5e9d 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
@@ -770,6 +770,117 @@ describe("ChatSubagentsPanel (pane variant)", () => {
     expect(screen.getByRole("button", { name: "Completed (2)" })).toBeTruthy();
   });
 
+  // A spawned ADE child chat row navigates to that chat instead of taking over
+  // the transcript / opening the inline drawer. The click is gated on either a
+  // `chat:`-prefixed taskId OR a `spawnKind` (the latter survives the dot-twin
+  // that can strip the `chat:` prefix — see chatExecutionSummary preservation).
+  describe("spawned-chat row navigation", () => {
+    const spawnedChatSnapshot = (overrides: Partial<ChatSubagentSnapshot> = {}): ChatSubagentSnapshot => ({
+      taskId: "chat:child-1",
+      childSessionId: "child-1",
+      agentId: "child-1",
+      agentType: "codex",
+      description: "Codex Chat",
+      status: "running",
+      startedAt: "2026-07-18T04:10:54.789Z",
+      updatedAt: "2026-07-18T04:10:54.789Z",
+      summary: null,
+      spawnKind: "subagent",
+      ...overrides,
+    });
+
+    function withSelectSessionSpy(run: (selectSession: ReturnType<typeof vi.fn>) => void): void {
+      const selectSession = vi.fn();
+      const listener = (event: Event) => selectSession((event as CustomEvent).detail);
+      window.addEventListener("ade:work:select-session", listener);
+      try {
+        run(selectSession);
+      } finally {
+        window.removeEventListener("ade:work:select-session", listener);
+      }
+    }
+
+    it("navigates to the child chat (chat:-prefixed taskId) instead of drawer/takeover", () => {
+      withSelectSessionSpy((selectSession) => {
+        const onSelectSubagent = vi.fn<[SubagentSelection], void>();
+        const probeSubagentTranscript = vi.fn().mockResolvedValue(true);
+        render(
+          <ChatSubagentsPanel
+            sessionId="parent-1"
+            snapshots={[spawnedChatSnapshot()]}
+            events={[]}
+            variant="pane"
+            capability={CLAUDE_CAP}
+            onSelectSubagent={onSelectSubagent}
+            probeSubagentTranscript={probeSubagentTranscript}
+          />,
+        );
+
+        fireEvent.click(screen.getByTitle("Open the spawned chat"));
+
+        expect(selectSession).toHaveBeenCalledWith({ sessionId: "child-1", laneId: null });
+        expect(onSelectSubagent).not.toHaveBeenCalled();
+        expect(probeSubagentTranscript).not.toHaveBeenCalled();
+        expect(screen.queryByText(/Transcript not ready yet/)).toBeNull();
+      });
+    });
+
+    it("navigates when the taskId is bare but spawnKind is set (post-dot-twin corruption shape)", () => {
+      withSelectSessionSpy((selectSession) => {
+        const onSelectSubagent = vi.fn<[SubagentSelection], void>();
+        render(
+          <ChatSubagentsPanel
+            sessionId="parent-1"
+            snapshots={[spawnedChatSnapshot({ taskId: "child-1" })]}
+            events={[]}
+            variant="pane"
+            capability={CLAUDE_CAP}
+            onSelectSubagent={onSelectSubagent}
+          />,
+        );
+
+        fireEvent.click(screen.getByTitle("Open the spawned chat"));
+
+        expect(selectSession).toHaveBeenCalledWith({ sessionId: "child-1", laneId: null });
+        expect(onSelectSubagent).not.toHaveBeenCalled();
+        expect(screen.queryByText(/Transcript not ready yet/)).toBeNull();
+      });
+    });
+
+    it("shows the resolved live chat title instead of the runtime agentType", () => {
+      render(
+        <ChatSubagentsPanel
+          sessionId="parent-1"
+          snapshots={[spawnedChatSnapshot()]}
+          events={[]}
+          variant="pane"
+          capability={CLAUDE_CAP}
+          resolveSpawnedChatTitle={(id) => (id === "child-1" ? "Investigate flaky CI" : null)}
+        />,
+      );
+
+      // Resolved title is the row label; the runtime name stays as the small chip.
+      expect(screen.getByText("Investigate flaky CI")).toBeTruthy();
+      expect(screen.getByText("codex")).toBeTruthy();
+    });
+
+    it("falls back to the snapshot description when no live title resolves", () => {
+      render(
+        <ChatSubagentsPanel
+          sessionId="parent-1"
+          snapshots={[spawnedChatSnapshot()]}
+          events={[]}
+          variant="pane"
+          capability={CLAUDE_CAP}
+          resolveSpawnedChatTitle={() => null}
+        />,
+      );
+
+      expect(screen.getByText("Codex Chat")).toBeTruthy();
+      expect(screen.getByText("codex")).toBeTruthy();
+    });
+  });
+
   it("owns the pane scroller and uses sticky opaque section headers", () => {
     render(<ChatSubagentsPanel snapshots={[baseSnapshot]} events={[]} variant="pane" />);
 
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
index 9717fa5aa..2e44526ac 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
@@ -781,6 +781,7 @@ function SubagentRow({
   canViewFullTranscript,
   onClick,
   depth = 0,
+  spawnedChatTitle = null,
 }: {
   snapshot: ChatSubagentSnapshot;
   selected: boolean;
@@ -793,10 +794,21 @@ function SubagentRow({
   /** Whether this runtime can surface a full child transcript (drives the
    * drawer's "transcript not ready yet" vs "live details only" footer). */
   canViewFullTranscript: boolean;
+  /** Live title of the spawned child chat this row navigates to, when resolved.
+   * Non-null marks this as a spawned-chat row (navigates on click). */
+  spawnedChatTitle?: string | null;
   onClick: () => void;
 }) {
-  const name = chatSubagentDisplayName(snapshot);
-  const kindLabel = kindBadge(snapshot);
+  const isSpawnedChat = snapshot.childSessionId != null;
+  // Spawned-chat rows read as the chat they open: prefer the resolved live
+  // session title, then the snapshot description ("Codex Chat") — never the bare
+  // agentType ("codex"), which becomes the small chip instead.
+  const name = isSpawnedChat
+    ? (spawnedChatTitle?.trim() || snapshot.description?.trim() || chatSubagentDisplayName(snapshot))
+    : chatSubagentDisplayName(snapshot);
+  // Spawned-chat rows surface the runtime as the uppercase chip (reusing the
+  // kindBadge chip idiom); other rows keep their taskType kind chip.
+  const kindLabel = isSpawnedChat ? (snapshot.agentType?.trim() || null) : kindBadge(snapshot);
   const color = chatSubagentColor(snapshot.agentId ?? snapshot.taskId);
   const isRunning = snapshot.status === "running";
   const isCompleted = snapshot.status === "completed";
@@ -830,7 +842,7 @@ function SubagentRow({
       <button
         type="button"
         onClick={onClick}
-        title={snapshot.description || "View subagent details"}
+        title={isSpawnedChat ? "Open the spawned chat" : (snapshot.description || "View subagent details")}
         data-selected={selected || undefined}
         className={cn(
           "group relative flex w-full items-center gap-2.5 rounded-md px-2 py-1.5 text-left",
@@ -873,6 +885,15 @@ function SubagentRow({
         </span>
 
         <span className="flex shrink-0 items-center gap-1.5 font-sans text-[10.5px] tabular-nums">
+          {isSpawnedChat ? (
+            <span
+              aria-hidden
+              className="inline-flex items-center gap-0.5 whitespace-nowrap text-fg/0 transition-colors group-hover:text-fg/40"
+            >
+              open
+              <CaretRight size={10} weight="bold" />
+            </span>
+          ) : null}
           {probing ? (
             <span
               aria-hidden
@@ -956,6 +977,7 @@ export function ChatSubagentsPanel({
   onSelectSubagent,
   onClearSelectedSubagent,
   probeSubagentTranscript,
+  resolveSpawnedChatTitle,
   capability = null,
   selectedTaskId,
   className,
@@ -982,6 +1004,10 @@ export function ChatSubagentsPanel({
   /** Probe (same fetch the takeover uses) for whether an agent has a pullable
    * transcript. Returns true → take over the chat; false → inline drawer. */
   probeSubagentTranscript?: (args: { taskId: string; agentId: string | null }) => Promise<boolean>;
+  /** Resolve the live title of a spawned child chat by session id, so spawned-chat
+   * rows show the chat's real title instead of the runtime name. Returns null when
+   * the session isn't known (yet). */
+  resolveSpawnedChatTitle?: (sessionId: string) => string | null;
   /** Per-runtime subagent capability — the single source of truth for whether a
    * subagent click can take over the chat (full transcript) or only opens the
    * inline drawer, and whether running agents take over immediately. Null →
@@ -1219,15 +1245,11 @@ export function ChatSubagentsPanel({
   const immediateForRunning = canTakeover && (capability?.hasRichMetadata ?? false);
 
   const handleRowClick = (snap: ChatSubagentSnapshot) => {
-    // A spawned ADE chat (peer/subagent) carries a `chat:<id>` taskId — clicking
-    // navigates to that chat instead of a transcript takeover/drawer. Only
-    // runtime-native subagents (non-`chat:` taskIds) keep the takeover behavior.
-    if (snap.taskId.startsWith("chat:")) {
-      const childSessionId = snap.agentId?.trim() || snap.taskId.slice("chat:".length);
-      if (childSessionId) {
-        navigateToSpawnedChat(childSessionId, null);
-        return;
-      }
+    // Spawned ADE chats navigate directly; runtime-native subagents keep the
+    // transcript takeover/details behavior below.
+    if (snap.childSessionId != null) {
+      navigateToSpawnedChat(snap.childSessionId, null);
+      return;
     }
     // Clicking the row whose drawer is open closes it.
     if (expandedTaskId === snap.taskId) {
@@ -1329,6 +1351,11 @@ export function ChatSubagentsPanel({
       canViewFullTranscript={canTakeover}
       category={snap.background ? "background" : "subagent"}
       depth={subagentTreeDepth(snap, snapshots)}
+      spawnedChatTitle={
+        snap.childSessionId != null
+          ? resolveSpawnedChatTitle?.(snap.childSessionId) ?? null
+          : null
+      }
       onClick={() => handleRowClick(snap)}
     />
   );
diff --git a/apps/desktop/src/renderer/components/chat/chatExecutionSummary.test.ts b/apps/desktop/src/renderer/components/chat/chatExecutionSummary.test.ts
index 43f180073..dcd557cb4 100644
--- a/apps/desktop/src/renderer/components/chat/chatExecutionSummary.test.ts
+++ b/apps/desktop/src/renderer/components/chat/chatExecutionSummary.test.ts
@@ -541,6 +541,86 @@ describe("deriveChatSubagentSnapshots", () => {
     }));
   });
 
+  // A spawned ADE child chat emits BOTH the underscore `subagent_started`
+  // (taskId `chat:<id>`, spawnKind) AND a canonical dot-form `subagent.started`
+  // twin that normalizes to a BARE taskId (= agentId). Both share the identity
+  // key, so a naive last-write lets the twin strip the `chat:` prefix — which is
+  // exactly what breaks spawned-chat navigation. The derivation must keep the
+  // `chat:` taskId and the spawnKind regardless of which event lands last.
+  describe("spawned-chat dual-event (underscore + dot twin) preservation", () => {
+    const underscoreStarted: AgentChatEventEnvelope = {
+      sessionId: "parent-1",
+      timestamp: "2026-07-18T04:10:54.789Z",
+      event: {
+        type: "subagent_started",
+        taskId: "chat:child-1",
+        agentId: "child-1",
+        agentType: "codex",
+        description: "Codex Chat",
+        spawnKind: "subagent",
+      },
+    };
+    // The dot twin as it arrives on the wire (normalizeSubagentLifecycleEvent
+    // maps this to { type: "subagent_started", taskId: "child-1", agentId: "child-1" }).
+    const dotTwin: AgentChatEventEnvelope = {
+      sessionId: "parent-1",
+      timestamp: "2026-07-18T04:10:54.900Z",
+      event: {
+        type: "subagent.started",
+        agentId: "child-1",
+        agentType: "codex",
+        description: "Codex Chat",
+      },
+    };
+
+    it("keeps the chat: taskId and spawnKind when the dot twin lands after the underscore event", () => {
+      const snapshots = deriveChatSubagentSnapshots([underscoreStarted, dotTwin]);
+      expect(snapshots).toHaveLength(1);
+      expect(snapshots[0]).toEqual(expect.objectContaining({
+        taskId: "chat:child-1",
+        childSessionId: "child-1",
+        agentId: "child-1",
+        spawnKind: "subagent",
+      }));
+    });
+
+    it("keeps the chat: taskId and spawnKind when the dot twin lands before the underscore event", () => {
+      const snapshots = deriveChatSubagentSnapshots([dotTwin, underscoreStarted]);
+      expect(snapshots).toHaveLength(1);
+      expect(snapshots[0]).toEqual(expect.objectContaining({
+        taskId: "chat:child-1",
+        childSessionId: "child-1",
+        agentId: "child-1",
+        spawnKind: "subagent",
+      }));
+    });
+
+    it("preserves the chat: taskId and spawnKind across a later progress/result merge", () => {
+      const snapshots = deriveChatSubagentSnapshots([
+        underscoreStarted,
+        dotTwin,
+        {
+          sessionId: "parent-1",
+          timestamp: "2026-07-18T04:11:00.000Z",
+          event: {
+            type: "subagent_result",
+            taskId: "child-1",
+            agentId: "child-1",
+            status: "completed",
+            summary: "Done",
+          },
+        },
+      ]);
+      expect(snapshots).toHaveLength(1);
+      expect(snapshots[0]).toEqual(expect.objectContaining({
+        taskId: "chat:child-1",
+        childSessionId: "child-1",
+        spawnKind: "subagent",
+        status: "completed",
+      }));
+    });
+  });
+
   it("keys Claude snapshots by SDK agent id and preserves background state", () => {
     const events: AgentChatEventEnvelope[] = [
       {
diff --git a/apps/desktop/src/renderer/components/chat/chatExecutionSummary.ts b/apps/desktop/src/renderer/components/chat/chatExecutionSummary.ts
index 576da5c4c..de9023075 100644
--- a/apps/desktop/src/renderer/components/chat/chatExecutionSummary.ts
+++ b/apps/desktop/src/renderer/components/chat/chatExecutionSummary.ts
@@ -1,5 +1,6 @@
 import type {
   AgentChatEventEnvelope,
+  AgentChatSpawnKind,
   TurnDiffSummary,
 } from "../../../shared/types";
 import {
@@ -26,6 +27,8 @@ export function derivePlan(events: AgentChatEventEnvelope[]): ChatInfoPlan {
 
 export type ChatSubagentSnapshot = {
   taskId: string;
+  /** ADE child-chat session id when this row represents a spawned chat. */
+  childSessionId?: string;
   agentId?: string;
   agentType?: string;
   label?: string | null;
@@ -44,6 +47,15 @@ export type ChatSubagentSnapshot = {
   lastToolName?: string;
   background?: boolean;
   taskType?: "subagent" | "background" | "local_workflow" | "cron" | "other";
+  /**
+   * Spawn lineage kind for a spawned ADE child chat (`subagent`/`peer`); absent
+   * for runtime-native subagents. Only the underscore `subagent_started` event
+   * carries it — the canonical dot-form (`subagent.started`) twin does NOT — so
+   * it must be preserved across the twin's overwrite and later progress/result
+   * merges. Used (alongside a `chat:`-prefixed taskId) to route a row click to
+   * the child chat instead of a transcript takeover/drawer.
+   */
+  spawnKind?: AgentChatSpawnKind;
   workflowName?: string;
   usage?: {
     totalTokens?: number;
@@ -167,6 +179,33 @@ function resolveSubagentSnapshot(
   };
 }
 
+function mergeSubagentTaskId(
+  existingTaskId: string | undefined,
+  eventTaskId: string,
+  adoptedPlaceholder: boolean,
+): string {
+  if (existingTaskId?.startsWith("chat:")) return existingTaskId;
+  return adoptedPlaceholder ? eventTaskId : existingTaskId ?? eventTaskId;
+}
+
+function mergeSubagentChildSessionId(args: {
+  existing: ChatSubagentSnapshot | undefined;
+  taskId: string;
+  agentId: string | undefined;
+  spawnKind: AgentChatSpawnKind | undefined;
+}): string | undefined {
+  const preserved = args.existing?.childSessionId?.trim();
+  if (preserved) return preserved;
+  const spawnedChat = args.taskId.startsWith("chat:")
+    || args.spawnKind != null
+    || args.existing?.taskId.startsWith("chat:")
+    || args.existing?.spawnKind != null;
+  if (!spawnedChat) return undefined;
+  const agentId = args.agentId?.trim();
+  if (agentId) return agentId;
+  return args.taskId.startsWith("chat:") ? args.taskId.slice("chat:".length) : args.taskId;
+}
+
 export function deriveChatSubagentSnapshots(events: AgentChatEventEnvelope[]): ChatSubagentSnapshot[] {
   const snapshots = new Map<string, ChatSubagentSnapshot>();
   const resolvedKeysByParent = buildResolvedSubagentKeysByParent(events);
@@ -176,9 +215,13 @@ export function deriveChatSubagentSnapshots(events: AgentChatEventEnvelope[]): C
     if (!event) continue;
     if (event.type === "subagent_started") {
       const { key, existing } = resolveSubagentSnapshot(snapshots, event, resolvedKeysByParent);
+      const taskId = mergeSubagentTaskId(existing?.taskId, event.taskId, true);
+      const agentId = event.agentId ?? existing?.agentId;
+      const spawnKind = event.spawnKind ?? existing?.spawnKind;
       snapshots.set(key, {
-        taskId: event.taskId,
-        agentId: event.agentId ?? existing?.agentId,
+        taskId,
+        childSessionId: mergeSubagentChildSessionId({ existing, taskId, agentId, spawnKind }),
+        agentId,
         agentType: event.agentType ?? existing?.agentType,
         label: event.label?.trim() || existing?.label,
         model: event.model?.trim() || existing?.model,
@@ -195,6 +238,9 @@ export function deriveChatSubagentSnapshots(events: AgentChatEventEnvelope[]): C
         lastToolName: existing?.lastToolName,
         background: event.background ?? existing?.background ?? false,
         taskType: event.taskType ?? existing?.taskType,
+        // Only the underscore event carries spawnKind; the dot twin does not, so
+        // fall back to the existing snapshot to survive the twin's overwrite.
+        spawnKind,
         workflowName: event.workflowName ?? existing?.workflowName,
         usage: existing?.usage,
       });
@@ -203,9 +249,13 @@ export function deriveChatSubagentSnapshots(events: AgentChatEventEnvelope[]): C
 
     if (event.type === "subagent_progress") {
       const { key, existing, adoptedPlaceholder } = resolveSubagentSnapshot(snapshots, event, resolvedKeysByParent);
+      const taskId = mergeSubagentTaskId(existing?.taskId, event.taskId, adoptedPlaceholder);
+      const agentId = event.agentId ?? existing?.agentId;
+      const spawnKind = existing?.spawnKind;
       snapshots.set(key, {
-        taskId: adoptedPlaceholder ? event.taskId : existing?.taskId ?? event.taskId,
-        agentId: event.agentId ?? existing?.agentId,
+        taskId,
+        childSessionId: mergeSubagentChildSessionId({ existing, taskId, agentId, spawnKind }),
+        agentId,
         agentType: event.agentType ?? existing?.agentType,
         label: event.label?.trim() || existing?.label,
         model: event.model?.trim() || existing?.model,
@@ -222,6 +272,7 @@ export function deriveChatSubagentSnapshots(events: AgentChatEventEnvelope[]): C
         lastToolName: event.lastToolName ?? existing?.lastToolName,
         background: existing?.background ?? false,
         taskType: event.taskType ?? existing?.taskType,
+        spawnKind,
         workflowName: event.workflowName ?? existing?.workflowName,
         usage: event.usage ? { ...(existing?.usage ?? {}), ...event.usage } : existing?.usage,
       });
@@ -230,9 +281,13 @@ export function deriveChatSubagentSnapshots(events: AgentChatEventEnvelope[]): C
 
     if (event.type === "subagent_result") {
       const { key, existing, adoptedPlaceholder } = resolveSubagentSnapshot(snapshots, event, resolvedKeysByParent);
+      const taskId = mergeSubagentTaskId(existing?.taskId, event.taskId, adoptedPlaceholder);
+      const agentId = event.agentId ?? existing?.agentId;
+      const spawnKind = existing?.spawnKind;
       snapshots.set(key, {
-        taskId: adoptedPlaceholder ? event.taskId : existing?.taskId ?? event.taskId,
-        agentId: event.agentId ?? existing?.agentId,
+        taskId,
+        childSessionId: mergeSubagentChildSessionId({ existing, taskId, agentId, spawnKind }),
+        agentId,
         agentType: event.agentType ?? existing?.agentType,
         label: event.label?.trim() || existing?.label,
         model: event.model?.trim() || existing?.model,
@@ -249,6 +304,7 @@ export function deriveChatSubagentSnapshots(events: AgentChatEventEnvelope[]): C
         lastToolName: existing?.lastToolName,
         background: existing?.background ?? false,
         taskType: event.taskType ?? existing?.taskType,
+        spawnKind,
         workflowName: event.workflowName ?? existing?.workflowName,
         usage: event.usage ? { ...(existing?.usage ?? {}), ...event.usage } : existing?.usage,
       });
diff --git a/apps/desktop/src/renderer/components/chat/chatSubagentIdentity.tsx b/apps/desktop/src/renderer/components/chat/chatSubagentIdentity.tsx
index 7acbac2ac..3bfbeedad 100644
--- a/apps/desktop/src/renderer/components/chat/chatSubagentIdentity.tsx
+++ b/apps/desktop/src/renderer/components/chat/chatSubagentIdentity.tsx
@@ -60,10 +60,16 @@ export function ChatSubagentGlyph({
   id,
   color,
   status,
+  size = 18,
 }: {
   id: string;
   color: string;
-  status: ChatSubagentSnapshot["status"];
+  // When omitted, renders the plain identicon: no spinner ring, no
+  // completed/failed corner badge, no dimming. Used for compact lineage cues
+  // (e.g. the Work sidebar card) where only the pattern+color identity matters.
+  status?: ChatSubagentSnapshot["status"];
+  /** Overall glyph size in px (svg + wrapper). Defaults to 18. */
+  size?: number;
 }) {
   const cells = identiconCells(id);
   const isRunning = status === "running";
@@ -73,7 +79,10 @@ export function ChatSubagentGlyph({
   const pad = 2;
 
   return (
-    <span className="relative flex h-[18px] w-[18px] shrink-0 items-center justify-center">
+    <span
+      className="relative flex shrink-0 items-center justify-center"
+      style={{ height: size, width: size }}
+    >
       {isRunning ? (
         <span
           aria-hidden
@@ -83,8 +92,8 @@ export function ChatSubagentGlyph({
       ) : null}
       <svg
         aria-hidden
-        width={18}
-        height={18}
+        width={size}
+        height={size}
         viewBox="0 0 18 18"
         className={cn("rounded-full", dimmed && "opacity-55")}
         style={{ backgroundColor: `color-mix(in srgb, ${color} 16%, transparent)` }}
diff --git a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
index b8fa1c6bc..7b54dde18 100644
--- a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
+++ b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
@@ -407,6 +407,75 @@ describe("chatTranscriptRows", () => {
     expect(anchor.agentType).toBe("claude");
   });
 
+  it("keeps a navigable spawn card when the canonical dot twin follows the underscore event", () => {
+    // Both events share the agentId identity key; the dot twin's taskId is bare
+    // (no `chat:` prefix), so the anchor must retain the childSessionId derived
+    // from the underscore event.
+    const rows = collapseChatTranscriptEvents([
+      {
+        sessionId: "parent-session",
+        timestamp: "2026-07-18T04:10:54.789Z",
+        event: {
+          type: "subagent_started",
+          taskId: "chat:child-123",
+          agentId: "child-123",
+          agentType: "codex",
+          description: "Codex Chat",
+          spawnKind: "subagent",
+        },
+      },
+      {
+        sessionId: "parent-session",
+        timestamp: "2026-07-18T04:10:54.900Z",
+        event: {
+          type: "subagent.started",
+          agentId: "child-123",
+          agentType: "codex",
+          description: "Codex Chat",
+        },
+      },
+    ]);
+
+    expect(rows).toHaveLength(1);
+    const anchor = rows[0]!.event;
+    if (anchor.type !== "subagent_spawn_anchor") throw new Error("Expected spawn anchor");
+    expect(anchor.childSessionId).toBe("child-123");
+    expect(anchor.spawnKind).toBe("subagent");
+  });
+
+  it("keeps a navigable spawn card when the dot twin precedes the underscore event", () => {
+    const rows = collapseChatTranscriptEvents([
+      {
+        sessionId: "parent-session",
+        timestamp: "2026-07-18T04:10:54.700Z",
+        event: {
+          type: "subagent.started",
+          agentId: "child-123",
+          agentType: "codex",
+          description: "Codex Chat",
+        },
+      },
+      {
+        sessionId: "parent-session",
+        timestamp: "2026-07-18T04:10:54.789Z",
+        event: {
+          type: "subagent_started",
+          taskId: "chat:child-123",
+          agentId: "child-123",
+          agentType: "codex",
+          description: "Codex Chat",
+          spawnKind: "subagent",
+        },
+      },
+    ]);
+
+    expect(rows).toHaveLength(1);
+    const anchor = rows[0]!.event;
+    if (anchor.type !== "subagent_spawn_anchor") throw new Error("Expected spawn anchor");
+    expect(anchor.childSessionId).toBe("child-123");
+    expect(anchor.spawnKind).toBe("subagent");
+  });
+
   it("leaves childSessionId/spawnKind null for a runtime-native subagent", () => {
     const rows = collapseChatTranscriptEvents([
       {
diff --git a/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx b/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx
index fb69d56e6..30a0e7e33 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx
@@ -168,6 +168,74 @@ describe("SessionCard spawn type + live children", () => {
     expect(screen.queryByText("PEER")).toBeNull();
   });
 
+  it("renders the lineage glyph for a spawned session and not for a top-level one", () => {
+    const { rerender } = render(
+      <SessionCard
+        session={makeSession({ orchestrationParentSessionId: "parent-1" })}
+        lane={lane}
+        isSelected={false}
+        onSelect={vi.fn()}
+        onContextMenu={vi.fn()}
+      />,
+    );
+    expect(screen.getByTestId("session-spawn-lineage")).toBeTruthy();
+
+    rerender(
+      <SessionCard
+        session={makeSession({ orchestrationParentSessionId: undefined })}
+        lane={lane}
+        isSelected={false}
+        onSelect={vi.fn()}
+        onContextMenu={vi.fn()}
+      />,
+    );
+    expect(screen.queryByTestId("session-spawn-lineage")).toBeNull();
+  });
+
+  it("navigates to the parent chat on glyph click without triggering card selection", () => {
+    const onSelect = vi.fn();
+    const dispatched: CustomEvent[] = [];
+    const handler = (event: Event) => dispatched.push(event as CustomEvent);
+    window.addEventListener("ade:work:select-session", handler);
+    try {
+      render(
+        <SessionCard
+          session={makeSession({ orchestrationParentSessionId: "parent-9" })}
+          lane={lane}
+          isSelected={false}
+          onSelect={onSelect}
+          onContextMenu={vi.fn()}
+        />,
+      );
+
+      act(() => {
+        screen.getByTestId("session-spawn-lineage").click();
+      });
+
+      expect(dispatched).toHaveLength(1);
+      expect(dispatched[0]?.detail).toMatchObject({ sessionId: "parent-9" });
+      expect(onSelect).not.toHaveBeenCalled();
+    } finally {
+      window.removeEventListener("ade:work:select-session", handler);
+    }
+  });
+
+  it("shows the parent title in the lineage glyph tooltip when provided", () => {
+    render(
+      <SessionCard
+        session={makeSession({ orchestrationParentSessionId: "parent-1" })}
+        lane={lane}
+        isSelected={false}
+        onSelect={vi.fn()}
+        onContextMenu={vi.fn()}
+        parentSessionTitle="Lead orchestrator"
+      />,
+    );
+    expect(
+      screen.getByTestId("session-spawn-lineage").getAttribute("title"),
+    ).toBe('Spawned by "Lead orchestrator" — click to open parent thread');
+  });
+
   it("shows the live-children badge when children are running", () => {
     render(
       <SessionCard
diff --git a/apps/desktop/src/renderer/components/terminals/SessionCard.tsx b/apps/desktop/src/renderer/components/terminals/SessionCard.tsx
index c822616ba..0ca14a623 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionCard.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionCard.tsx
@@ -26,6 +26,8 @@ import { ToolLogo } from "./ToolLogos";
 import { readImportedFrom, providerDisplayName } from "./importSessions/contract";
 import { ClaudeCacheTtlBadge } from "../shared/ClaudeCacheTtlBadge";
 import { shouldShowClaudeCacheTtl } from "../../lib/claudeCacheTtl";
+import { ChatSubagentGlyph, chatSubagentColor } from "../chat/chatSubagentIdentity";
+import { navigateToSpawnedChat } from "../chat/spawnNavigation";
 
 const DELTA_CHIP_STYLE: React.CSSProperties = {
   fontSize: 10,
@@ -259,6 +261,7 @@ export const SessionCard = React.memo(function SessionCard({
   compact = false,
   gridBadge = null,
   liveChildrenCount = 0,
+  parentSessionTitle = null,
   disabledReason = null,
 }: {
   session: TerminalSessionSummary;
@@ -272,6 +275,8 @@ export const SessionCard = React.memo(function SessionCard({
   gridBadge?: "active" | "inactive" | null;
   /** Count of this session's still-running spawned children (drives the `▸N` badge). */
   liveChildrenCount?: number;
+  /** Title of the parent chat that spawned this session (drives the lineage glyph tooltip). */
+  parentSessionTitle?: string | null;
   /** When present, blocks interaction while the owning lane is being removed. */
   disabledReason?: string | null;
 }) {
@@ -515,6 +520,33 @@ export const SessionCard = React.memo(function SessionCard({
                   </span>
                 ) : null}
                 <NextWakeChip nextWakeAt={session.nextWakeAt} compact={compact} />
+                {session.orchestrationParentSessionId ? (
+                  // Plain span, no role/tabIndex: the whole card is already a
+                  // <button>, and a nested interactive control is invalid HTML
+                  // that assistive tech may flatten into the outer button. The
+                  // mouse shortcut stays (stopPropagation keeps the card's
+                  // onSelect from firing); keyboard/AT users reach the parent
+                  // via the child chat's "View parent thread" header button.
+                  <span
+                    data-testid="session-spawn-lineage"
+                    className="inline-flex shrink-0 cursor-pointer items-center opacity-70 transition-opacity hover:opacity-100"
+                    title={
+                      parentSessionTitle
+                        ? `Spawned by "${parentSessionTitle}" — click to open parent thread`
+                        : "Spawned by another chat — click to open parent thread"
+                    }
+                    onClick={(event) => {
+                      event.stopPropagation();
+                      navigateToSpawnedChat(session.orchestrationParentSessionId, null);
+                    }}
+                  >
+                    <ChatSubagentGlyph
+                      id={session.id}
+                      color={chatSubagentColor(session.id)}
+                      size={compact ? 10 : 12}
+                    />
+                  </span>
+                ) : null}
                 <span
                   title={dot.label}
                   className={cn(
diff --git a/apps/desktop/src/renderer/components/terminals/SessionListPane.tsx b/apps/desktop/src/renderer/components/terminals/SessionListPane.tsx
index 3fff926ba..58be66006 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionListPane.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionListPane.tsx
@@ -19,7 +19,7 @@ import { SmartTooltip } from "../ui/SmartTooltip";
 import { cn } from "../ui/cn";
 import { branchNameFromRef } from "../prs/shared/laneBranchTargets";
 import { laneSurfaceTint } from "../lanes/laneDesignTokens";
-import { canBulkDeleteSession, canBulkStopSession } from "../../lib/sessions";
+import { canBulkDeleteSession, canBulkStopSession, primarySessionLabel } from "../../lib/sessions";
 import { useWorkLaneContextMenu } from "./useWorkLaneContextMenu";
 import { relativeTimeCompact } from "../../lib/format";
 import { getLaneDeleteStatusLabel } from "../../lib/laneDeleteProgress";
@@ -515,6 +515,16 @@ export const SessionListPane = React.memo(function SessionListPane({
     }
     return map;
   }, [allSessionsUnfiltered]);
+  // Parent-title lookup for the sidebar lineage glyph tooltip. Keyed off the
+  // UNFILTERED list so a spawned child can still name its parent even when the
+  // parent is hidden by the current search/lane filter.
+  const sessionTitleById = useMemo(() => {
+    const map = new Map<string, string>();
+    for (const session of allSessionsUnfiltered) {
+      map.set(session.id, primarySessionLabel(session));
+    }
+    return map;
+  }, [allSessionsUnfiltered]);
   const isChildSectionCollapsed = useCallback(
     (parentId: string) => workCollapsedSectionIds.includes(`chat:${parentId}`),
     [workCollapsedSectionIds],
@@ -661,6 +671,11 @@ export const SessionListPane = React.memo(function SessionListPane({
         session={session}
         lane={laneById.get(session.laneId) ?? null}
         liveChildrenCount={liveChildrenByParentId.get(session.id) ?? 0}
+        parentSessionTitle={
+          session.orchestrationParentSessionId
+            ? sessionTitleById.get(session.orchestrationParentSessionId) ?? null
+            : null
+        }
         isSelected={selectedSessionId === session.id}
         isMultiSelected={selectedSessionIds?.has(session.id) ?? false}
         onSelect={(id, event) => onSelectSession(id, event, renderedSessionIds)}
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalsPage.test.tsx b/apps/desktop/src/renderer/components/terminals/TerminalsPage.test.tsx
index 99f89169a..3202570f2 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalsPage.test.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalsPage.test.tsx
@@ -405,6 +405,32 @@ describe("TerminalsPage chat session activation", () => {
     expect(workMocks.currentWork.setSelectedSessionId).toHaveBeenCalledWith("chat-worker");
   });
 
+  it("resolves the target lane from the session list when select-session carries no laneId", async () => {
+    // Spawn cards and the subagents pane dispatch without a laneId — the
+    // listener must look the session up so cross-lane jumps still land.
+    workMocks.currentWork.sessions = [
+      workMocks.makeTerminalSession("chat-spawned-child", "lane-background", "codex-chat"),
+    ];
+    Object.defineProperty(window, "ade", {
+      configurable: true,
+      value: { builtInBrowser: { onEvent: vi.fn(() => vi.fn()) } },
+    });
+
+    render(<TerminalsPage />);
+    await screen.findByTestId("work-view-area");
+
+    window.dispatchEvent(
+      new CustomEvent("ade:work:select-session", {
+        detail: { sessionId: "chat-spawned-child" },
+      }),
+    );
+
+    expect(workMocks.fns.selectLane).toHaveBeenCalledWith("lane-background");
+    expect(workMocks.fns.focusSession).toHaveBeenCalledWith("chat-spawned-child");
+    expect(workMocks.fns.openSessionTab).toHaveBeenCalledWith("chat-spawned-child");
+    expect(workMocks.currentWork.setSelectedSessionId).toHaveBeenCalledWith("chat-spawned-child");
+  });
+
   it("opens the Browser sidebar only for matching project open requests", async () => {
     workMocks.projectRoot = "/repo-one";
     const browserEventListener: {
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx b/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
index 1c499eb85..ea44a9394 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
@@ -271,7 +271,11 @@ export function TerminalsPage({ active = true }: { active?: boolean }) {
       const detail = (event as CustomEvent<{ sessionId?: string; laneId?: string }>).detail;
       const sessionId = detail?.sessionId;
       if (!sessionId) return;
-      if (detail.laneId) work.selectLane(detail.laneId);
+      // Callers (spawn cards, subagents pane) often don't know the target's
+      // lane. Resolve it from the loaded session list so cross-lane jumps
+      // land on the right lane instead of focusing an off-lane session.
+      const laneId = detail.laneId ?? work.sessions.find((s) => s.id === sessionId)?.laneId ?? null;
+      if (laneId) work.selectLane(laneId);
       work.focusSession(sessionId);
       work.openSessionTab(sessionId);
       work.setSelectedSessionId(sessionId);
diff --git a/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx b/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
index 11d3b1d28..d60ae1449 100644
--- a/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
+++ b/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
@@ -729,6 +729,7 @@ function CliSessionSurface({
 
 function SessionSurface({
   session,
+  sessionTitleById,
   lanes,
   isActive,
   pageActive = true,
@@ -752,6 +753,7 @@ function SessionSurface({
   terminalPaneOpen,
 }: {
   session: TerminalSessionSummary;
+  sessionTitleById?: ReadonlyMap<string, string>;
   lanes: LaneSummary[];
   isActive: boolean;
   pageActive?: boolean;
@@ -790,6 +792,7 @@ function SessionSurface({
         laneId={session.laneId}
         laneLabel={session.laneName}
         lockSessionId={session.id}
+        sessionTitleById={sessionTitleById}
         hideSessionTabs
         hideLaneToolDrawers
         onSessionCreated={onOpenChatSession}
@@ -1070,6 +1073,10 @@ export function WorkViewArea({
     for (const session of sessions) map.set(session.id, session);
     return map;
   }, [sessions]);
+  const sessionTitleById = useMemo(
+    () => new Map(sessions.map((session) => [session.id, session.title] as const)),
+    [sessions],
+  );
 
   const showingDraft = activeItemId == null;
   const activeSession = showingDraft
@@ -1083,6 +1090,7 @@ export function WorkViewArea({
   const renderGridSession = (session: TerminalSessionSummary) => (
     <SessionSurface
       session={session}
+      sessionTitleById={sessionTitleById}
       lanes={lanes}
       // Exactly the focused grid member is active; every displayed tile stays
       // visible (terminalVisible) and keeps receiving live output. Only the
@@ -1138,6 +1146,7 @@ export function WorkViewArea({
       >
         <SessionSurface
           session={activeSession}
+          sessionTitleById={sessionTitleById}
           lanes={lanes}
           isActive
           pageActive={pageActive}
diff --git a/apps/desktop/src/shared/types/sessions.ts b/apps/desktop/src/shared/types/sessions.ts
index fde0b6fd7..4592ac8fb 100644
--- a/apps/desktop/src/shared/types/sessions.ts
+++ b/apps/desktop/src/shared/types/sessions.ts
@@ -92,6 +92,10 @@ export type TerminalResumeMetadata = {
   targetKind: TerminalResumeTargetKind;
   targetId: string | null;
   launch: TerminalResumeLaunchConfig;
+  /** Chat that spawned this tracked CLI session, independent of terminal ownership. */
+  orchestrationParentSessionId?: string;
+  /** Cosmetic/reporting relationship declared by the spawning chat. */
+  spawnKind?: AgentChatSpawnKind;
   importedFrom?: {
     provider: TerminalResumeProvider;
     targetId: string;
@@ -158,11 +162,12 @@ export type TerminalSessionSummary = {
   orchestrationRole?: OrchestrationRole;
   orchestrationTag?: string;
   /**
-   * Spawn lineage for chat-backed sessions, projected from the underlying chat
-   * session (independent of any orchestration run). `orchestrationParentSessionId`
-   * marks a chat spawned by another chat; `spawnKind` is the spawner-declared,
-   * cosmetic relationship (subagent/peer/none) the sidebar renders as a pill and
-   * uses to count a spawner's live children. Both optional for migration tolerance.
+   * Spawn lineage for chat- and tracked CLI-backed sessions, projected from the
+   * chat record or CLI resume metadata (independent of any orchestration run).
+   * `orchestrationParentSessionId` marks work spawned by another chat; `spawnKind`
+   * is the spawner-declared cosmetic relationship (subagent/peer/none) the sidebar
+   * renders as a pill and uses to count a spawner's live children. Both optional
+   * for migration tolerance.
    */
   orchestrationParentSessionId?: string;
   spawnKind?: AgentChatSpawnKind;
@@ -191,6 +196,8 @@ export type PtyCreateArgs = {
   allowExternalCwd?: boolean;
   /** Session that owns this attached terminal, when launched from chat/CLI UI or App Control. */
   chatSessionId?: string | null;
+  /** Parent chat lineage to export to a spawned agent CLI process. */
+  spawnLineage?: { parentChatSessionId: string; spawnKind: AgentChatSpawnKind | null } | null;
   laneId: string;
   cwd?: string;
   cols: number;
diff --git a/docs/features/agents/README.md b/docs/features/agents/README.md
index 4f5b80bb5..7a7644a0d 100644
--- a/docs/features/agents/README.md
+++ b/docs/features/agents/README.md
@@ -12,9 +12,9 @@ The former worker/hiring agents were removed. There is one persistent identity 
 | `apps/desktop/src/main/services/cto/ctoMemoryService.ts` | The CTO's smart-memory file store (`MEMORY.md`, `thread-state.md`, daily logs, search, injection sections). |
 | `apps/desktop/src/main/services/ai/tools/ctoOperatorTools.ts` | CTO operator tools for chat spawning, lanes/PRs/git/tests, Linear reads/writes, and the `saveMemory` / `searchMemory` / `readMemory` memory tools. |
 | `apps/desktop/src/main/services/agentTools/agentToolsService.ts` | Detects external CLI tools on PATH. |
-| `apps/ade-cli/src/cli.ts` | Agent-focused `ade` command surface and text/JSON output formatters. Includes the `ade ios-sim` (alias `ade ios`, `ade simulator`) family — see [iOS Simulator feature](../ios-simulator/README.md), the `ade --socket app-control ...` driver for live Electron apps, and the `ade --socket browser ...` driver for the in-app browser. `ade secrets list|get|set|delete` is the typed surface for encrypted project-scoped ADE secrets that agents may read when the user names a secret. `ade new chat --mode chat|cli --lane <lane|auto> --provider codex --model <id> --reasoning-effort <tier> --no-fast --permissions full-auto --type <subagent|peer|none> --prompt "..."` mirrors the desktop New Chat toggle. `ade chat create` / `ade new --mode chat` default `orchestrationParentSessionId` from `ADE_CHAT_SESSION_ID` so agent-spawned chats link back to the spawning chat (`--parent <sessionId>` overrides, `--no-parent` opts out). `--type` (chat mode only; alias `--spawn-type`) sets the child's `AgentChatSpawnKind` and thereby its completion-report policy — see [Chat › Spawn types and completion reporting](../chat/README.md#spawn-types-and-completion-reporting). `ade chat read <session> --text` reads recent transcript messages. `ade chat scheduled-work create --cron "<expr>" --prompt "<text>" [--once] [--reason "<text>"] [--session <id>]` creates a provider-neutral durable wakeup; list/cancel use the same runtime management store and cancellation path as desktop Settings. `ade chat ... --personal` lists, creates, reads, sends to, interrupts, archives, and deletes machine-owned projectless chats through the running brain. `ade lanes link-linear-issue <laneId> --linear-issue-json '{...}'` (aliases `link-linear`, `linear-link`) links Linear issues to an existing lane. |
+| `apps/ade-cli/src/cli.ts` | Agent-focused `ade` command surface and text/JSON output formatters. Includes the `ade ios-sim` (alias `ade ios`, `ade simulator`) family — see [iOS Simulator feature](../ios-simulator/README.md), the `ade --socket app-control ...` driver for live Electron apps, and the `ade --socket browser ...` driver for the in-app browser. `ade secrets list|get|set|delete` is the typed surface for encrypted project-scoped ADE secrets that agents may read when the user names a secret. `ade new chat --mode chat|cli --lane <lane|auto> --provider codex --model <id> --reasoning-effort <tier> --no-fast --permissions full-auto --type <subagent|peer|none> --prompt "..."` mirrors the desktop New Chat toggle. Both chat and agent-provider CLI modes default `orchestrationParentSessionId` from `ADE_CHAT_SESSION_ID` (`--parent <sessionId>` overrides, `--no-parent` opts out) and accept `--type` / `--spawn-type`; chat mode stores the fields on the child chat and applies its completion-report policy, while CLI mode sends them as tracked-session lineage without claiming attached-terminal ownership. Plain shell launches omit lineage. See [Chat › Spawn types and completion reporting](../chat/README.md#spawn-types-and-completion-reporting). `ade chat read <session> --text` reads recent transcript messages. `ade chat scheduled-work create --cron "<expr>" --prompt "<text>" [--once] [--reason "<text>"] [--session <id>]` creates a provider-neutral durable wakeup; list/cancel use the same runtime management store and cancellation path as desktop Settings. `ade chat ... --personal` lists, creates, reads, sends to, interrupts, archives, and deletes machine-owned projectless chats through the running brain. `ade lanes link-linear-issue <laneId> --linear-issue-json '{...}'` (aliases `link-linear`, `linear-link`) links Linear issues to an existing lane. |
 | `apps/ade-cli/src/services/account/accountAuthService.ts` | Optional ADE account auth for humans, remote agents, and CI: loopback OAuth, account-directory device authorization, shared `account.session.v1` refresh storage, JWT-`exp`-authoritative access-token refresh, one cross-process refresh-rotation recovery attempt after `invalid_grant`, and ephemeral `ADE_ACCOUNT_TOKEN` credentials. |
-| `apps/ade-cli/src/adeRpcServer.ts` | Private ADE action RPC: registers actions, handles JSON-RPC, applies session-identity-based filtering, builds lane-scoped ADE guidance / `ADE_AGENT_SKILLS_DIRS` for CLI launches, injects an explicitly enabled and verified direct Computer Use MCP client into tracked Codex launches, and returns GitHub + ADE PR URLs from PR creation tools when available. For `chat.createScheduledWork`, `listScheduledWork`, and `cancelScheduledWork`, a bound non-CTO agent defaults an omitted target to its own chat and cannot name another session; an external role without a bound chat is denied. |
+| `apps/ade-cli/src/adeRpcServer.ts` | Private ADE action RPC: registers actions, handles JSON-RPC, applies session-identity-based filtering, builds lane-scoped ADE guidance / `ADE_AGENT_SKILLS_DIRS` for CLI launches, injects an explicitly enabled and verified direct Computer Use MCP client into tracked Codex launches, and returns GitHub + ADE PR URLs from PR creation tools when available. `start_cli_session` validates optional `orchestrationParentSessionId` / `spawnKind`, stores them in agent-provider `TerminalResumeMetadata`, and leaves `chatSessionId` for true attached-terminal ownership. For `chat.createScheduledWork`, `listScheduledWork`, and `cancelScheduledWork`, a bound non-CTO agent defaults an omitted target to its own chat and cannot name another session; an external role without a bound chat is denied. |
 | `apps/desktop/src/main/services/builtInBrowser/builtInBrowserActorCapabilities.ts`, `desktopBridgeServer.ts`; `apps/ade-cli/src/services/builtInBrowser/desktopBridgeClient.ts` | Browser-automation security boundary. ADE issues an opaque in-memory capability for each chat-owned agent/terminal; the runtime strips caller routing and carries the token over a separately authenticated bridge, then Electron validates it in the issuing process and restores only its bound browser scope. |
 | `apps/desktop/src/main/utils/codexComputerUse.ts` | Security boundary for direct Codex Computer Use: explicit config opt-in, stable/cache candidate resolution, executable check, and strict OpenAI code-signature identity verification. |
 | `apps/desktop/resources/agent-skills/ade-cli-control-plane/SKILL.md` | Agent-facing ADE CLI control-plane guidance. |
@@ -74,15 +74,20 @@ project workflow tools are not injected. See [Personal chats](../personal-chats/
 
 ## Spawning agents and spawn types
 
-Any chat-bound agent can spawn another full ADE agent by running
-`ade new chat` — the child inherits `orchestrationParentSessionId` from the
-spawner's `ADE_CHAT_SESSION_ID` (see the CLI row above). The optional
-`--type subagent|peer|none` flag sets the child's `AgentChatSpawnKind`,
-which is **cosmetic to capabilities**: the child is a normal agent with the
-same runtime, permissions, and tools regardless of type. The only thing the
-type governs is how ADE reports the child's completion back to the spawner —
-`subagent` wakes the spawner, `peer` leaves a quiet note, and `none` (the
-default) reports nothing.
+Any chat-bound agent can run `ade new chat` to spawn either another ADE chat
+or a tracked agent CLI session. Both modes inherit
+`orchestrationParentSessionId` from the spawner's `ADE_CHAT_SESSION_ID`, and
+both accept `--parent`, `--no-parent`, and `--type subagent|peer|none`. Plain
+shell terminals do not record this lineage. For a chat child, `--type` sets
+its `AgentChatSpawnKind`, which is **cosmetic to capabilities**: the child is
+a normal agent with the same runtime, permissions, and tools regardless of
+type. It also selects the chat completion-report policy: `subagent` wakes the
+spawner, `peer` leaves a quiet note, and `none` (the default) reports nothing.
+
+For a CLI child, the same parent/type fields are persisted in the tracked
+session's `resumeMetadata` and projected onto `TerminalSessionSummary` for
+lineage UI. They do not populate `chatSessionId`, which remains reserved for
+terminal ownership, and a later resume-command refresh preserves the lineage.
 
 The orchestrator's `spawnAgent` tool
 (`services/ai/tools/orchestrationTools.ts`) and the orchestration domain
diff --git a/docs/features/chat/README.md b/docs/features/chat/README.md
index 31284debb..79ebb8441 100644
--- a/docs/features/chat/README.md
+++ b/docs/features/chat/README.md
@@ -74,7 +74,7 @@ for its separate RPC, sync, storage, and UI contracts.
 | `apps/desktop/src/shared/chatMosaic.ts` | Mosaic v1 — agent-emitted interactive cards. Strict versioned (`"v":1`) parser for ```` ```mosaic ```` fence bodies (`parseMosaicCard`: unknown version/element types, duplicate ids, or malformed JSON → null → callers render the plain fence), submission serializer (`serializeMosaicSubmission`: readable lines + machine JSON, sent through the normal `agentChat.send` path with `displayText`), and `summarizeMosaicCard` for the TUI's one-line summary. Data only — no expressions, no eval, no host actions. Schema documented for agents in the `ade-mosaic` Agent Skill (`apps/desktop/resources/agent-skills/ade-mosaic/SKILL.md`). |
 | `apps/desktop/src/renderer/components/chat/MosaicCard.tsx` | Interactive mosaic card renderer (text, select, multiselect, number/slider, input, approve/deny, key-value table). Hooked in at `MarkdownBlock`'s code-fence handler behind a Claude-gated `mosaic` context prop from `AgentChatPane`; answered state persists across virtualized unmounts via a session-lifetime latch that rolls back on send failure. Non-Claude sessions render the plain fence. |
 | `apps/desktop/src/shared/types/chat.ts` | All chat types: `AgentChatSession`, `AgentChatEvent` union, `AgentChatEventHistorySnapshot` (with optional `sessionFound` for stale-session detection), provider-neutral `AgentChatMcpToolSource` / app context metadata, Codex goal/token-usage/runtime-state DTOs (`CodexSafetyBufferingState`, moderation metadata, sleep/thread-deleted/stall events), the `web_search` event's structured `CodexWebSearchResult[]` (`results`, max 8) plus `resultsTotal`, typed Codex goal/recovery control args, image generation/view events with large-inline-payload omission metadata, permission modes, pending input (including app-server `autoResolutionMs`), completion reports, `AgentChatMessageSession*` peer-message routing DTOs (`auto` / `queue` / `wake` / `interrupt-replace`), `AgentChatCreateScheduledWork*`, `AgentChatSetScheduledWorkPaused*`, `PARALLEL_CHAT_MAX_ATTACHMENTS`, and parallel launch state DTOs. `AgentChatSubagentSnapshot.label` carries provider-assigned display labels such as Codex Agent #N. `AgentChatScheduledWakeMetadata` marks synthetic unattended user turns with schedule id, kind, fire time, reason, and late state. `scheduled_work_update` captures action/Claude wake/cron/background lifecycle including `paused`, `firedAt`, and `late`; `AgentChatSessionSummary.nextWakeAt` and `scheduledWorkPaused` project durable scheduler state into session lists. `transcript_retraction` removes provider-superseded assistant text from renderers without rewriting the persisted JSONL stream. `user_message` events may also carry metadata such as `hideFullPrompt` for internal handoff briefs, while `displayText` remains the user-facing transcript text. `AgentChatSessionSummary.linearIssueLinks?: SessionLinearIssueLink[]` carries the Linear issues attached to the session (chat or CLI), populated from `session_linear_issues` independent of any lane link. The `session_meta_updated` event additionally carries optional permission/interaction mode fields (`permissionMode`, `interactionMode`, `claudePermissionMode`, `codexApprovalPolicy`, `codexSandbox`, `codexConfigSource`, `opencodePermissionMode`, `droidPermissionMode`, `cursorModeId`, `cursorModeSnapshot`) so a mode change made on one client patches every other client's composer state; a title-only emit carries none of them and stays backward-compatible. |
-| `apps/desktop/src/renderer/components/chat/AgentChatPane.tsx` | Top-level renderer surface: state derivation, IPC wiring, composer mount, message-list mount, End/Delete chat controls in the header, parallel multi-model lane launch orchestration, transient-lane cleanup, and multi-lane deep-link navigation. Renders the inline `InlineQuestionRequestCard` (in `AgentChatMessageList`) when the active pending input is a question/structured-question. Resolves the surface accent colour through `providerChatAccent(provider)` so Claude/Codex/Cursor stay visually consistent regardless of model variant; the question/plan cards inherit that same `--chat-accent`. Visible Work grid tiles flush user/lifecycle/live events immediately and poll-recover active transcripts when IPC misses an event, even when the tile is not focused. A visible session whose transcript is still empty but whose summary no longer looks active receives two bounded forced history reads (after 900 ms and 3 s), covering newly-created headless sessions whose first append/event raced the renderer without introducing idle polling. Event-history snapshots with `sessionFound: false` clear stale locked-pane state instead of rendering a dead transcript. Draft chats scope their last-launch config by project/lane/surface/draft-kind and mark local model/reasoning/permission edits as touched so late lane-session hydration cannot overwrite the user's draft selection; composer text is also keyed by the real session id or the lane draft key (`draft:<laneId>`) so switching draft lanes does not leak text through a shared null session key. During project transitions the pane blocks send/model/permission mutations and shows a "Project is switching..." composer placeholder so chat calls do not hit the wrong runtime binding. On macOS, polls `ade.iosSimulator.getStatus` and renders the iOS Simulator drawer toggle in the header when the platform is supported (see [iOS Simulator feature](../ios-simulator/README.md)); selecting elements inside the drawer flows back through the pane as `IosElementContextItem` chips on the composer. Polls `ade.appControl.getStatus` and exposes the App Control drawer toggle when the platform is supported, mounting `ChatAppControlPanel`; selections become `AppControlContextItem` chips + attachments on the composer. See [App Control](../computer-use/app-control.md). When mounted as a Work tile (`SessionSurface` passes `hideLaneToolDrawers={true}`) the iOS, App Control, and chat terminal drawer toggles are suppressed because the Work right-edge sidebar owns those lane-scoped drawers; hidden lane-tool mode also skips App Control status polling and terminal listing. Remote-bound panes further defer local-only App Control / proof snapshot polling until the matching drawer is open, delay unfinished parallel-launch cleanup recovery briefly after mount, cache chat-session lists and slash-command catalogs by active project root, and avoid mount-time session-delta fetches until a remote turn completes. The pane still listens on `ade:agent-chat:add-attachment` / `add-ios-context` / `add-app-control-context` / `add-builtin-browser-context` / `insert-draft` window events so selections from the sidebar flow into the active chat composer; event handlers match on either `sessionId` (for active sessions) or `draftTargetId` (for unsaved draft composers when `draftContextTargetId` is set), enabling the Work sidebar to insert context into a draft composer before a chat session exists. Work-tab CLI launches pass the active lane worktree into the shared launcher so the spawned CLI sees lane-aware Agent Skill roots. Work CLI launches intentionally skip the direct-argv path: the pane drops `command` / `args` from the `onLaunchPtySession` payload and always sends `startupCommand` plus `workCliStartupDelayMs = 180` so the spawned shell can finish drawing its prompt before the CLI invocation is typed in (see [pty-and-processes.md](../terminals-and-sessions/pty-and-processes.md#create-flow-createargs) for how `ptyService.create` consumes the delay). The `onLaunchCliSession` prop is typed as `(args: WorkPtyLaunchArgs) => Promise<WorkPtyLaunchResult>` and passes `disposition` matching the draft launch mode so background CLI launches do not steal focus. Internal draft launch state is structured through `DraftLaunchMode`, `DraftLaunchKind`, `DraftLaunchLaneTarget`, `StartedDraftLaunch`, and `DraftLaunchJob`. Each draft launch creates a `DraftLaunchJob` that tracks multi-step progress through a state machine (`creating-lane` -> `starting-session` -> `sending-prompt` -> `ready` | `failed`; auto-created lanes are named deterministically up front and the AI rename runs in the background via `startBackgroundLaneNaming` / `startBackgroundParallelLaneNaming`, surfaced through `laneNamingStore`, so there is no blocking `naming-lane` phase) and stores it in the **root** store's `draftLaunchJobsByScope` (read via `useRootAppStore` / `rootAppStoreApi.getState()`) keyed by project root, lane, surface profile, and Work draft kind so loading/error strips survive pane remounts — and a remote project switch that tears down the originating per-project store — without leaking into another lane pane. The detached launch chain captures the originating `OpenProjectBinding`, passes it as a `pin` to branch/lane/chat/orchestration/PTY calls so a mid-launch project switch keeps targeting the originating runtime, pins rollback (`lanes.delete` / `agentChat.delete` with a `pin`) to that binding, and caps each step with `withDraftLaunchTimeout` (90 s). The composer is cleared optimistically when the job starts rather than after it finishes; active jobs remain visible while terminal rows are pruned by scope. The pane renders status strips with Open/Restore for ready/failed jobs, Dismiss for terminal jobs, and a hide-status escape hatch for stale active jobs. Failed jobs offer a Restore button that merges the snapshot back into the composer (merging attachments and context items by identity rather than replacing). `clearDraftLaunchComposer` resets the draft, attachments, and context items after a successful launch. `DraftLaunchJob` carries `draftKind` so the dismissible job strip's "Open" action restores the correct Work draft kind (chat vs. CLI). Proof remains chat-scoped and stays on the chat header. |
+| `apps/desktop/src/renderer/components/chat/AgentChatPane.tsx` | Top-level renderer surface: state derivation, IPC wiring, composer mount, message-list mount, End/Delete chat controls in the header, parallel multi-model lane launch orchestration, transient-lane cleanup, and multi-lane deep-link navigation. Renders the inline `InlineQuestionRequestCard` (in `AgentChatMessageList`) when the active pending input is a question/structured-question. Resolves the surface accent colour through `providerChatAccent(provider)` so Claude/Codex/Cursor stay visually consistent regardless of model variant; the question/plan cards inherit that same `--chat-accent`. Visible Work grid tiles flush user/lifecycle/live events immediately and poll-recover active transcripts when IPC misses an event, even when the tile is not focused. A visible session whose transcript is still empty but whose summary no longer looks active receives two bounded forced history reads (after 900 ms and 3 s), covering newly-created headless sessions whose first append/event raced the renderer without introducing idle polling. Event-history snapshots with `sessionFound: false` clear stale locked-pane state instead of rendering a dead transcript. Draft chats scope their last-launch config by project/lane/surface/draft-kind and mark local model/reasoning/permission edits as touched so late lane-session hydration cannot overwrite the user's draft selection; composer text is also keyed by the real session id or the lane draft key (`draft:<laneId>`) so switching draft lanes does not leak text through a shared null session key. During project transitions the pane blocks send/model/permission mutations and shows a "Project is switching..." composer placeholder so chat calls do not hit the wrong runtime binding. On macOS, polls `ade.iosSimulator.getStatus` and renders the iOS Simulator drawer toggle in the header when the platform is supported (see [iOS Simulator feature](../ios-simulator/README.md)); selecting elements inside the drawer flows back through the pane as `IosElementContextItem` chips on the composer. Polls `ade.appControl.getStatus` and exposes the App Control drawer toggle when the platform is supported, mounting `ChatAppControlPanel`; selections become `AppControlContextItem` chips + attachments on the composer. See [App Control](../computer-use/app-control.md). When mounted as a Work tile (`SessionSurface` passes `hideLaneToolDrawers={true}`) the iOS, App Control, and chat terminal drawer toggles are suppressed because the Work right-edge sidebar owns those lane-scoped drawers; hidden lane-tool mode also skips App Control status polling and terminal listing. Remote-bound panes further defer local-only App Control / proof snapshot polling until the matching drawer is open, delay unfinished parallel-launch cleanup recovery briefly after mount, cache chat-session lists and slash-command catalogs by active project root, and avoid mount-time session-delta fetches until a remote turn completes. The pane still listens on `ade:agent-chat:add-attachment` / `add-ios-context` / `add-app-control-context` / `add-builtin-browser-context` / `insert-draft` window events so selections from the sidebar flow into the active chat composer; event handlers match on either `sessionId` (for active sessions) or `draftTargetId` (for unsaved draft composers when `draftContextTargetId` is set), enabling the Work sidebar to insert context into a draft composer before a chat session exists. Work-tab CLI launches pass the active lane worktree into the shared launcher so the spawned CLI sees lane-aware Agent Skill roots. Work CLI launches intentionally skip the direct-argv path: the pane drops `command` / `args` from the `onLaunchPtySession` payload and always sends `startupCommand` plus `workCliStartupDelayMs = 180` so the spawned shell can finish drawing its prompt before the CLI invocation is typed in (see [pty-and-processes.md](../terminals-and-sessions/pty-and-processes.md#create-flow-createargs) for how `ptyService.create` consumes the delay). The `onLaunchCliSession` prop is typed as `(args: WorkPtyLaunchArgs) => Promise<WorkPtyLaunchResult>` and passes `disposition` matching the draft launch mode so background CLI launches do not steal focus. Internal draft launch state is structured through `DraftLaunchMode`, `DraftLaunchKind`, `DraftLaunchLaneTarget`, `StartedDraftLaunch`, and `DraftLaunchJob`. Each draft launch creates a `DraftLaunchJob` that tracks multi-step progress through a state machine (`creating-lane` -> `starting-session` -> `sending-prompt` -> `ready` | `failed`; auto-created lanes are named deterministically up front and the AI rename runs in the background via `startBackgroundLaneNaming` / `startBackgroundParallelLaneNaming`, surfaced through `laneNamingStore`, so there is no blocking `naming-lane` phase) and stores it in the **root** store's `draftLaunchJobsByScope` (read via `useRootAppStore` / `rootAppStoreApi.getState()`) keyed by project root, lane, surface profile, and Work draft kind so loading/error strips survive pane remounts — and a remote project switch that tears down the originating per-project store — without leaking into another lane pane. The detached launch chain captures the originating `OpenProjectBinding`, passes it as a `pin` to branch/lane/chat/orchestration/PTY calls so a mid-launch project switch keeps targeting the originating runtime, pins rollback (`lanes.delete` / `agentChat.delete` with a `pin`) to that binding, and caps each step with `withDraftLaunchTimeout` (90 s). The composer is cleared optimistically when the job starts rather than after it finishes; active jobs remain visible while terminal rows are pruned by scope. The pane renders status strips with Open/Restore for ready/failed jobs, Dismiss for terminal jobs, and a hide-status escape hatch for stale active jobs. Failed jobs offer a Restore button that merges the snapshot back into the composer (merging attachments and context items by identity rather than replacing). `clearDraftLaunchComposer` resets the draft, attachments, and context items after a successful launch. `DraftLaunchJob` carries `draftKind` so the dismissible job strip's "Open" action restores the correct Work draft kind (chat vs. CLI). Locked Work embeddings accept a full session-title index for spawned-chat roster labels, and spawned chats render a type-tinted **View parent thread** header control. Proof remains chat-scoped and stays on the chat header. |
 | `apps/desktop/src/renderer/components/chat/usage/contextUsageModel.ts` | Provider-neutral context meter reducer. Automatic per-turn Claude `context_usage` snapshots (`origin: "live"`) are filtered out of the transcript and feed only this reducer, so the composer meter's hover (`ContextUsageDial`) — not an inline card — is the primary context-usage surface; the user-invoked `/context` command (`origin: "command"`) is the only `context_usage` that still renders an inline breakdown card. The reducer reads the snapshot's typed breakdown (`inputTokens` / `outputTokens` / `cacheReadTokens` / `cacheCreationTokens`) so the dial's hover is a complete replacement for that card, falling back to showing the total as input when no breakdown is present. A completed `context_compact` boundary invalidates older usage for Claude, Codex, OpenCode, Cursor, and Droid; generic same-turn counters are ignored because those SDKs can report pre-compaction per-turn/cumulative totals after the history was replaced. Claude `postTokens` / exact `context_usage` and Codex `thread/tokenUsage/updated` snapshots can repopulate the meter immediately. Desktop, ADE Code, and iOS mirror this boundary rule. Codex token breakdowns are normalized in `agentChatService.ts` (`normalizeCodexTokenBreakdown`), which maps 0.145's `cacheWriteInputTokens` / `reasoningOutputTokens` onto `cacheWriteTokens` / `reasoningTokens`; the desktop `ContextUsageDial` tooltip renders `cache write` and `reasoning` segments (in addition to in/out/cached) whenever those counts are present. |
 | `apps/desktop/src/renderer/components/usage/ActivityModule.tsx` | Reusable activity, token, code-movement, and client-mix module. `AgentChatPane` mounts `WorkActivityModule` directly below an empty Work draft composer (desktop and web only); it reads `usage.getAdeStats` through the active `window.ade` adapter, defaults to all-time activity, and preserves explicit tab/range choices locally. |
 | `apps/desktop/src/renderer/lib/agentChatSessionListCache.ts` | Short-lived renderer cache for `ade.agentChat.list`, keyed by active project root, lane, automation, and archive flags. Normal reads coalesce; forced reads bypass an older in-flight promise, and promise-identity checks prevent the superseded response from repopulating the cache. Mutations invalidate by project/lane so remote Work panes do not fan out repeated list calls while still refreshing immediately after create/archive/delete. |
@@ -85,13 +85,13 @@ for its separate RPC, sync, storage, and UI contracts.
 | `apps/desktop/src/renderer/state/appStore.ts` | Shared renderer state store. Besides project/lane/work selection, it persists user preferences such as `launchPromptClipboardEnabled` and `launchPromptClipboardNoticeEnabled`, mirrors them into per-project stores, and owns `draftLaunchJobsByScope` (+ `setDraftLaunchJobs`) for Work draft launch status strips plus `handoffLaunchJobsByScope` (+ `setHandoffLaunchJobs`) for Work sidebar handoff placeholders. These live in the **root** store (not the per-project store) on purpose: in-flight launches must survive a remote project switch that destroys the originating per-project store; `AgentChatPane` reads them via `useRootAppStore` / `rootAppStoreApi.getState()`. |
 | `apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx` | Virtualized transcript renderer. Coalesces resize / measurement updates and, while sticky-to-bottom is active, follows height changes across multiple animation frames so streamed output and late row measurements do not leave the user above the newest message. Programmatic scroll writes are tracked by target scroll position, not a stale counter, so browser-coalesced scroll events do not swallow the next real user gesture. Activity bundles fold todo/scheduled updates and placeholder subagent updates into compact rows, dedupe placeholder subagent parents once the concrete child id is known, and open Chat Info / subagent detail instead of duplicating the drawer roster inline; real subagents instead render as inline `SubagentSpawnCard` / `SubagentResultCard` rows anchored where they started and settled (background shell commands collapse to a single `BackgroundFinishChip`), with jump-to-result / jump-to-start affordances that reuse the stable-row scroll machinery; a run of two or more interrupt-stopped subagents folds into one calm `SubagentStoppedGroupCard` instead of a wall of identical stopped cards. Synthetic scheduled turns render an amber `Woke on schedule` divider with fire time, reason, and late marker; the existing stable-row scroll machinery accepts jump requests from the while-you-were-away strip. Codex goal lifecycle events render as compact user-facing rows (`Goal set`, `Goal paused`, `Goal cleared`) instead of raw JSON-RPC/status wording. Codex runtime notices (`codex_safety_buffering`, `codex_moderation_metadata`, `codex_sleep`, `codex_thread_deleted`) render as small transcript chips. `codex_turn_stalled` renders a live recovery card: Wait re-arms the watchdog, Nudge sends a status steer, Retry interrupts and replays work in the same thread, and Resume restarts app-server, resumes the thread, and retries. Handoff brief user messages with `metadata.hideFullPrompt` show only their `displayText` breadcrumb and do not expose or copy the internal prompt body. History seeded into a forked chat (envelopes tagged `providerOrigin: "handoff_fork"`) renders under a single `Forked from the previous chat — full history above` divider pinned to the first live row after the seeded tail, rather than a per-row marker. Error events whose `errorInfo.agentCli.category` is `"unauthenticated"` render as the calm `AgentCliAuthCard` (raw 401 behind a `Details` disclosure) rather than the red error block, so a recoverable logout reads as a re-login prompt, not a crash. |
 | `apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx` | Inline subagent transcript cards mounted by `AgentChatMessageList` from the render events `chatTranscriptRows.ts` derives. `SubagentSpawnCard` anchors where the agent started (identicon/colour from `chatSubagentIdentity`, task title, agent-type/background chips, a single live `running · <activity> · <N> tools · <elapsed>` line that ticks each second, and a `jump to result` link once the agent ends); `SubagentResultCard` renders at the settle position (status + duration, ~2-line report preview, View transcript, `jump to start`, warm amber tones for stopped/failed instead of red error blocks); `BackgroundFinishChip` is the one-line finish chip for backgrounded shell commands; `SubagentStoppedGroupCard` collapses a run of interrupt-stopped subagents into one amber "N agents stopped when you interrupted" line that expands to a per-agent list with `jump to start` links. All inherit `--chat-accent`. |
-| `apps/desktop/src/renderer/components/chat/spawnNavigation.ts` | One canonical `navigateToSpawnedChat(sessionId, laneId?)` helper that dispatches the `ade:work:select-session` window event (behind a try/catch, no-op on a falsy id). Every spawn surface routes through it: the inline `SubagentSpawnCard` (when it carries a `chat:<id>` taskId), the `spawn_wake_divider` and `spawn_completed` completion rows, the subagent roster row click in `ChatSubagentsPanel`, and the header lineage breadcrumb in `AgentChatPane`, so the navigation contract stays in one place. |
+| `apps/desktop/src/renderer/components/chat/spawnNavigation.ts` | One canonical `navigateToSpawnedChat(sessionId, laneId?)` helper that dispatches the `ade:work:select-session` window event (behind a try/catch, no-op on a falsy id). Every spawn surface routes through it: the inline `SubagentSpawnCard`, `spawn_wake_divider` and `spawn_completed` completion rows, spawned-chat rows in `ChatSubagentsPanel`, the `AgentChatPane` parent-thread breadcrumb, and the `SessionCard` lineage glyph. `TerminalsPage` resolves an omitted lane from the loaded session list before focusing the target, so cross-lane jumps land on the correct lane. |
 | `apps/desktop/src/renderer/components/chat/ChatActionsDrawerPanel.tsx`, `ChatSourcesPanel.tsx`, `chatSources.ts` | Codex Chat Actions source inventory. Sources is the first available tab and derives a deduplicated list of attachments/files, web searches/results, MCP apps/tools, and external resource URLs from the current transcript. HTTP(S) rows open in ADE's built-in browser; internal `node_repl` plumbing and unsafe protocols are excluded. |
 | `apps/desktop/src/renderer/components/chat/ChatGitToolbar.tsx` | Git / PR quick-action toolbar above the composer. If the lane already has a linked PR, the PR button opens or toggles that PR; otherwise it routes to the PR workspace with a create-PR handoff (`create=1&sourceLaneId=<lane>&target=primary`). When the chat PR pane or compact PR menu opens, it asks `prReadCache.refreshLinkedPrCoalesced` for a targeted `prs.refresh({ prIds })` so the badge picks up merged/closed/check transitions without broad GitHub polling. An unmapped lane PR (a `github_pr_projections`-derived summary with `pr.unmapped === true` and a synthetic `gh:` id) has no DB row to refresh or fetch checks for, so both the live refresh and `getChecks` are skipped for it. |
 | `apps/desktop/src/renderer/components/chat/ChatPrPane.tsx` | Left floating PR pane for Work chat. Renders cached lane PR details immediately, then performs the same cooldown-bound targeted PR refresh as the toolbar before settling the state. Terminal PRs hide stale running-check labels so merged/closed PRs do not keep showing in-progress CI from an old cache row. An unmapped (`pr.unmapped`) lane PR skips the live refresh and the checks/reviews/status enrichment, since it has no DB row behind the synthetic `gh:` id. |
 | `apps/desktop/src/renderer/lib/visualContextFormatting.ts` | Serializes iOS, App Control, built-in browser, and attachment context into prompt text. |
 | `apps/desktop/src/renderer/components/chat/RewindFilesConfirmDialog.tsx`, `rewindFilesPreview.ts` | Chat file-rewind confirmation surface. Claude uses the SDK `rewindFiles` control call; Codex uses ADE's git-backed file restore plan plus a version-gated app-server call — `thread/fork` before the target turn on servers >= 0.145.0, and the deprecated `thread/rollback` fallback on <= 0.144 or when the target turn has no usable id (see [agent-routing.md](./agent-routing.md#codex-rewind-and-0145-readiness)). `rewindFilesPreview.ts` maps the selected user message to turn diff summaries and per-file SHA ranges; the dialog lists every restored file, expands rows into `AdeDiffViewer`, and confirms the provider rewind without using browser-native confirm UI. |
-| `apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx`, `chatSubagentIdentity.tsx`, `codex/CodexGoalCard.tsx` | Chat Info drawer content: Codex goal card, capped/collapsible plan and task sections, and capped Subagents/Background/Schedule rosters. Running subagent and background durations derive from the wall clock and tick once per second; terminal rows retain their final compact duration. Terminal work moves into one **Completed** disclosure without reordering survivors; failed and pinned rows stay active; Clear hides only terminal Completed rows and Restore reverses it. Schedule pause/play remains in the Schedule header, recurring rows show last-run plus next-fire timing, and each active ADE-managed durable row exposes Cancel; provider-only/non-durable transcript rows stay visible without a false cancellation control. A Claude-owned job remains visible and paused while ADE asks that same session to confirm `CronDelete`. ADE Code and iOS mirror the grouping and cap behavior; iOS separately gates Cancel and Pause/Resume on the connected host's chat-scope action descriptors. `chatSubagentIdentity.tsx` centralizes deterministic subagent identity, and the Codex goal card stays above the roster. |
+| `apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx`, `chatExecutionSummary.ts`, `chatSubagentIdentity.tsx`, `codex/CodexGoalCard.tsx` | Chat Info drawer content: Codex goal card, capped/collapsible plan and task sections, and capped Subagents/Background/Schedule rosters. Running subagent and background durations derive from the wall clock and tick once per second; terminal rows retain their final compact duration. Terminal work moves into one **Completed** disclosure without reordering survivors; failed and pinned rows stay active; Clear hides only terminal Completed rows and Restore reverses it. Schedule pause/play remains in the Schedule header, recurring rows show last-run plus next-fire timing, and each active ADE-managed durable row exposes Cancel; provider-only/non-durable transcript rows stay visible without a false cancellation control. Spawned-chat snapshots carry a derived `childSessionId`; the derivation preserves the `chat:` task id and `spawnKind` when the canonical dotted lifecycle twin merges into the underscore event. Their roster rows show the child's live session title, put the runtime in the small kind chip, and navigate directly to the child instead of opening a provider transcript drawer. `chatSubagentIdentity.tsx` centralizes deterministic identity and exposes status-optional, size-configurable glyphs for both roster state and compact lineage cues. |
 | `apps/desktop/src/renderer/components/chat/ChatBuiltInBrowserPanel.tsx` | Renderer panel for the in-app browser. Renders the address bar, tabs strip, navigation controls, an inspect/select toolbar, and a `BuiltInBrowserStatus`-derived empty/error state, then asks the main process to position the underlying `WebContentsView` over the panel's bounding rect through `ade.builtInBrowser.setBounds`. Its trusted-renderer-only **Profile** panel shows global cookie counts/domains, cache size, last safe flush, and remembered site permissions, with per-row Remove and Clear all controls. Because native `WebContentsView` content sits above the renderer, the panel hides it while ADE overlays, dialogs, menus, or popovers overlap the browser surface so ADE chrome remains reachable. Mounted by `WorkSidebar` under the `browser` tab and (indirectly) by any renderer code that calls `openUrlInAdeBrowser()` — the helper opens the sidebar Browser tab and dispatches the URL into a fresh tab. Selections committed through inspect-mode hit-testing fan out via the `onAddContext` callback as `BuiltInBrowserContextItem` payloads. |
 | `apps/desktop/src/renderer/components/work/WorkSurfaceHeader.tsx`, `ClaudeLoginPromptButton.tsx` | Shared Work surface header chrome for chat and CLI surfaces: title, lane chip, Claude cache badge, git toolbar, caller-provided trailing actions, and the dismissible Claude login CTA that starts `claude auth login` in a tracked PTY. The `WorkSurfaceTitle` sub-component plays a one-time CSS shimmer when the title transitions from a provider default (`Claude Chat`, `Codex Chat`, …) to a real auto-generated title while the surface stays mounted, and respects `prefers-reduced-motion`. `AgentChatPane` also reuses `ClaudeLoginPromptButton` as a sticky bar above the composer (keyed `composer-auth:<sessionId>`) while a Claude session is logged out, but only when the chat header pill is absent so the two never double up. |
 | `apps/desktop/src/renderer/components/chat/AgentCliAuthCard.tsx` | Inline install / re-login card for missing or unauthenticated agent CLIs, rendered in the transcript from a decorated `error` event's `errorInfo.agentCli` payload. Copy chips + a tracked-PTY Run button (`window.ade.pty.create`) for the install / auth command. The logged-out (`category: "unauthenticated"`) variant is terracotta-toned for Claude (amber for other agents), retitles to "&lt;Provider&gt; is logged out", and adds an always-on **Retry turn** button that resends the last user message via the `CHAT_RETRY_AUTH_TURN_EVENT` (`ade:chat:retry-auth-turn`) window event; it collapses to a "Reconnected" confirmation when `AgentChatPane` fires `CHAT_AUTH_RECOVERED_EVENT` (`ade:chat:auth-recovered`) after a later turn succeeds. The "missing CLI" variant keeps the red-free amber install card. |
@@ -862,11 +862,14 @@ finishes.
 
 Where it is set:
 
-- `ade new chat --mode chat --type subagent|peer|none` (alias
-  `--spawn-type`). CLI-mode launches ignore the flag. Combined with the
-  existing `ADE_CHAT_SESSION_ID` → `orchestrationParentSessionId` default,
-  an agent that runs `ade new chat` links the child back to itself and can
-  choose how it wants to be told the child finished.
+- `ade new chat --mode chat|cli --type subagent|peer|none` (alias
+  `--spawn-type`). Both modes default `orchestrationParentSessionId` from
+  `ADE_CHAT_SESSION_ID`; `--parent` overrides it and `--no-parent` opts out.
+  Chat mode stores the fields on the child chat and uses `spawnKind` for the
+  completion policy below. Agent-provider CLI mode sends the same fields to
+  `start_cli_session`, which stores them in `TerminalResumeMetadata` for
+  lineage UI; plain shell launches omit them, and CLI lineage never populates
+  `chatSessionId` because that field means attached-terminal ownership.
 - The orchestrator `spawnAgent` tool
   (`apps/desktop/src/main/services/ai/tools/orchestrationTools.ts`) and the
   orchestration domain's `spawnAgent`
@@ -875,7 +878,7 @@ Where it is set:
 
 ### Type-decided completion reporting
 
-When any spawned child reaches a terminal turn, `reportChildSpawnEnded` in
+When any spawned chat child reaches a terminal turn, `reportChildSpawnEnded` in
 `agentChatService.ts` reports to the spawner based on the child's
 `spawnKind`:
 
@@ -918,19 +921,30 @@ an inline card was emitted.
 
 Every spawn surface routes through `navigateToSpawnedChat` in
 `spawnNavigation.ts` (see the source file map). `spawnKind` and
-`orchestrationParentSessionId` are projected from the chat session onto
-`TerminalSessionSummary` (`apps/desktop/src/shared/types/sessions.ts`) so
-the Work sidebar can render, without any extra fetch:
+`orchestrationParentSessionId` are projected onto `TerminalSessionSummary`
+(`apps/desktop/src/shared/types/sessions.ts`) from either the chat session or a
+tracked agent CLI's normalized `resumeMetadata`. CLI resume-command refreshes
+merge with the existing metadata so these fields survive continuation. The
+Work sidebar can therefore render, without any extra fetch:
 
 - a type pill on the spawner-declared child (`SessionCard` — violet for
   `subagent`, slate for `peer`, hidden for `none`), and
 - a live-children badge (`▸N`) counting a spawner's still-`running`
   children, derived in `SessionListPane` from the already-loaded session
-  list.
-
-`AgentChatPane` renders a two-way lineage breadcrumb: a spawned child shows
-a `↳ from "<spawner>"` chip in its header that navigates back to the parent
-(type-tinted, parent title resolved from the loaded session list).
+  list, and
+- a small status-optional lineage identicon immediately left of the status dot
+  on every child with a parent. Its tooltip names the parent from the
+  unfiltered session-title index when available; clicking it opens the parent
+  without selecting the child card.
+
+`AgentChatPane` renders a type-tinted **View parent thread** header button for
+a spawned chat. The tooltip names the parent when its title is available, and
+the button is the keyboard/assistive-technology route back to the parent.
+Spawned-chat rows in `ChatSubagentsPanel` derive an explicit `childSessionId`
+and navigate to it directly. Their labels prefer the live child title threaded
+from `WorkViewArea`; preserving the `chat:` task id and `spawnKind` through the
+canonical dotted/underscore event twin keeps the row navigable regardless of
+event order.
 
 ## IPC surface
 
diff --git a/docs/features/chat/composer-and-ui.md b/docs/features/chat/composer-and-ui.md
index fbe307463..a8402e820 100644
--- a/docs/features/chat/composer-and-ui.md
+++ b/docs/features/chat/composer-and-ui.md
@@ -36,7 +36,7 @@ subagents, computer use). The pane derives all visible state from the
 | `apps/desktop/src/shared/chatScheduledWork.ts` | Pure scheduled-work derivation. Folds `scheduled_work_update` envelopes into Chat Info schedule rows for Claude wakeups, cron tasks, `/loop`, remote triggers, and background work; defines the shared Background/Schedule Earlier predicates (including fired one-shot wakeups); and formats next-fire labels. A parent turn's terminal event does not stop a background row, and background snapshots whose `sourceTaskId` belongs to a real subagent are omitted so native Agents do not appear twice. Shared by desktop, ADE Code, and mirrored by iOS. |
 | `ChatFileChangesPanel.tsx` | Turn-level file change summary with lazy diff expansion. |
 | `RewindFilesConfirmDialog.tsx`, `rewindFilesPreview.ts` | Undo confirmation for provider-backed file rewind. Builds a message-scoped file list from provider dry-run output plus turn diff summaries, then renders per-file expandable diffs before applying `rewindFiles`. Claude uses SDK file checkpoints; Codex forks the thread before the selected turn (`thread/fork` + `beforeTurnId`) on app-server >= 0.145.0, or falls back to `thread/rollback` (latest user message only) on older servers, and restores files through ADE's git plan. |
-| `ChatSubagentsPanel.tsx` | Chat Info panel. It renders the Codex goal card, latest plan, tasks, schedule, and subagent/background rosters. Running subagent and background rows derive elapsed time from the wall clock and tick once per second; terminal rows keep their final compact duration. Large sections cap active rows and add Show all; terminal rows move into one Completed fold; Clear/Restore is a visual per-session filter. Failed and pinned rows remain active, survivors keep source order, and the pane variant owns a single scroller with sticky section headers. The Schedule header keeps the per-chat pause/play action. For Codex sessions the goal card stays above plan/subagent progress so the current objective stays visible without crowding the chat header. |
+| `ChatSubagentsPanel.tsx` | Chat Info panel. It renders the Codex goal card, latest plan, tasks, schedule, and subagent/background rosters. Running subagent and background rows derive elapsed time from the wall clock and tick once per second; terminal rows keep their final compact duration. Large sections cap active rows and add Show all; terminal rows move into one Completed fold; Clear/Restore is a visual per-session filter. Failed and pinned rows remain active, survivors keep source order, and the pane variant owns a single scroller with sticky section headers. Spawned-chat rows are identified by `childSessionId`, show the live child title supplied by `AgentChatPane` / `WorkViewArea`, keep the runtime as a small kind chip, and navigate to the child rather than opening the provider-subagent drawer. The Schedule header keeps the per-chat pause/play action. For Codex sessions the goal card stays above plan/subagent progress so the current objective stays visible without crowding the chat header. |
 | `ChatComputerUsePanel.tsx` | Computer-use backend status. |
 | `ChatAppControlPanel.tsx` | App Control panel for Electron apps. Two mount points: under the chat composer (chat-scoped, `sessionId` set) and inside the Work right-edge sidebar (lane-scoped, `sessionId={null}`). Two modes: **Control** (live screencast frames + launch/connect form + click/type input + quick `terminal write` / `terminal signal` actions) and **Inspect** (hit-test crosshair on the screenshot; commits selections as `AppControlContextItem`s with screenshot, DOM packet, and source-file candidates). Persists panel state under `sessionStorage["ade.chat.appControlPanel.<key>"]`, where the key is `chat:<sessionId>` for the chat mount and `lane:<laneId>:<projectRoot>` for the sidebar mount. Connect/launch calls forward `laneId` so the resulting `AppControlSession` records its launching lane. See [App Control](../computer-use/app-control.md). |
 | `ChatIosSimulatorPanel.tsx` | macOS-only iOS Simulator drawer. Two mount points: under the chat composer and inside the Work right-edge sidebar. Tool-readiness checklist, device + target pickers, three-backend live preview, `interact` vs `inspect` mode, hit-test overlay, and selection emission as `IosElementContextItem`. Accepts an optional `laneId` prop, forwarded into `iosSimulator.launch` so the resulting `IosSimulatorSession` records its launching lane. Simulator controls are not blocked when another chat session owns the simulator — ownership only affects which session receives context insertions, not whether the user can interact with the device. See [iOS Simulator feature](../ios-simulator/README.md). |
@@ -664,12 +664,17 @@ the same panel with zero new chrome: `claudeWorkflowProgress.ts` normalizes
 the undocumented `workflow_progress` snapshot and fans each workflow agent
 out as its own subagent row (phase in the summary line, tokens/duration
 from the snapshot, `workflowName` chip), while the parent workflow task row
-falls back to a phase/count rollup summary. Child chat sessions spawned
-with a parent lineage (`ade chat create` from a tracked agent shell,
-`--parent`) also list here via synthetic `subagent_*` events keyed
-`chat:<childSessionId>`; the parent transcript additionally shows a quiet
-"Subagent spawned" chip (a `status:"subagent_spawned"` system_notice) that
-deep-links to the child chat.
+falls back to a phase/count rollup summary. Child chat sessions spawned with
+a parent lineage (`ade chat create` from a tracked agent shell, `--parent`)
+also list here via synthetic `subagent_*` events keyed
+`chat:<childSessionId>`. `deriveChatSubagentSnapshots` preserves that prefixed
+task id and the underscore event's `spawnKind` when the canonical dot-form
+`subagent.started` twin merges into the same snapshot, then derives an explicit
+`childSessionId`. The panel uses that field for routing, labels the row with
+the live child-session title when available, and shows the runtime as the small
+kind chip. The parent transcript additionally shows a quiet "Subagent spawned"
+chip (a `status:"subagent_spawned"` system notice) that deep-links to the child
+chat.
 
 Codex parallel-agent lifecycle comes from both legacy `collabAgentToolCall`
 items and newer app-server `subAgentActivity` items. The service registers
diff --git a/docs/features/terminals-and-sessions/README.md b/docs/features/terminals-and-sessions/README.md
index 280c2fb50..c620410cc 100644
--- a/docs/features/terminals-and-sessions/README.md
+++ b/docs/features/terminals-and-sessions/README.md
@@ -111,7 +111,11 @@ and in tests.
   tests. Branch updated.
 - `apps/desktop/src/main/services/sessions/sessionService.ts` — persistence
   layer for `terminal_sessions` rows. CRUD, continuation metadata
-  normalization, `reattach`, `reconcileStaleRunningSessions`. Reconcile and
+  normalization, `reattach`, `reconcileStaleRunningSessions`. Normalized
+  `TerminalResumeMetadata` retains optional `orchestrationParentSessionId` /
+  `spawnKind`; tracked agent CLI rows project those fields onto
+  `TerminalSessionSummary`, and resume-command backfill merges the existing
+  metadata so lineage survives continuation. Reconcile and
   ownership-aware queries gate row sweeps on both live owners and known local
   owners from `processRegistryService`: a `running` row whose owner is live
   belongs to a sibling and must be left alone; a row whose owner is known on
@@ -135,6 +139,16 @@ and in tests.
   [ARCHITECTURE.md §3.4](../../ARCHITECTURE.md#34-cross-process-ownership).
 - `apps/desktop/src/main/services/sessions/sessionService.test.ts` —
   session persistence tests.
+- `apps/ade-cli/src/cli.ts`, `apps/ade-cli/src/adeRpcServer.ts` —
+  `ade new chat --mode cli` forwards the parent chat id and spawn kind for
+  agent providers; `start_cli_session` validates them and persists them in
+  `TerminalResumeMetadata` without assigning `chatSessionId`. Plain shell
+  sessions omit the fields.
+- `apps/ade-cli/src/tuiClient/closedCliSessions.ts`,
+  `apps/ade-cli/src/tuiClient/components/Drawer.tsx` — ADE Code projects spawn
+  lineage from closed tracked CLI resume metadata and shows compact `sub` /
+  `peer` markers for chat and CLI children in the session drawer; `none` stays
+  visually quiet.
 - `apps/desktop/src/main/services/sessions/sessionDeltaService.ts` —
   end-of-session git diff + transcript delta computation, reads from
   `session_deltas` table.
@@ -168,7 +182,8 @@ Shared types and IPC:
 
 - `apps/desktop/src/shared/types/sessions.ts` — `TerminalSessionSummary`,
   `TerminalSessionStatus`, `TerminalToolType`, `TerminalRuntimeState`,
-  `TerminalResumeMetadata`, `PtyCreateArgs`, `SessionDeltaSummary`,
+  `TerminalResumeMetadata` (including tracked CLI spawn lineage),
+  `PtyCreateArgs`, `SessionDeltaSummary`,
   offset-stamped `PtyDataEvent`,
   `PtySendToSessionArgs` / `PtySendToSessionResult` (the
   send-or-continue surface), `PtyResumeSessionArgs` /
@@ -267,9 +282,10 @@ Renderer surfaces:
   `window.ade.pty.resumeSession`, alongside the continuation composer
   that sends a new prompt through `window.ade.pty.sendToSession`.
   It also listens for the renderer-wide `ade:work:select-session` event
-  used by orchestration panels and worker-to-lead links; the listener
-  selects the lane when supplied, focuses the target session, opens its
-  Work tab, and updates `selectedSessionId`.
+  used by orchestration panels and lineage links; the listener uses the
+  supplied lane when present or resolves it from the loaded session list,
+  then focuses the target session, opens its Work tab, and updates
+  `selectedSessionId`.
   Also owns the right-edge `WorkSidebar` toggle and resizer: when the
   sidebar is open and the view mode is not `grid`, the work view area
   shares its row with `WorkSidebar` via a flex container with a
@@ -356,10 +372,16 @@ Renderer surfaces:
   `CreateLaneDialogHost` in `close-on-create` mode, so a new lane can
   be created from Work without navigating away; once the lane record
   exists, env setup continues detached and failures surface as a sticky
-  retry toast.
+  retry toast. It also builds parent-title and live-child indexes from the
+  unfiltered session list, so a lineage tooltip can name a parent hidden by
+  the current lane/search filter.
 - `apps/desktop/src/renderer/components/terminals/SessionCard.tsx` —
   per-session card (status dot, title, preview line, tool type, lane,
-  delta chips). Chat summaries with a future `nextWakeAt` render a compact
+  delta chips). Any session with `orchestrationParentSessionId` renders a
+  small deterministic lineage identicon immediately left of the status dot;
+  its tooltip names the parent when available, and clicking it opens the
+  parent without selecting the child card. Chat summaries with a future
+  `nextWakeAt` render a compact
   `⏰ <duration>` chip that refreshes while the row is mounted; paused or
   overdue schedules omit the chip because their session summary reports no
   future wake. Surfaces a small amber warning pip next to the title
@@ -383,7 +405,9 @@ Renderer surfaces:
 - `apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx` —
   tabs/grid/single Work view. The grid mode renders through the shared
   `PaneTilingLayout`; the seed tree comes from
-  `buildWorkSessionTilingTree`. Also hosts the chat-like continuation
+  `buildWorkSessionTilingTree`. It builds a session-title index and threads it
+  into locked `AgentChatPane` embeddings so spawned-chat roster rows use live
+  child titles. Also hosts the chat-like continuation
   composer for ended tracked agent CLI sessions: when a Claude / Codex /
   Cursor / OpenCode / Droid PTY has exited, the surface keeps the
   transcript and renders a model / permission / slash-aware composer
@@ -781,7 +805,10 @@ Fields that feed UI and downstream systems:
 - git anchoring: `headShaStart`, `headShaEnd` (used by
   `sessionDeltaService`)
 - resume: `resumeCommand`, `resumeMetadata` (provider, target kind,
-  target ID, launch config)
+  target ID, launch config, and optional `orchestrationParentSessionId` /
+  `spawnKind` for tracked agent CLI lineage)
+- spawn lineage: optional `orchestrationParentSessionId` and `spawnKind`,
+  projected from a chat record or tracked agent CLI `resumeMetadata`
 
 See `apps/desktop/src/shared/types/sessions.ts` for the full shape.
 
@@ -990,7 +1017,8 @@ Processes (managed):
 - `resumeCommand` is derived from `resumeMetadata` when present, then
   falls back to `defaultResumeCommandForTool(toolType)`. Editing it
   directly is only allowed through `sessionService.setResumeCommand` or
-  `updateMeta`, both of which re-derive the metadata.
+  `updateMeta`, both of which re-derive the metadata; target-id refreshes merge
+  the current metadata so tracked CLI spawn lineage is not discarded.
 - Transcript writes are capped at 16 MB; after the cap a notice line is
   written once and further output is dropped. The runtime seeds
   `transcriptBytesWritten` from the file size on attach, so the cap
diff --git a/docs/features/terminals-and-sessions/pty-and-processes.md b/docs/features/terminals-and-sessions/pty-and-processes.md
index d992493e1..637691c92 100644
--- a/docs/features/terminals-and-sessions/pty-and-processes.md
+++ b/docs/features/terminals-and-sessions/pty-and-processes.md
@@ -57,9 +57,12 @@ filesystem outside `readTranscriptTail`.
 
 `mapRow()` converts the row into `TerminalSessionSummary` /
 `TerminalSessionDetail`. It parses `resumeMetadata` through
-`normalizeResumeMetadata` (handles legacy `target` vs modern `targetId`),
-then derives `resumeCommand` via `deriveResumeMetadataCommand` so
-downstream code always sees a normalized command even for old rows.
+`normalizeResumeMetadata` (handles legacy `target` vs modern `targetId` and
+retains optional `orchestrationParentSessionId` / `spawnKind`), then derives
+`resumeCommand` via `deriveResumeMetadataCommand` so downstream code always
+sees a normalized command even for old rows. For tracked agent CLI tool types,
+`mapRow()` also projects those lineage fields onto the session summary; shell
+and other terminal rows do not acquire lineage from resume metadata.
 
 ### Exported methods
 
@@ -114,7 +117,10 @@ downstream code always sees a normalized command even for old rows.
   refuses to overwrite when it is set.
 - Continuation metadata is stored as a JSON blob. `normalizeResumeMetadata`
   accepts both the current `{ provider, targetKind, targetId, launch }`
-  shape and legacy fields (`target`, `permissionMode` at the top level).
+  shape (plus optional `orchestrationParentSessionId` / `spawnKind`) and legacy
+  fields (`target`, `permissionMode` at the top level). `setResumeCommand`
+  merges parsed target data into the existing metadata so the two lineage
+  fields survive a resume-target refresh.
 - `runtime_processes` is machine-local bookkeeping, not replicated
   project state. It is excluded from CRR setup; synced terminal rows may
   describe sessions owned by another machine, and local reconcile must
diff --git a/docs/features/terminals-and-sessions/ui-surfaces.md b/docs/features/terminals-and-sessions/ui-surfaces.md
index 839584d4f..f80c62afb 100644
--- a/docs/features/terminals-and-sessions/ui-surfaces.md
+++ b/docs/features/terminals-and-sessions/ui-surfaces.md
@@ -43,10 +43,12 @@ targets attach to the chat session and `pty` targets attach to the running
 CLI session id.
 
 The same page is the subscriber for `ade:work:select-session`, the
-renderer event dispatched by orchestration "Open chat" buttons. The
-handler accepts `{ sessionId, laneId? }`, selects the lane when present,
-focuses the target chat, opens its Work tab, and stores it as the active
-selected session.
+renderer event dispatched by orchestration and lineage navigation. The
+handler accepts `{ sessionId, laneId? }`; when the caller omits `laneId`, it
+resolves the target lane from the loaded session list. It then selects that
+lane, focuses the target session, opens its Work tab, and stores it as the
+active selected session. This lets a spawned-chat row or parent-lineage glyph
+jump across lanes without already knowing the target lane.
 
 `useWorkLaneDeleteProgress` also makes this page the Work-owned consumer of
 lane deletion state. While Work is active it subscribes to streamed delete
@@ -162,6 +164,11 @@ from the active organization mode and uncollapsed groups) as the third
 argument so shift-range selection follows the visual order the user
 sees, not the underlying data order.
 
+The pane derives `liveChildrenByParentId` and `sessionTitleById` from the
+unfiltered session inventory. The latter uses `primarySessionLabel()` and is
+passed to each child card as `parentSessionTitle`, so lineage tooltips can name
+a parent even when search, lane, or status filters hide its row.
+
 ### `SessionCard.tsx`
 
 Three rows:
@@ -170,7 +177,13 @@ Three rows:
    `primarySessionLabel()` drive these. The relative time comes from
    `relativeTimeCompact`. Disposed CLI rows render a small inline
    "Stopped" label immediately before the red status dot rather than an
-   attention capsule.
+   attention capsule. When `orchestrationParentSessionId` is present, a small
+   deterministic `ChatSubagentGlyph` appears immediately left of the status
+   dot. `SessionListPane` supplies the parent title from its unfiltered session
+   index for the tooltip; clicking the glyph stops card selection and routes
+   to the parent through `navigateToSpawnedChat`. The glyph is a mouse
+   shortcut inside the existing card button; a spawned chat's **View parent
+   thread** header control remains the keyboard/assistive-technology route.
 2. **Preview line** (conditional) — when the card's lane is mid
    background AI auto-naming (`useLaneNaming(lane.id)` from
    `renderer/state/laneNamingStore.ts` is true), this row instead shows an
@@ -216,6 +229,11 @@ idle age so the user can decide whether to close it.
 Owns the render target for open sessions. Supports three modes tied to
 `viewMode`:
 
+`WorkViewArea` also builds a title index for all loaded sessions and threads
+it through `SessionSurface` into locked `AgentChatPane` embeddings. The chat
+pane uses it to label spawned-chat rows in Chat Info with the live child title
+instead of the provider/runtime fallback.
+
 - `tabs` — tab-strip + single `SessionSurface` for the active tab, plus
   a "New Chat" button in the tab strip. A second sub-mode (`hasGroupedTabs`)
   renders lane-grouped tab chips with per-group collapse. Lane group chips use