From 784899ffbfe4ef24f5103711bfd9c8ddbfe78ef2 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Fri, 10 Jul 2026 03:26:53 -0400
Subject: [PATCH 1/9] fix(chat): ended chats no longer resurrect via durable
 scheduled work

Deliberate end (delete/archive chat, lane archive/delete, explicit dispose)
now cancels the chat's durable schedules and ends the row as "disposed";
project close and graceful quit end live rows as "detached" so KV-persisted
schedules survive for restart late-fire/cold resume. The scheduler's
sessionState contract gains an "ended" state that cancels at reconcile,
fire, claim, and upsert. Lane teardown also cancels schedules for sessions
never rehydrated this run. finishSession clears pending native wakes, and
terminal Claude teardown reaps the session's SDK subprocesses per-session.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../services/chat/agentChatService.test.ts    | 413 +++++++++++++++++-
 .../main/services/chat/agentChatService.ts    |  54 ++-
 .../chat/chatScheduledWorkScheduler.test.ts   | 109 +++++
 .../chat/chatScheduledWorkScheduler.ts        |   2 +-
 .../chat/claudeSubprocessReaper.test.ts       |  35 ++
 .../services/chat/claudeSubprocessReaper.ts   |  64 ++-
 docs/features/chat/README.md                  |  21 +-
 7 files changed, 666 insertions(+), 32 deletions(-)

diff --git a/apps/desktop/src/main/services/chat/agentChatService.test.ts b/apps/desktop/src/main/services/chat/agentChatService.test.ts
index 57e5a40eb..889675583 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.test.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.test.ts
@@ -799,6 +799,7 @@ import { createOrchestrationService } from "../orchestration/orchestrationServic
 import { runGit } from "../git/git";
 import { deriveScheduledWorkSnapshots } from "../../../shared/chatScheduledWork";
 import { parseAgentChatTranscript } from "../../../shared/chatTranscript";
+import type { ChatScheduledWorkRecord, ChatScheduledWorkState } from "./chatScheduledWorkScheduler";
 import { mapPermissionToCodex } from "./permissionMapping";
 import { acquireCursorSdkConnection, releaseCursorSdkConnection } from "./cursorSdkPool";
 import { acquireDroidSdkConnection } from "./droidSdkPool";
@@ -1211,7 +1212,7 @@ function createMockSessionService() {
       const sessionId = typeof args === "string" ? args : args?.sessionId;
       const row = sessions.get(sessionId);
       if (row) {
-        row.status = "ended";
+        row.status = args?.status ?? "disposed";
         row.endedAt = args?.endedAt ?? new Date().toISOString();
       }
     }),
@@ -1278,6 +1279,142 @@ function createMockProjectConfigService() {
   } as any;
 }
 
+const SCHEDULED_WORK_STATE_KEY = "agent-chat:scheduled-work:v1";
+const SCHEDULE_TEST_START = Date.parse("2026-07-10T09:00:00.000Z");
+
+function createScheduledWorkDb(initialState: ChatScheduledWorkState | null = null) {
+  const values = new Map<string, unknown>();
+  if (initialState) values.set(SCHEDULED_WORK_STATE_KEY, structuredClone(initialState));
+  return {
+    db: {
+      getJson: vi.fn((key: string) => structuredClone(values.get(key) ?? null)),
+      setJson: vi.fn((key: string, value: unknown) => {
+        values.set(key, structuredClone(value));
+      }),
+    },
+    readState: (): ChatScheduledWorkState | null => {
+      const state = values.get(SCHEDULED_WORK_STATE_KEY);
+      return state ? structuredClone(state) as ChatScheduledWorkState : null;
+    },
+  };
+}
+
+function storedWakeup(
+  sessionId: string,
+  overrides: Partial<ChatScheduledWorkRecord> = {},
+): ChatScheduledWorkRecord {
+  return {
+    id: `wakeup:${sessionId}`,
+    sessionId,
+    kind: "wakeup",
+    prompt: "Check PR CI and report the result.",
+    reason: "Check PR CI",
+    fireAt: Date.now() + 60_000,
+    createdAt: Date.now(),
+    status: "scheduled",
+    pausedFlag: false,
+    lateFlag: false,
+    ...overrides,
+  };
+}
+
+function installClaudeWakeupFixture(args: {
+  sdkSessionId: string;
+  delaySeconds: number;
+  prompt?: string;
+}) {
+  let streamCall = 0;
+  const send = vi.fn().mockResolvedValue(undefined);
+  const close = vi.fn();
+  const handle = {
+    send,
+    stream: vi.fn(() => (async function* () {
+      streamCall += 1;
+      if (streamCall === 1) {
+        yield {
+          type: "system",
+          subtype: "init",
+          session_id: args.sdkSessionId,
+          slash_commands: [],
+        };
+        return;
+      }
+      yield {
+        type: "assistant",
+        message: {
+          content: [{
+            type: "tool_use",
+            id: `tool-${args.sdkSessionId}`,
+            name: "ScheduleWakeup",
+            input: {
+              delaySeconds: args.delaySeconds,
+              reason: "Check PR CI",
+              prompt: args.prompt ?? "Check PR CI and report the result.",
+            },
+          }],
+          usage: { input_tokens: 1, output_tokens: 1 },
+        },
+      };
+      yield {
+        type: "result",
+        subtype: "success",
+        is_error: false,
+        session_id: args.sdkSessionId,
+        usage: { input_tokens: 1, output_tokens: 1 },
+      };
+    })()),
+    close,
+    sessionId: args.sdkSessionId,
+    setPermissionMode: vi.fn().mockResolvedValue(undefined),
+  };
+  vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue(handle as any);
+  vi.mocked(claudeSdkResumeSessionCompat).mockReturnValue(handle as any);
+  return { handle, send, close };
+}
+
+function installClaudeResponseFixture(args: {
+  sdkSessionId: string;
+  responseText: string;
+}) {
+  let streamCall = 0;
+  const send = vi.fn().mockResolvedValue(undefined);
+  const handle = {
+    send,
+    stream: vi.fn(() => (async function* () {
+      streamCall += 1;
+      if (streamCall === 1) {
+        yield {
+          type: "system",
+          subtype: "init",
+          session_id: args.sdkSessionId,
+          slash_commands: [],
+        };
+        return;
+      }
+      yield {
+        type: "assistant",
+        message: {
+          content: [{ type: "text", text: args.responseText }],
+          usage: { input_tokens: 1, output_tokens: 1 },
+        },
+      };
+      yield {
+        type: "result",
+        subtype: "success",
+        is_error: false,
+        session_id: args.sdkSessionId,
+        usage: { input_tokens: 1, output_tokens: 1 },
+      };
+    })()),
+    close: vi.fn(),
+    sessionId: args.sdkSessionId,
+    setPermissionMode: vi.fn().mockResolvedValue(undefined),
+  };
+  vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue(handle as any);
+  vi.mocked(claudeSdkResumeSessionCompat).mockReturnValue(handle as any);
+  return { handle, send };
+}
+
 function createService(overrides: Record<string, unknown> = {}) {
   const logger = createLogger();
   const laneService = createMockLaneService();
@@ -3031,6 +3168,7 @@ describe("createAgentChatService", () => {
       const claudeSubprocessReaper = {
         register: vi.fn(),
         spawnClaudeCodeProcess: vi.fn(() => spawnedProcess),
+        reapForSession: vi.fn(),
         reapAll: vi.fn(),
         liveRecords: vi.fn(() => []),
       };
@@ -3078,6 +3216,12 @@ describe("createAgentChatService", () => {
           cwd: expect.any(String),
         }),
       );
+
+      await service.dispose({ sessionId: session.id });
+      expect(claudeSubprocessReaper.reapForSession).toHaveBeenCalledWith(
+        session.id,
+        "ended_session",
+      );
     });
 
     it("appends discovered project slash commands to the Claude system prompt", async () => {
@@ -11138,6 +11282,140 @@ describe("createAgentChatService", () => {
       );
     });
 
+    it("dispose cancels durable schedules and emits cancelled scheduled_work_update", async () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(SCHEDULE_TEST_START);
+      const scheduledWork = createScheduledWorkDb();
+      const events: AgentChatEventEnvelope[] = [];
+      installClaudeWakeupFixture({
+        sdkSessionId: "sdk-dispose-cancel",
+        delaySeconds: 60,
+      });
+      const { service, sessionService } = createService({
+        db: scheduledWork.db,
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await service.runSessionTurn({
+        sessionId: session.id,
+        text: "Check CI again later.",
+      });
+      expect(scheduledWork.readState()?.schedules).toEqual([
+        expect.objectContaining({ sessionId: session.id, status: "scheduled" }),
+      ]);
+
+      await service.dispose({ sessionId: session.id });
+
+      expect(sessionService.get(session.id)).toEqual(expect.objectContaining({
+        status: "disposed",
+        endedAt: expect.any(String),
+      }));
+      expect(scheduledWork.readState()?.schedules).toEqual([
+        expect.objectContaining({ sessionId: session.id, status: "cancelled" }),
+      ]);
+      expect(events).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          sessionId: session.id,
+          event: expect.objectContaining({
+            type: "scheduled_work_update",
+            status: "cancelled",
+          }),
+        }),
+      ]));
+      service.forceDisposeAll();
+    });
+
+    it("a scheduled fire after dispose does not resume the session", async () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(SCHEDULE_TEST_START);
+      const scheduledWork = createScheduledWorkDb();
+      const events: AgentChatEventEnvelope[] = [];
+      installClaudeWakeupFixture({
+        sdkSessionId: "sdk-dispose-no-fire",
+        delaySeconds: 1,
+      });
+      const { service, sessionService } = createService({
+        db: scheduledWork.db,
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await service.runSessionTurn({
+        sessionId: session.id,
+        text: "Wake once to check CI.",
+      });
+      await service.dispose({ sessionId: session.id });
+      const startedTurnsBeforeAdvance = events.filter((event) =>
+        event.sessionId === session.id
+        && event.event.type === "status"
+        && event.event.turnStatus === "started"
+      ).length;
+
+      await vi.advanceTimersByTimeAsync(65_000);
+
+      expect(sessionService.get(session.id)).toEqual(expect.objectContaining({
+        status: "disposed",
+        endedAt: expect.any(String),
+      }));
+      expect(scheduledWork.readState()?.schedules[0]?.status).toBe("cancelled");
+      expect(events.filter((event) =>
+        event.sessionId === session.id
+        && event.event.type === "status"
+        && event.event.turnStatus === "started"
+      )).toHaveLength(startedTurnsBeforeAdvance);
+      expect(events.some((event) =>
+        event.sessionId === session.id
+        && event.event.type === "user_message"
+        && event.event.metadata?.scheduledWake != null
+      )).toBe(false);
+      service.forceDisposeAll();
+    });
+
+    it("finishSession clears pending native scheduled wakes", async () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(SCHEDULE_TEST_START);
+      const scheduledWork = createScheduledWorkDb();
+      const events: AgentChatEventEnvelope[] = [];
+      installClaudeWakeupFixture({
+        sdkSessionId: "sdk-pending-native-wake",
+        delaySeconds: 60,
+        prompt: "Stale native wake must not survive dispose.",
+      });
+      const { service } = createService({
+        db: scheduledWork.db,
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await service.runSessionTurn({
+        sessionId: session.id,
+        text: "Queue a native wake.",
+      });
+      await vi.advanceTimersByTimeAsync(60_000);
+      expect(scheduledWork.readState()?.schedules[0]?.status).toBe("fired");
+      expect(service.pendingNativeScheduledWakeCountForTesting(session.id)).toBe(1);
+
+      await service.dispose({ sessionId: session.id });
+
+      expect(service.pendingNativeScheduledWakeCountForTesting(session.id)).toBe(0);
+      expect(events.some((event) =>
+        event.sessionId === session.id
+        && event.event.type === "user_message"
+        && event.event.metadata?.scheduledWake?.reason === "Stale native wake must not survive dispose."
+      )).toBe(false);
+      service.forceDisposeAll();
+    });
+
     it("evicts disposed chats from the live managed session cache", async () => {
       const { service } = createService();
       const session = await service.createSession({
@@ -11265,6 +11543,7 @@ describe("createAgentChatService", () => {
       const claudeSubprocessReaper = {
         register: vi.fn(),
         spawnClaudeCodeProcess: vi.fn(),
+        reapForSession: vi.fn(),
         reapAll: vi.fn(),
         liveRecords: vi.fn(() => []),
       };
@@ -11274,6 +11553,138 @@ describe("createAgentChatService", () => {
 
       expect(claudeSubprocessReaper.reapAll).toHaveBeenCalledWith("dispose_all");
     });
+
+    it("disposeAll ends sessions as detached and preserves scheduled work", async () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(SCHEDULE_TEST_START);
+      const scheduledWork = createScheduledWorkDb();
+      installClaudeWakeupFixture({
+        sdkSessionId: "sdk-dispose-all-detached",
+        delaySeconds: 60,
+      });
+      const { service, sessionService } = createService({ db: scheduledWork.db });
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await service.runSessionTurn({
+        sessionId: session.id,
+        text: "Schedule work across restart.",
+      });
+
+      await service.disposeAll();
+
+      expect(sessionService.end).toHaveBeenCalledWith(expect.objectContaining({
+        sessionId: session.id,
+        status: "detached",
+      }));
+      expect(sessionService.get(session.id)).toEqual(expect.objectContaining({
+        status: "detached",
+        endedAt: expect.any(String),
+      }));
+      expect(scheduledWork.readState()?.schedules).toEqual([
+        expect.objectContaining({ sessionId: session.id, status: "scheduled" }),
+      ]);
+    });
+
+    it("scheduled fire into a detached session still delivers by cold resume", async () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(SCHEDULE_TEST_START);
+      const scheduledWork = createScheduledWorkDb();
+      installClaudeWakeupFixture({
+        sdkSessionId: "sdk-detached-cold-resume",
+        delaySeconds: 60,
+        prompt: "Deliver this wake after restart.",
+      });
+      const first = createService({ db: scheduledWork.db });
+      const session = await first.service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await first.service.runSessionTurn({
+        sessionId: session.id,
+        text: "Schedule restart work.",
+      });
+      await first.service.disposeAll();
+
+      const events: AgentChatEventEnvelope[] = [];
+      installClaudeResponseFixture({
+        sdkSessionId: "sdk-detached-cold-resume",
+        responseText: "Cold scheduled work delivered.",
+      });
+      const restarted = createService({
+        db: scheduledWork.db,
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+      await restarted.service.refreshScheduledWork();
+
+      await vi.advanceTimersByTimeAsync(60_000);
+      await vi.waitFor(() => {
+        expect(events.some((event) =>
+          event.sessionId === session.id
+          && event.event.type === "user_message"
+          && event.event.metadata?.scheduledWake?.reason === "Check PR CI"
+        )).toBe(true);
+      });
+
+      expect(restarted.sessionService.get(session.id)).toEqual(expect.objectContaining({
+        status: "running",
+        endedAt: null,
+      }));
+      expect(events.some((event) =>
+        event.sessionId === session.id
+        && event.event.type === "done"
+        && event.event.status === "completed"
+      )).toBe(true);
+      expect(scheduledWork.readState()?.schedules[0]?.status).toBe("done");
+      restarted.service.forceDisposeAll();
+    });
+  });
+
+  describe("disposeForLane", () => {
+    it("cancels schedules for lane sessions including unmanaged ones", async () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(SCHEDULE_TEST_START);
+      mockState.sessions.set("unmanaged-lane-1", {
+        id: "unmanaged-lane-1",
+        laneId: "lane-1",
+        toolType: "claude-chat",
+        status: "running",
+        startedAt: new Date().toISOString(),
+        endedAt: null,
+        archivedAt: null,
+      });
+      mockState.sessions.set("unmanaged-lane-2", {
+        id: "unmanaged-lane-2",
+        laneId: "lane-2",
+        toolType: "claude-chat",
+        status: "running",
+        startedAt: new Date().toISOString(),
+        endedAt: null,
+        archivedAt: null,
+      });
+      const scheduledWork = createScheduledWorkDb({
+        version: 1,
+        schedules: [
+          storedWakeup("unmanaged-lane-1"),
+          storedWakeup("unmanaged-lane-2"),
+          storedWakeup("missing-session"),
+        ],
+        pausedSessionIds: [],
+      });
+      const { service } = createService({ db: scheduledWork.db });
+
+      await expect(service.disposeForLane("lane-1")).resolves.toBe(0);
+
+      expect(scheduledWork.readState()?.schedules).toEqual([
+        expect.objectContaining({ sessionId: "missing-session", status: "cancelled" }),
+        expect.objectContaining({ sessionId: "unmanaged-lane-1", status: "cancelled" }),
+        expect.objectContaining({ sessionId: "unmanaged-lane-2", status: "scheduled" }),
+      ]);
+      service.forceDisposeAll();
+    });
   });
 
   describe("forceDisposeAll", () => {
diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index 44da697a8..5bab70be6 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -12023,6 +12023,13 @@ export function createAgentChatService(args: {
       if (preserveProviderResumeState) persistChatState(managed);
       cancelClaudeWarmup(managed, managed.runtime, "teardown");
       try { managed.runtime.query?.close(); } catch { /* ignore */ }
+      if (
+        openCodeReason === "ended_session"
+        || openCodeReason === "handle_close"
+        || openCodeReason === "model_switch"
+      ) {
+        claudeSubprocessReaper.reapForSession(managed.session.id, openCodeReason);
+      }
       managed.runtime.inputPump?.close();
       try { managed.runtime.warmQuery?.close(); } catch { /* ignore */ }
       managed.runtime.query = null;
@@ -12221,6 +12228,7 @@ export function createAgentChatService(args: {
     status: TerminalSessionStatus,
     options?: { exitCode?: number | null; summary?: string | null }
   ): Promise<void> => {
+    pendingNativeScheduledWakeBySession.delete(managed.session.id);
     if (managed.endedNotified) return;
     managed.endedNotified = true;
     clearSubagentSnapshots(managed.session.id);
@@ -12233,6 +12241,16 @@ export function createAgentChatService(args: {
     }
     managed.localPendingInputs.clear();
 
+    if (status === "disposed") {
+      await scheduledWorkReady;
+      if (scheduledWorkScheduler) {
+        await Promise.all(
+          scheduledWorkScheduler.list(managed.session.id).map((schedule) =>
+            scheduledWorkScheduler!.cancel(schedule.id)),
+        );
+      }
+    }
+
     if (options?.summary !== undefined) {
       sessionService.setSummary(managed.session.id, options.summary);
     }
@@ -28799,6 +28817,9 @@ export function createAgentChatService(args: {
     await scheduledWorkScheduler?.refreshGlobalPause();
   };
 
+  const pendingNativeScheduledWakeCountForTesting = (sessionId: string): number =>
+    pendingNativeScheduledWakeBySession.get(sessionId)?.length ?? 0;
+
   const hasActiveWorkloads = (): boolean => {
     for (const managed of managedSessions.values()) {
       if (managed.closed || managed.deleted) continue;
@@ -28889,6 +28910,17 @@ export function createAgentChatService(args: {
         errors.push(`${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
       }
     }
+    await scheduledWorkReady;
+    if (scheduledWorkScheduler) {
+      await Promise.all(
+        scheduledWorkScheduler.list()
+          .filter((schedule) => {
+            const row = sessionService.get(schedule.sessionId);
+            return !row || row.laneId === laneId;
+          })
+          .map((schedule) => scheduledWorkScheduler!.cancel(schedule.id)),
+      );
+    }
     if (errors.length > 0) {
       throw new Error(`Failed to close ${errors.length} chat session${errors.length === 1 ? "" : "s"}: ${errors.join("; ")}`);
     }
@@ -30043,7 +30075,10 @@ export function createAgentChatService(args: {
     return await loadModelCatalogRequest(catalogArgs);
   };
 
-  const dispose = async ({ sessionId }: AgentChatDisposeArgs): Promise<void> => {
+  const disposeManagedSession = async (
+    { sessionId }: AgentChatDisposeArgs,
+    terminalStatus: "disposed" | "detached",
+  ): Promise<void> => {
     const managed = ensureManagedSession(sessionId);
     abortActiveBashControllers(managed, "Session disposed.");
 
@@ -30139,11 +30174,15 @@ export function createAgentChatService(args: {
       cancelQueuedSteers(managed, managed.runtime, "disposed");
     }
 
-    await finishSession(managed, "disposed", {
+    await finishSession(managed, terminalStatus, {
       summary: managed.preview ? `Session closed: ${managed.preview}` : "Session closed."
     });
   };
 
+  const dispose = async (args: AgentChatDisposeArgs): Promise<void> => {
+    await disposeManagedSession(args, "disposed");
+  };
+
   const deleteSession = async ({ sessionId }: AgentChatDeleteArgs): Promise<void> => {
     const trimmedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
     if (!trimmedSessionId.length) {
@@ -30256,7 +30295,7 @@ export function createAgentChatService(args: {
     scheduledWorkScheduler?.dispose();
     for (const sessionId of [...managedSessions.keys()]) {
       try {
-        await dispose({ sessionId });
+        await disposeManagedSession({ sessionId }, "detached");
       } catch {
         // ignore shutdown errors
       }
@@ -32828,7 +32867,9 @@ export function createAgentChatService(args: {
     sessionState: (sessionId) => {
       const row = sessionService.get(sessionId);
       if (!row) return "missing";
-      return row.archivedAt ? "archived" : "active";
+      if (row.archivedAt) return "archived";
+      if (row.status === "running" || row.status === "detached") return "active";
+      return "ended";
     },
     fire: async (schedule, context) => {
       const firedAt = new Date(schedule.lastFiredAt ?? Date.now()).toISOString();
@@ -32885,7 +32926,9 @@ export function createAgentChatService(args: {
       const row = sessionService.get(schedule.sessionId);
       if (!row || row.archivedAt) return;
       const managed = managedSessions.get(schedule.sessionId)
-        ?? (status === "fired" ? ensureManagedSession(schedule.sessionId) : null);
+        ?? (status === "fired" && (row.status === "running" || row.status === "detached")
+          ? ensureManagedSession(schedule.sessionId)
+          : null);
       if (!managed || managed.session.provider !== "claude") return;
 
       const eventStatus: ScheduledWorkEvent["status"] = status === "done" ? "completed" : status;
@@ -32936,6 +32979,7 @@ export function createAgentChatService(args: {
     messageSession,
     setScheduledWorkPaused,
     refreshScheduledWork,
+    pendingNativeScheduledWakeCountForTesting,
     readTranscript,
     setOrchestrationFields,
     getCodexGoal,
diff --git a/apps/desktop/src/main/services/chat/chatScheduledWorkScheduler.test.ts b/apps/desktop/src/main/services/chat/chatScheduledWorkScheduler.test.ts
index 54847b7aa..ccdcf2ba9 100644
--- a/apps/desktop/src/main/services/chat/chatScheduledWorkScheduler.test.ts
+++ b/apps/desktop/src/main/services/chat/chatScheduledWorkScheduler.test.ts
@@ -49,6 +49,115 @@ afterEach(() => {
 });
 
 describe("createChatScheduledWorkScheduler", () => {
+  it("cancels persisted work for an ended session during start reconciliation", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(START);
+    let state: ChatScheduledWorkState | null = storedState([wakeup()]);
+    const transitions: string[] = [];
+    const fire = createFireMock();
+    const scheduler = createChatScheduledWorkScheduler({
+      loadState: () => cloneState(state),
+      saveState: (next) => {
+        state = structuredClone(next);
+      },
+      isGlobalPaused: () => false,
+      sessionState: () => "ended",
+      fire,
+      onTransition: (_schedule, status) => {
+        transitions.push(status);
+      },
+    });
+
+    await scheduler.start();
+    await vi.advanceTimersByTimeAsync(60_000);
+
+    expect(fire).not.toHaveBeenCalled();
+    expect(transitions).toEqual(["cancelled"]);
+    expect(requireState(state).schedules[0]).toEqual(expect.objectContaining({
+      id: "wake-1",
+      status: "cancelled",
+    }));
+    scheduler.dispose();
+  });
+
+  it("cancels work when its session becomes ended before processDue fires", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(START);
+    let sessionState: "active" | "ended" = "active";
+    let state: ChatScheduledWorkState | null = null;
+    const transitions: string[] = [];
+    const fire = createFireMock();
+    const scheduler = createChatScheduledWorkScheduler({
+      loadState: () => cloneState(state),
+      saveState: (next) => {
+        state = structuredClone(next);
+      },
+      isGlobalPaused: () => false,
+      sessionState: () => sessionState,
+      fire,
+      onTransition: (_schedule, status) => {
+        transitions.push(status);
+      },
+    });
+    await scheduler.upsert(wakeup({ fireAt: START + 1_000 }));
+
+    sessionState = "ended";
+    await vi.advanceTimersByTimeAsync(1_000);
+
+    expect(fire).not.toHaveBeenCalled();
+    expect(transitions).toEqual(["scheduled", "cancelled"]);
+    expect(requireState(state).schedules[0]?.status).toBe("cancelled");
+    scheduler.dispose();
+  });
+
+  it("does not let an ended session claim a native scheduled fire", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(START);
+    let sessionState: "active" | "ended" = "active";
+    const scheduler = createChatScheduledWorkScheduler({
+      loadState: () => null,
+      saveState: () => undefined,
+      isGlobalPaused: () => false,
+      sessionState: () => sessionState,
+      fire: createFireMock(),
+    });
+    await scheduler.upsert(wakeup({ fireAt: START }));
+
+    sessionState = "ended";
+    const claimed = scheduler.claimNativeFire("session-1", "native-turn-ended");
+
+    expect(claimed).toBeNull();
+    expect(scheduler.list("session-1")[0]).toEqual(expect.objectContaining({
+      id: "wake-1",
+      status: "scheduled",
+    }));
+    scheduler.dispose();
+  });
+
+  it("persists a new schedule as cancelled when its session is ended", async () => {
+    let state: ChatScheduledWorkState | null = null;
+    const transitions: string[] = [];
+    const scheduler = createChatScheduledWorkScheduler({
+      loadState: () => null,
+      saveState: (next) => {
+        state = structuredClone(next);
+      },
+      isGlobalPaused: () => false,
+      sessionState: () => "ended",
+      fire: createFireMock(),
+      onTransition: (_schedule, status) => {
+        transitions.push(status);
+      },
+    });
+
+    const schedule = await scheduler.upsert(wakeup());
+
+    expect(schedule.status).toBe("cancelled");
+    expect(transitions).toEqual(["cancelled"]);
+    expect(requireState(state).schedules[0]?.status).toBe("cancelled");
+    scheduler.dispose();
+  });
+
   it("persists an arm and re-arms it in a fresh scheduler after restart", async () => {
     vi.useFakeTimers();
     vi.setSystemTime(START);
diff --git a/apps/desktop/src/main/services/chat/chatScheduledWorkScheduler.ts b/apps/desktop/src/main/services/chat/chatScheduledWorkScheduler.ts
index 906ecf6eb..8ca7ba2dc 100644
--- a/apps/desktop/src/main/services/chat/chatScheduledWorkScheduler.ts
+++ b/apps/desktop/src/main/services/chat/chatScheduledWorkScheduler.ts
@@ -55,7 +55,7 @@ export type ChatScheduledWorkSchedulerOptions = {
   now?: () => number;
   timers?: ChatScheduledWorkTimerApi;
   isGlobalPaused(): boolean;
-  sessionState(sessionId: string): "active" | "archived" | "missing";
+  sessionState(sessionId: string): "active" | "ended" | "archived" | "missing";
   fire(schedule: ChatScheduledWorkRecord, context: { late: boolean }): Promise<void>;
   onTransition?: (
     schedule: ChatScheduledWorkRecord,
diff --git a/apps/desktop/src/main/services/chat/claudeSubprocessReaper.test.ts b/apps/desktop/src/main/services/chat/claudeSubprocessReaper.test.ts
index f0df4a914..7b960826f 100644
--- a/apps/desktop/src/main/services/chat/claudeSubprocessReaper.test.ts
+++ b/apps/desktop/src/main/services/chat/claudeSubprocessReaper.test.ts
@@ -144,6 +144,41 @@ describe("createClaudeSubprocessReaper", () => {
     expect(child.killedWith).toEqual(["SIGTERM", "SIGKILL"]);
   });
 
+  it("reapForSession terminates only the matching session's live subprocesses", () => {
+    vi.useFakeTimers();
+    const logger = createLogger();
+    const matchingChild = createProcess(2469);
+    const otherChild = createProcess(2470);
+    const reaper = createClaudeSubprocessReaper({
+      logger,
+      killGraceMs: 25,
+    });
+    reaper.register(matchingChild, {
+      sessionId: "chat-matching",
+      laneId: "lane-1",
+      cwd: "/tmp/lane-1",
+    }, "claude", []);
+    reaper.register(otherChild, {
+      sessionId: "chat-other",
+      laneId: "lane-2",
+      cwd: "/tmp/lane-2",
+    }, "claude", []);
+
+    reaper.reapForSession("chat-matching", "ended_session");
+
+    expect(matchingChild.killedWith).toEqual(["SIGTERM"]);
+    expect(otherChild.killedWith).toEqual([]);
+    expect(reaper.liveRecords().map((record) => record.sessionId)).toEqual([
+      "chat-matching",
+      "chat-other",
+    ]);
+
+    vi.advanceTimersByTime(25);
+
+    expect(matchingChild.killedWith).toEqual(["SIGTERM", "SIGKILL"]);
+    expect(otherChild.killedWith).toEqual([]);
+  });
+
   it("reaps subprocesses left behind by a crashed ADE owner", () => {
     vi.useFakeTimers();
     const logger = createLogger();
diff --git a/apps/desktop/src/main/services/chat/claudeSubprocessReaper.ts b/apps/desktop/src/main/services/chat/claudeSubprocessReaper.ts
index 9dcb5c0bc..55630b234 100644
--- a/apps/desktop/src/main/services/chat/claudeSubprocessReaper.ts
+++ b/apps/desktop/src/main/services/chat/claudeSubprocessReaper.ts
@@ -22,6 +22,11 @@ export type ClaudeSubprocessRecord = ClaudeSubprocessMetadata & {
 };
 
 type ClaudeChildProcess = ChildProcessByStdio<Writable, Readable, null>;
+type LiveClaudeSubprocess = {
+  record: ClaudeSubprocessRecord;
+  process: SpawnedProcess;
+  killTimer: ReturnType<typeof setTimeout> | null;
+};
 
 export type ClaudeSubprocessReaper = ReturnType<typeof createClaudeSubprocessReaper>;
 
@@ -43,7 +48,7 @@ export function createClaudeSubprocessReaper(args: {
     ? null
     : args.registryPath ?? path.join(os.tmpdir(), "ade-claude-subprocesses.json");
   const processKill = args.processKill ?? ((pid: number, signal?: NodeJS.Signals | 0) => process.kill(pid, signal as NodeJS.Signals | undefined));
-  const live = new Map<number, { record: ClaudeSubprocessRecord; process: SpawnedProcess; killTimer: ReturnType<typeof setTimeout> | null }>();
+  const live = new Map<number, LiveClaudeSubprocess>();
 
   const readRegistry = (): ClaudeSubprocessRecord[] => {
     if (!registryPath || !fs.existsSync(registryPath)) return [];
@@ -226,43 +231,58 @@ export function createClaudeSubprocessReaper(args: {
     return child;
   };
 
-  const reapAll = (reason: string): void => {
-    for (const [pid, entry] of live) {
-      const child = entry.process;
+  const terminateLiveEntry = (
+    pid: number,
+    entry: LiveClaudeSubprocess,
+    reason: string,
+  ): void => {
+    const child = entry.process;
+    if (child.killed || child.exitCode !== null || entry.killTimer) return;
+    logger.warn("agent_chat.claude_subprocess_terminate", {
+      pid,
+      sessionId: entry.record.sessionId,
+      reason,
+    });
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      // Best effort; the process may already be gone.
+    }
+    entry.killTimer = setTimer(() => {
       if (!child.killed && child.exitCode === null) {
-        logger.warn("agent_chat.claude_subprocess_terminate", {
+        logger.warn("agent_chat.claude_subprocess_kill", {
           pid,
           sessionId: entry.record.sessionId,
           reason,
         });
         try {
-          child.kill("SIGTERM");
+          child.kill("SIGKILL");
         } catch {
           // Best effort; the process may already be gone.
         }
-        entry.killTimer = setTimer(() => {
-          if (!child.killed && child.exitCode === null) {
-            logger.warn("agent_chat.claude_subprocess_kill", {
-              pid,
-              sessionId: entry.record.sessionId,
-              reason,
-            });
-            try {
-              child.kill("SIGKILL");
-            } catch {
-              // Best effort; the process may already be gone.
-            }
-          }
-          removeRegistryPid(pid);
-        }, killGraceMs);
-        entry.killTimer.unref?.();
       }
+      removeRegistryPid(pid);
+    }, killGraceMs);
+    entry.killTimer.unref?.();
+  };
+
+  const reapForSession = (sessionId: string, reason: string): void => {
+    for (const [pid, entry] of live) {
+      if (entry.record.sessionId !== sessionId) continue;
+      terminateLiveEntry(pid, entry, reason);
+    }
+  };
+
+  const reapAll = (reason: string): void => {
+    for (const [pid, entry] of live) {
+      terminateLiveEntry(pid, entry, reason);
     }
   };
 
   return {
     register,
     spawnClaudeCodeProcess,
+    reapForSession,
     reapAll,
     reapStaleRegistry,
     liveRecords: (): ClaudeSubprocessRecord[] => [...live.values()].map((entry) => ({ ...entry.record })),
diff --git a/docs/features/chat/README.md b/docs/features/chat/README.md
index f96d1f9b9..2c30c41e3 100644
--- a/docs/features/chat/README.md
+++ b/docs/features/chat/README.md
@@ -134,8 +134,17 @@ host was asleep or the runtime was down, an overdue one-shot fires once with
 then computes its next ordinary cron occurrence from the current time; ADE
 does not replay every missed interval. Paused schedules remain armed. Work
 that became overdue while either the chat or global pause was active follows
-the same one-late-fire rule after resume. Archiving or deleting the owning
-chat cancels its schedules.
+the same one-late-fire rule after resume.
+
+Session teardown distinguishes deliberate end from runtime lifecycle. Deleting,
+archiving, or explicitly disposing a chat, and archiving or deleting its lane,
+cancels every durable schedule owned by that chat. Project close and graceful
+app quit instead end live chat rows as `detached`; their schedules remain armed
+so restart reconciliation can late-fire overdue work and cold-resume the chat.
+The scheduler's `sessionState` contract treats `running` and `detached` rows as
+`active`, any other non-archived terminal row as `ended`, archived rows as
+`archived`, and absent rows as `missing`. Ended, archived, and missing owners
+are cancelled during reconciliation or before delivery.
 
 Delivery reuses the session peer-message path with `kind: "wake"`. A live,
 idle Claude query is resumed through its existing idle reader; otherwise the
@@ -516,7 +525,13 @@ happen to begin with `User request:`.
 5. On completion the service emits `status: "completed" | "failed" |
    "interrupted"`, optionally emits a `turn_diff_summary`, flushes
    buffered text, and pulls the next queued steer.
-6. `dispose({ sessionId })` ends the runtime and persists the final state.
+6. `dispose({ sessionId })` deliberately ends the runtime, persists the final
+   state as `disposed`, and cancels the chat's durable scheduled work. Project
+   close and graceful app quit use the lifecycle variant: live rows become
+   `detached`, provider runtimes are torn down, and durable schedules remain for
+   restart reconciliation and cold resume. Lane archive/delete additionally
+   cancels schedules for every session owned by that lane, including sessions
+   that were not rehydrated into the current runtime.
 
 Parallel launch is a renderer-orchestrated workflow layered on the same
 session primitives:

From 70047568099f0d7f55c0908cfb338abd48e2bfe9 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Fri, 10 Jul 2026 03:37:13 -0400
Subject: [PATCH 2/9] docs(chat): note the sync-saveState ordering assumption
 in finishSession schedule cancel

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 apps/desktop/src/main/services/chat/agentChatService.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index 5bab70be6..f654003a6 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -12244,6 +12244,12 @@ export function createAgentChatService(args: {
     if (status === "disposed") {
       await scheduledWorkReady;
       if (scheduledWorkScheduler) {
+        // This cancel snapshot runs while the session row still reads "running",
+        // so a racing in-flight-turn upsert could slip past it. That is safe only
+        // because saveState is synchronous (better-sqlite3): the awaits resolve on
+        // microtasks, sessionService.end below runs before any timer fires, and
+        // the leaked schedule cancels at fire time via sessionState === "ended".
+        // If saveState ever becomes async I/O, mark the row terminal first.
         await Promise.all(
           scheduledWorkScheduler.list(managed.session.id).map((schedule) =>
             scheduledWorkScheduler!.cancel(schedule.id)),

From 3f57c6fff9fc4910ac244ab8947463b76ddb467f Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Fri, 10 Jul 2026 04:18:13 -0400
Subject: [PATCH 3/9] feat(chat): scale the actions pane to 60+ subagents;
 copy-whole-turn

Shared stable partition (groupPaneSectionItems) + caps + Earlier/Show-all/
Clear-Restore semantics in shared/chatSubagents.ts and chatScheduledWork.ts,
consumed by all three surfaces. Desktop pane owns a single scroller with
sticky section headers, collapsible-when-worthy headers, per-session
localStorage view/clear state, and generalizes the Schedule History fold
into one Earlier idiom. ADE Code TUI renders the grouped row model with
tagged mouse targets and keyboard controls; iOS mirrors the predicates,
caps, fired/late decoding, and persisted disclosure state in the Chat Info
sheet. Small sections render exactly as before (no new chrome).

Also: one-click "Copy turn" on the last text block of multi-block assistant
turns, keyed off turnId.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../tuiClient/__tests__/RightPane.test.tsx    |  48 +-
 .../tuiClient/__tests__/subagentPane.test.ts  |  51 +-
 apps/ade-cli/src/tuiClient/app.tsx            | 122 +++-
 .../src/tuiClient/components/RightPane.tsx    | 222 +++---
 apps/ade-cli/src/tuiClient/subagentPane.ts    |   6 +
 .../chat/AgentChatMessageList.test.tsx        |  57 ++
 .../components/chat/AgentChatMessageList.tsx  |  59 +-
 .../components/chat/AgentChatPane.tsx         |   4 +-
 .../chat/ChatSubagentsPanel.test.tsx          |  94 ++-
 .../components/chat/ChatSubagentsPanel.tsx    | 690 +++++++++++++++---
 .../src/shared/chatScheduledWork.test.ts      |  11 +
 apps/desktop/src/shared/chatScheduledWork.ts  |  13 +
 apps/desktop/src/shared/chatSubagents.test.ts |  69 ++
 apps/desktop/src/shared/chatSubagents.ts      | 324 ++++++--
 apps/ios/ADE/Models/RemoteModels.swift        |   6 +-
 .../Views/Work/WorkChatRichCardViews.swift    | 369 +++++++++-
 .../Work/WorkErrorAndMessageHelpers.swift     |   4 +-
 .../ios/ADE/Views/Work/WorkEventMapping.swift |   4 +-
 apps/ios/ADE/Views/Work/WorkModels.swift      |   4 +-
 .../Work/WorkSessionDestinationView.swift     |   1 +
 .../ADE/Views/Work/WorkTimelineHelpers.swift  |  35 +-
 .../ADE/Views/Work/WorkTranscriptParser.swift |   2 +
 apps/ios/ADETests/ADETests.swift              |  36 +-
 docs/features/chat/README.md                  |   6 +-
 docs/features/chat/composer-and-ui.md         |  19 +-
 25 files changed, 1958 insertions(+), 298 deletions(-)

diff --git a/apps/ade-cli/src/tuiClient/__tests__/RightPane.test.tsx b/apps/ade-cli/src/tuiClient/__tests__/RightPane.test.tsx
index 8002767f7..ce0f4d6b6 100644
--- a/apps/ade-cli/src/tuiClient/__tests__/RightPane.test.tsx
+++ b/apps/ade-cli/src/tuiClient/__tests__/RightPane.test.tsx
@@ -191,6 +191,45 @@ describe("RightPane chat info", () => {
     expect(frame).toContain("agent-07");
   });
 
+  it("windows grouped roster rows while keeping Show all and Earlier affordances reachable", () => {
+    const snapshots: ChatInfoSnapshot["snapshots"] = [
+      ...Array.from({ length: 13 }, (_, index) => ({
+        id: `run-${index}`,
+        name: `running-${index}`,
+        kind: "subagent" as const,
+        status: "running" as const,
+        summary: "working",
+      })),
+      { id: "done-1", name: "completed-agent", kind: "subagent", status: "completed", summary: "done" },
+    ];
+    const collapsed = render(
+      <RightPane
+        content={{ kind: "chat-info", info: chatInfo({ snapshots }) }}
+        subagentPaneViewState={{}}
+        selectedIndex={12}
+        focused
+        width={80}
+      />,
+    );
+    const collapsedFrame = stripAnsi(collapsed.lastFrame() ?? "");
+
+    expect(collapsedFrame).toContain("+ show all (1)");
+    expect(collapsedFrame).toContain("▸ earlier (1)");
+    expect(collapsedFrame).toMatch(/↑\s+\d+\s+earlier/);
+    expect(collapsedFrame).not.toContain("completed-agent");
+
+    const expanded = render(
+      <RightPane
+        content={{ kind: "chat-info", info: chatInfo({ snapshots }) }}
+        subagentPaneViewState={{ showAll: { subagents: true }, earlierExpanded: { subagents: true } }}
+        selectedIndex={14}
+        focused
+        width={80}
+      />,
+    );
+    expect(stripAnsi(expanded.lastFrame() ?? "")).toContain("completed-agent");
+  });
+
   it("separates foreground subagents from background tasks with section headers", () => {
     const result = render(
       <RightPane
@@ -327,7 +366,7 @@ describe("RightPane chat info", () => {
   });
 
   it("caps scheduled work rows in narrow chat info panes", () => {
-    const scheduledWork: ChatInfoSnapshot["scheduledWork"] = Array.from({ length: 7 }, (_, index) => {
+    const scheduledWork: ChatInfoSnapshot["scheduledWork"] = Array.from({ length: 12 }, (_, index) => {
       const ordinal = String(index + 1).padStart(2, "0");
       return {
         id: `wake-${ordinal}`,
@@ -355,9 +394,9 @@ describe("RightPane chat info", () => {
 
     expect(frame).toContain("SCHEDULE");
     expect(frame).toContain("Wakeup 01");
-    expect(frame).toContain("Wakeup 05");
-    expect(frame).not.toContain("Wakeup 06");
-    expect(frame).toContain("↓ 2 more");
+    expect(frame).toContain("Wakeup 10");
+    expect(frame).not.toContain("Wakeup 11");
+    expect(frame).toContain("+ show all (2)");
     expect(longestLine).toBeLessThanOrEqual(44);
   });
 
@@ -391,6 +430,7 @@ describe("RightPane chat info", () => {
             ],
           }),
         }}
+        subagentPaneViewState={{ earlierExpanded: { schedule: true } }}
         focused
         width={80}
       />,
diff --git a/apps/ade-cli/src/tuiClient/__tests__/subagentPane.test.ts b/apps/ade-cli/src/tuiClient/__tests__/subagentPane.test.ts
index 9c66c681f..b01bca958 100644
--- a/apps/ade-cli/src/tuiClient/__tests__/subagentPane.test.ts
+++ b/apps/ade-cli/src/tuiClient/__tests__/subagentPane.test.ts
@@ -3,6 +3,7 @@ import {
   buildSubagentPaneRows,
   buildSubagentTranscriptEvents,
   selectedSubagentSnapshot,
+  SUBAGENT_PANE_ROSTER_CAPACITY,
   subagentIndexForPaneLine,
   subagentPaneSelectableLineOffsets,
   subagentTranscriptMessagesToEvents,
@@ -12,6 +13,7 @@ import { resolveSubagentCapability } from "../../../../desktop/src/shared/subage
 import { renderChatLines } from "../format";
 import type { AgentChatEventEnvelope, AgentChatSessionSummary } from "../../../../desktop/src/shared/types/chat";
 import type { RightPaneContent } from "../types";
+import type { SubagentSnapshot } from "../types";
 
 const session: AgentChatSessionSummary = {
   sessionId: "s1",
@@ -82,17 +84,54 @@ describe("subagent pane helpers", () => {
     const offsets = subagentPaneSelectableLineOffsets(content, 1);
 
     expect(offsets.length).toBe(5);
-    expect(subagentIndexForPaneLine(content, offsets[0]!, 1)).toBe(0);
-    expect(subagentIndexForPaneLine(content, offsets[1]!, 1)).toBe(1);
-    expect(subagentIndexForPaneLine(content, offsets[3]!, 1)).toBe(3);
-    expect(subagentIndexForPaneLine(content, offsets[4]! + 1, 1)).toBe(4);
+    expect(subagentIndexForPaneLine(content, offsets[0]!, 1)).toEqual({ type: "snapshot", index: 0 });
+    expect(subagentIndexForPaneLine(content, offsets[1]!, 1)).toEqual({ type: "snapshot", index: 1 });
+    expect(subagentIndexForPaneLine(content, offsets[3]!, 1)).toEqual({ type: "snapshot", index: 3 });
+    expect(subagentIndexForPaneLine(content, offsets[4]!, 1)).toEqual({ type: "snapshot", index: 4 });
     expect(subagentIndexForPaneLine(content, offsets[0]! - 2, 1)).toBeNull();
   });
 
   it("only accounts for detail lines on the selected subagent row", () => {
     const content = rosterPaneContent();
-    expect(subagentPaneSelectableLineOffsets(content, 1)).toEqual([4, 8, 10, 13, 16]);
-    expect(subagentPaneSelectableLineOffsets(content, 2)).toEqual([4, 8, 9, 13, 16]);
+    expect(subagentPaneSelectableLineOffsets(content, 1)).toEqual([0, 2, 4, 5, 6]);
+    expect(subagentPaneSelectableLineOffsets(content, 2)).toEqual([0, 2, 3, 5, 6]);
+  });
+
+  it("emits grouped section, show-all, Earlier, and tagged action rows", () => {
+    const snapshots: SubagentSnapshot[] = Array.from({ length: 13 }, (_, index) => ({
+      id: `run-${index}`,
+      name: `run ${index}`,
+      kind: "subagent" as const,
+      status: "running" as const,
+      summary: "working",
+    }));
+    snapshots.push({ id: "done", name: "done", kind: "subagent", status: "completed", summary: "done" });
+    const content = { snapshots };
+    const rows = buildSubagentPaneRows(content, {});
+
+    expect(rows.find((row) => row.kind === "section-header")).toMatchObject({
+      section: "subagents",
+      activeCount: 13,
+      earlierCount: 1,
+      collapsible: true,
+    });
+    expect(rows.find((row) => row.kind === "show-all")).toMatchObject({ hiddenCount: 1 });
+    expect(rows.find((row) => row.kind === "earlier-toggle")).toMatchObject({ count: 1, expanded: false });
+
+    const actionTargets = Array.from({ length: 40 }, (_, line) => subagentIndexForPaneLine(content, line, 0, {}))
+      .filter((target) => target && target.type !== "snapshot");
+    expect(actionTargets).toContainEqual({ type: "show-all", section: "subagents" });
+    expect(actionTargets).toContainEqual({ type: "toggle-earlier", section: "subagents" });
+
+    const windowedTargets = Array.from({ length: 20 }, (_, line) => subagentIndexForPaneLine(
+      content,
+      line,
+      12,
+      {},
+      SUBAGENT_PANE_ROSTER_CAPACITY,
+    )).filter((target) => target && target.type !== "snapshot");
+    expect(windowedTargets).toContainEqual({ type: "show-all", section: "subagents" });
+    expect(windowedTargets).toContainEqual({ type: "toggle-earlier", section: "subagents" });
   });
 
   it("builds a focused transcript without unrelated subagent output", () => {
diff --git a/apps/ade-cli/src/tuiClient/app.tsx b/apps/ade-cli/src/tuiClient/app.tsx
index 61b1966a4..7f266eff9 100644
--- a/apps/ade-cli/src/tuiClient/app.tsx
+++ b/apps/ade-cli/src/tuiClient/app.tsx
@@ -309,10 +309,14 @@ import { copyToClipboard } from "../lib/clipboard";
 import {
   buildSubagentPaneRows,
   buildSubagentTranscriptEvents,
+  SUBAGENT_PANE_ROSTER_CAPACITY,
   subagentIndexForPaneLine,
   subagentPaneContentFromRightPane,
   subagentTranscriptMessagesToEvents,
+  type SubagentPaneDisclosureSection,
   type SubagentPaneRow,
+  type SubagentPaneTarget,
+  type SubagentPaneViewState,
 } from "./subagentPane";
 import { readClaudeStatusLineConfig, runClaudeStatusLineCommand } from "./statusline";
 import {
@@ -2893,6 +2897,46 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
   const [formValues, setFormValues] = useState<Record<string, string>>({});
   const [formFieldIndex, setFormFieldIndex] = useState(0);
   const [rightSelectionIndex, setRightSelectionIndex] = useState(0);
+  const [subagentPaneViewStateBySessionId, setSubagentPaneViewStateBySessionId] = useState<Record<string, SubagentPaneViewState>>({});
+  const subagentPaneViewState = activeSessionId ? (subagentPaneViewStateBySessionId[activeSessionId] ?? {}) : {};
+  const updateSubagentPaneViewState = useCallback((update: (current: SubagentPaneViewState) => SubagentPaneViewState) => {
+    if (!activeSessionId) return;
+    setSubagentPaneViewStateBySessionId((current) => ({
+      ...current,
+      [activeSessionId]: update(current[activeSessionId] ?? {}),
+    }));
+  }, [activeSessionId]);
+  const activateSubagentPaneTarget = useCallback((target: SubagentPaneTarget, resumeOffset: number) => {
+    if (target.type === "snapshot") {
+      setRightSelectionIndex(target.index + resumeOffset);
+      return;
+    }
+    if (target.type === "toggle-section") {
+      updateSubagentPaneViewState((current) => ({
+        ...current,
+        collapsed: { ...current.collapsed, [target.section]: current.collapsed?.[target.section] !== true },
+      }));
+      return;
+    }
+    if (target.type === "toggle-earlier") {
+      updateSubagentPaneViewState((current) => ({
+        ...current,
+        earlierExpanded: { ...current.earlierExpanded, [target.section]: current.earlierExpanded?.[target.section] !== true },
+      }));
+      return;
+    }
+    if (target.type === "show-all") {
+      updateSubagentPaneViewState((current) => ({
+        ...current,
+        showAll: { ...current.showAll, [target.section]: true },
+      }));
+      return;
+    }
+    updateSubagentPaneViewState((current) => ({
+      ...current,
+      cleared: { ...current.cleared, [target.section]: [] },
+    }));
+  }, [updateSubagentPaneViewState]);
   const [rightChatsClosedExpanded, setRightChatsClosedExpanded] = useState(false);
   const [drawerOpen, setDrawerOpen] = useState(false);
   const [rightOpen, setRightOpen] = useState(false);
@@ -3917,9 +3961,9 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
     // visible (0 = resume, 1 = main, …). Clamp prior selection back into range
     // when the roster shrinks (e.g., a subagent finishes and is reaped).
     const resumeOffset = rightPane.kind === "chat-info" ? chatInfoSelectionOffset(rightPane.info) : 0;
-    const rowCount = buildSubagentPaneRows(content).filter((row) => row.kind === "snapshot").length + resumeOffset;
+    const rowCount = buildSubagentPaneRows(content, subagentPaneViewState).filter((row) => row.kind === "snapshot").length + resumeOffset;
     setRightSelectionIndex((index) => Math.max(0, Math.min(Number.isFinite(index) ? Math.floor(index) : 0, rowCount)));
-  }, [rightPane]);
+  }, [rightPane, subagentPaneViewState]);
   useEffect(() => {
     if (!inspectedSubagentId) return;
     if (rightPane.kind !== "chat-info" || !rightOpen || !subagentSnapshots.some((snap) => snap.id === inspectedSubagentId)) {
@@ -12157,10 +12201,10 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
             const resumeOffset = chatInfoSelectionOffset(rightPane.info);
             const subagentPaneTop = 4 + goalBannerRows + addModeRows + (resumeOffset ? CHAT_INFO_RESUME_ROW_LINES : 0);
             const subagentContent = subagentPaneContentFromRightPane(rightPane);
-            const nextIndex = subagentContent
-              ? subagentIndexForPaneLine(subagentContent, mouse.y - subagentPaneTop, rightSelectionIndex - resumeOffset)
+            const target = subagentContent
+              ? subagentIndexForPaneLine(subagentContent, mouse.y - subagentPaneTop, rightSelectionIndex - resumeOffset, subagentPaneViewState, SUBAGENT_PANE_ROSTER_CAPACITY)
               : null;
-            if (nextIndex != null) setRightSelectionIndex(nextIndex + resumeOffset);
+            if (target) activateSubagentPaneTarget(target, resumeOffset);
           }
           return;
         }
@@ -12292,12 +12336,10 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
           const resumeOffset = chatInfoSelectionOffset(rightPane.info);
           const subagentPaneTop = 4 + goalBannerRows + addModeRows + (resumeOffset ? CHAT_INFO_RESUME_ROW_LINES : 0);
           const subagentContent = subagentPaneContentFromRightPane(rightPane);
-          const nextIndex = subagentContent
-            ? subagentIndexForPaneLine(subagentContent, mouse.y - subagentPaneTop, rightSelectionIndex - resumeOffset)
+          const target = subagentContent
+            ? subagentIndexForPaneLine(subagentContent, mouse.y - subagentPaneTop, rightSelectionIndex - resumeOffset, subagentPaneViewState, SUBAGENT_PANE_ROSTER_CAPACITY)
             : null;
-          if (nextIndex != null) {
-            setRightSelectionIndex(nextIndex + resumeOffset);
-          }
+          if (target) activateSubagentPaneTarget(target, resumeOffset);
           setRightOpen(true);
           setPaneFocus("details");
         }
@@ -13486,15 +13528,19 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
     }
 
     const killWorkerKey = key.ctrl && !key.meta && input.toLowerCase() === "k";
+    const chatInfoDisclosureKey = !key.ctrl && !key.meta && !key.shift
+      ? input.toLowerCase()
+      : "";
     if (
       pane === "details"
       && rightOpen
       && rightPane.kind === "chat-info"
-      && (key.upArrow || key.downArrow || key.return || killWorkerKey)
+      && (key.upArrow || key.downArrow || key.return || killWorkerKey || ["c", "e", "a", "x"].includes(chatInfoDisclosureKey))
     ) {
       const subagentContent = subagentPaneContentFromRightPane(rightPane);
       if (!subagentContent) return;
-      const snapshotRows = buildSubagentPaneRows(subagentContent)
+      const paneRows = buildSubagentPaneRows(subagentContent, subagentPaneViewState);
+      const snapshotRows = paneRows
         .filter((row): row is Extract<SubagentPaneRow, { kind: "snapshot" }> => row.kind === "snapshot");
       // Selection: 0 = main row; 1..N = subagent rows — shifted down by one
       // when the resume row is visible (0 = resume, 1 = main, …).
@@ -13503,6 +13549,48 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
       const resumeRowSelected = resumeOffset === 1 && rightSelectionIndex === 0;
       const selectedRow = rightSelectionIndex > resumeOffset ? snapshotRows[rightSelectionIndex - 1 - resumeOffset] : null;
       const selectedSnapshot: SubagentSnapshot | null = selectedRow ? selectedRow.snapshot : null;
+      const focusedSection: SubagentPaneDisclosureSection = selectedRow?.section
+        ?? (paneRows.find((row): row is Extract<SubagentPaneRow, { kind: "section-header" }> => row.kind === "section-header")?.section ?? "subagents");
+      const focusedHeader = paneRows.find((row): row is Extract<SubagentPaneRow, { kind: "section-header" }> => (
+        row.kind === "section-header" && row.section === focusedSection
+      ));
+      if (chatInfoDisclosureKey === "c") {
+        if (focusedHeader?.collapsible) {
+          activateSubagentPaneTarget({ type: "toggle-section", section: focusedSection }, resumeOffset);
+          if (!focusedHeader.collapsed) setRightSelectionIndex(resumeOffset);
+        }
+        return;
+      }
+      if (chatInfoDisclosureKey === "e") {
+        if (focusedHeader && (focusedHeader.earlierCount > 0 || focusedHeader.clearedCount > 0)) {
+          activateSubagentPaneTarget({ type: "toggle-earlier", section: focusedSection }, resumeOffset);
+        }
+        return;
+      }
+      if (chatInfoDisclosureKey === "a") {
+        if (paneRows.some((row) => row.kind === "show-all" && row.section === focusedSection)) {
+          activateSubagentPaneTarget({ type: "show-all", section: focusedSection }, resumeOffset);
+        }
+        return;
+      }
+      if (chatInfoDisclosureKey === "x") {
+        const clearIds = paneRows
+          .filter((row): row is Extract<SubagentPaneRow, { kind: "snapshot" }> => (
+            row.kind === "snapshot" && row.section === focusedSection && row.group === "earlier"
+          ))
+          .map((row) => row.snapshot.id);
+        if (clearIds.length) {
+          updateSubagentPaneViewState((current) => ({
+            ...current,
+            cleared: {
+              ...current.cleared,
+              [focusedSection]: [...new Set([...(current.cleared?.[focusedSection] ?? []), ...clearIds])],
+            },
+          }));
+          setRightSelectionIndex(resumeOffset);
+        }
+        return;
+      }
       // ^k — stop the selected Droid AGI worker. The Droid worker subagent id IS
       // its workerSessionId (see droidSdkEventMapper.mission_worker_started).
       if (killWorkerKey) {
@@ -14949,13 +15037,14 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
         }
         if (subagentContent) {
           for (let y = rightBodyTop; y <= Math.max(rightBodyTop, rows - 2); y += 1) {
-            const index = subagentIndexForPaneLine(subagentContent, y - subagentPaneTop, rightSelectionIndex - resumeOffset);
-            if (index == null) continue;
+            const target = subagentIndexForPaneLine(subagentContent, y - subagentPaneTop, rightSelectionIndex - resumeOffset, subagentPaneViewState, SUBAGENT_PANE_ROSTER_CAPACITY);
+            if (!target) continue;
+            const targetKey = target.type === "snapshot" ? `${target.type}:${target.index}` : `${target.type}:${target.section}`;
             addTarget({
-              id: `right:chat-info:${index + resumeOffset}:${y}`,
+              id: `right:chat-info:${targetKey}:${y}`,
               rect: { x: rightStartColumn, y, w: rightPaneWidth, h: 1 },
               onClick: () => {
-                setRightSelectionIndex(index + resumeOffset);
+                activateSubagentPaneTarget(target, resumeOffset);
                 setRightOpen(true);
                 setPaneFocus("details");
               },
@@ -15504,6 +15593,7 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
 	              activeProvider={activeCommandProvider as AdeCodeProvider}
 	              width={rightPaneWidth}
               scrollOffsetRows={rightPaneScrollOffsetRows}
+              subagentPaneViewState={subagentPaneViewState}
               modelPickerInputs={rightPaneModelPickerInputs}
               onModelPickerMeasureOrigin={handlePickerMeasureOrigin}
             />
diff --git a/apps/ade-cli/src/tuiClient/components/RightPane.tsx b/apps/ade-cli/src/tuiClient/components/RightPane.tsx
index 6da0e76e2..1ab4d36ee 100644
--- a/apps/ade-cli/src/tuiClient/components/RightPane.tsx
+++ b/apps/ade-cli/src/tuiClient/components/RightPane.tsx
@@ -20,10 +20,24 @@ import {
 } from "../externalSessionBrowser";
 import { formatRelativePastTime } from "../relativeTime";
 import {
+  isEarlierBackgroundItem,
+  isEarlierScheduleItem,
   backgroundCommandLabel,
   compactRelativeDuration,
 } from "../../../../desktop/src/shared/chatScheduledWork";
-import { buildSubagentPaneRows, type SubagentPaneRow } from "../subagentPane";
+import {
+  BACKGROUND_ACTIVE_CAP,
+  SCHEDULE_ACTIVE_CAP,
+  capPaneSectionItems,
+  groupPaneSectionItems,
+} from "../../../../desktop/src/shared/chatSubagents";
+import {
+  buildSubagentPaneRows,
+  SUBAGENT_PANE_ROSTER_CAPACITY,
+  type SubagentPaneRow,
+  type SubagentPaneViewState,
+  windowSubagentPaneRows,
+} from "../subagentPane";
 import { ModelPickerPane } from "./ModelPicker/ModelPickerPane";
 import { buildModelPickerLayout } from "./ModelPicker/modelPickerLayout";
 import { TokenBar } from "./FooterControls";
@@ -794,36 +808,29 @@ export function ChatInfoResumeRow({ selected }: { selected: boolean }) {
   );
 }
 
-function rosterWindow(rowCount: number, selected: number, capacity: number): { start: number; end: number } {
-  if (rowCount <= capacity) return { start: 0, end: rowCount };
-  const half = Math.floor(capacity / 2);
-  let start = Math.max(0, selected - half);
-  let end = start + capacity;
-  if (end > rowCount) {
-    end = rowCount;
-    start = end - capacity;
-  }
-  return { start, end };
-}
-
 function ChatInfoRoster({
   info,
   selectedIndex,
   brandColor,
   width,
+  viewState,
 }: {
   info: ChatInfoSnapshot;
   selectedIndex: number;
   brandColor: string;
   width: number;
+  viewState: SubagentPaneViewState;
 }) {
   const inner = Math.max(10, width - 4);
-  const snapshotRows = buildSubagentPaneRows(info)
+  const paneRows = buildSubagentPaneRows(info, viewState);
+  const snapshotRows = paneRows
     .filter((row): row is Extract<SubagentPaneRow, { kind: "snapshot" }> => row.kind === "snapshot");
-  const runCount = snapshotRows.filter((row) => row.snapshot.status === "running").length;
-  const doneCount = snapshotRows.filter((row) => row.snapshot.status === "completed").length;
-  const failedCount = snapshotRows.filter((row) => row.snapshot.status === "failed").length;
-  const bgCount = snapshotRows.filter((row) => row.section === "background").length;
+  const clearedIds = new Set(Object.values(viewState.cleared ?? {}).flatMap((ids) => [...(ids ?? [])]));
+  const countedSnapshots = info.snapshots.filter((snapshot) => !clearedIds.has(snapshot.id));
+  const runCount = countedSnapshots.filter((snapshot) => snapshot.status === "running").length;
+  const doneCount = countedSnapshots.filter((snapshot) => snapshot.status === "completed").length;
+  const failedCount = countedSnapshots.filter((snapshot) => snapshot.status === "failed").length;
+  const bgCount = countedSnapshots.filter((snapshot) => snapshot.background === true).length;
   // Selection convention: 0 = main row; 1..N = subagent rows (1-indexed).
   // A negative index means the selection sits ABOVE the roster (the resume
   // row) — nothing in the roster highlights.
@@ -840,13 +847,22 @@ function ChatInfoRoster({
         bgCount ? `${bgCount} bg` : null,
       ].filter((value): value is string => value !== null).join(" · ");
 
-  const ROSTER_CAPACITY = 5;
   const subagentSelectedIndex = mainSelected ? -1 : selected - 1;
   const selectedSnapshot = !mainSelected ? (snapshotRows[subagentSelectedIndex]?.snapshot ?? null) : null;
-  const window = rosterWindow(snapshotRows.length, Math.max(0, subagentSelectedIndex), ROSTER_CAPACITY);
-  const visibleSlice = snapshotRows.slice(window.start, window.end);
-  const hiddenBefore = window.start;
-  const hiddenAfter = snapshotRows.length - window.end;
+  const selectedSection = !mainSelected ? snapshotRows[subagentSelectedIndex]?.section ?? null : null;
+  const selectedHeader = selectedSection
+    ? paneRows.find((row): row is Extract<SubagentPaneRow, { kind: "section-header" }> => row.kind === "section-header" && row.section === selectedSection)
+    : null;
+  const disclosureHints = selectedHeader ? [
+    ...(selectedHeader.collapsible ? ["c section"] : []),
+    ...(selectedHeader.earlierCount > 0 || selectedHeader.clearedCount > 0 ? ["e earlier"] : []),
+    ...(paneRows.some((row) => row.kind === "show-all" && row.section === selectedSection) ? ["a all"] : []),
+  ] : [];
+  const { visibleRows: visibleSlice, hiddenBefore, hiddenAfter } = windowSubagentPaneRows(
+    paneRows,
+    selected,
+    SUBAGENT_PANE_ROSTER_CAPACITY,
+  );
 
   return (
     <Box flexDirection="column">
@@ -861,19 +877,31 @@ function ChatInfoRoster({
         </Box>
         <Text color={theme.color.t4} dimColor>{showingMain ? "viewing" : "return ↵"}</Text>
       </Box>
-      {snapshotRows.length === 0 ? (
+      {info.snapshots.length === 0 ? (
         <Text color={theme.color.t4} dimColor>{" "}no subagents yet</Text>
       ) : (
         <>
           {hiddenBefore > 0 ? (
             <Text color={theme.color.t4} dimColor>{`  ↑ ${hiddenBefore} earlier`}</Text>
           ) : null}
-          {visibleSlice.map((row, sliceIndex) => {
-            const rosterIndex = window.start + sliceIndex;
-            const previousSection = rosterIndex === 0
-              ? "main"
-              : snapshotRows[rosterIndex - 1]?.section;
-            const showSection = row.section !== previousSection;
+          {visibleSlice.map((row) => {
+            if (row.kind === "section-header") {
+              return <RosterSectionHead key={row.key} row={row} />;
+            }
+            if (row.kind === "earlier-toggle") {
+              return (
+                <Text key={row.key} color={theme.color.t4} dimColor>
+                  {`  ${row.expanded ? "▾" : "▸"} earlier (${row.count})${row.clearedCount ? ` · ${row.clearedCount} hidden` : ""}`}
+                </Text>
+              );
+            }
+            if (row.kind === "show-all") {
+              return <Text key={row.key} color={theme.color.t4} dimColor>{`  + show all (${row.hiddenCount})`}</Text>;
+            }
+            if (row.kind === "restore-cleared") {
+              return <Text key={row.key} color={theme.color.t4} dimColor>{`  restore (${row.count})`}</Text>;
+            }
+            const rosterIndex = snapshotRows.findIndex((candidate) => candidate.key === row.key);
             const isSelected = !mainSelected && subagentSelectedIndex === rosterIndex;
             const kind = subagentAgentKind(row.snapshot.status);
             // Background rows get a cyan glyph tint so the eye can sort them out
@@ -889,7 +917,6 @@ function ChatInfoRoster({
             const detail = isSelected ? selectedRosterDetail(row.snapshot, info.capability) : null;
             return (
               <Box key={row.key} flexDirection="column">
-                {showSection ? <RosterSectionHead section={row.section} /> : null}
                 <Box flexDirection="row">
                   <Text color={isSelected ? theme.color.violet : theme.color.t5}>{isSelected ? theme.rail : " "}</Text>
                   <Text color={statusColor}>{` ${theme.agentStatusGlyph(kind)}`}</Text>
@@ -912,7 +939,7 @@ function ChatInfoRoster({
         </>
       )}
       <Box marginTop={1}>
-        <Text color={theme.color.t4} dimColor>{rosterFooterHint(info, mainSelected, selectedSnapshot)}</Text>
+        <Text color={theme.color.t4} dimColor>{rosterFooterHint(info, mainSelected, selectedSnapshot, disclosureHints)}</Text>
       </Box>
       {info.mission ? <ChatInfoMissionBlock mission={info.mission} width={width} brandColor={brandColor} /> : null}
     </Box>
@@ -927,6 +954,7 @@ function rosterFooterHint(
   info: ChatInfoSnapshot,
   mainSelected: boolean,
   selectedSnapshot: SubagentSnapshot | null,
+  disclosureHints: string[],
 ): string {
   const parts = ["↑↓ focus"];
   if (mainSelected) {
@@ -942,6 +970,7 @@ function rosterFooterHint(
   ) {
     parts.push("^k kill");
   }
+  parts.push(...disclosureHints);
   parts.push("esc → main");
   return parts.join(" · ");
 }
@@ -949,14 +978,16 @@ function rosterFooterHint(
 // Section heading for the roster — matches the 2-line allowance built into
 // `subagentPaneSelectableLineOffsets` (one blank-margin line + one title line)
 // so the mouse-click line-math stays accurate.
-function RosterSectionHead({ section }: { section: SubagentPaneRow["section"] }) {
-  let label = "subagents";
-  if (section === "background") label = "background";
-  else if (section === "teammates") label = "teammates";
-  const color = section === "background" ? theme.color.tool : theme.color.t4;
+function RosterSectionHead({ row }: { row: Extract<SubagentPaneRow, { kind: "section-header" }> }) {
+  const color = row.section === "background" ? theme.color.tool : theme.color.t4;
+  const count = row.earlierCount
+    ? `${row.activeCount} · ${row.earlierCount} earlier`
+    : `${row.activeCount}`;
   return (
     <Box marginTop={1}>
-      <Text color={color} dimColor>{label}</Text>
+      <Text color={color} dimColor>
+        {row.collapsible ? (row.collapsed ? "▸ " : "▾ ") : ""}{row.label.toLowerCase()} {count}{row.clearedCount ? ` · ${row.clearedCount} hidden` : ""}
+      </Text>
     </Box>
   );
 }
@@ -1019,7 +1050,6 @@ function ChatInfoMissionBlock({ mission, width, brandColor }: { mission: Mission
 // Desktop ChatTasksPanel parity: latest todo_update snapshot. Rendered BELOW
 // the roster (like Mission) so the roster's click line-math stays intact.
 const TASKS_VISIBLE_CAP = 6;
-const SCHEDULE_VISIBLE_CAP = 5;
 
 function scheduleStatusColor(status: ChatScheduledWorkSnapshot["status"]): string {
   if (status === "running" || status === "fired") return theme.color.running;
@@ -1058,65 +1088,89 @@ function nextWakeCountdown(value: string | null | undefined, nowMs: number): str
   return compactRelativeDuration(Math.max(60_000, timestampMs - nowMs));
 }
 
-function ChatInfoScheduleBlock({ info, brandColor, width }: { info: ChatInfoSnapshot; brandColor: string; width: number }) {
+function ChatInfoScheduleBlock({ info, brandColor, width, viewState }: { info: ChatInfoSnapshot; brandColor: string; width: number; viewState: SubagentPaneViewState }) {
   const nextWake = nextWakeCountdown(info.nextWakeAt, Date.now());
   if (!info.scheduledWork.length && !nextWake) return null;
   const inner = Math.max(10, width - 4);
-  const visible = info.scheduledWork.slice(0, SCHEDULE_VISIBLE_CAP);
-  const hiddenAfter = info.scheduledWork.length - visible.length;
+  const clearedIds = new Set(viewState.cleared?.schedule ?? []);
+  const grouped = groupPaneSectionItems(info.scheduledWork, {
+    isEarlier: isEarlierScheduleItem,
+    isCleared: (item) => clearedIds.has(item.id),
+    isPinned: () => false,
+  });
+  const capped = viewState.showAll?.schedule
+    ? { visible: grouped.active, hiddenCount: 0 }
+    : capPaneSectionItems(grouped.active, SCHEDULE_ACTIVE_CAP, (item) => item.status === "failed");
+  const earlierExpanded = viewState.earlierExpanded?.schedule === true;
+  const renderItem = (item: ChatScheduledWorkSnapshot, earlier: boolean) => {
+    const detail = scheduleLineDetail(item);
+    const label = `${scheduleKindLabel(item.kind)} · ${item.status}${item.late ? " · late" : ""}`;
+    const titleBudget = Math.max(6, inner - label.length - 4);
+    return (
+      <Box key={item.id} flexDirection="column">
+        <Text color={scheduleStatusColor(item.status)} dimColor={earlier} wrap="truncate-end">
+          {scheduleStatusGlyph(item.status)} {endTruncate(item.title, titleBudget)} <Text color={theme.color.t4}>{label}</Text>
+        </Text>
+        {detail ? (
+          <Text color={theme.color.t4} dimColor wrap="truncate-end">
+            {"  "}{endTruncate(detail, inner - 2)}
+          </Text>
+        ) : null}
+      </Box>
+    );
+  };
   return (
     <Box flexDirection="column">
-      <ChatInfoSectionHead title="SCHEDULE" hint={info.scheduledWork.length ? `${info.scheduledWork.length}` : ""} color={brandColor} width={width} />
+      <ChatInfoSectionHead title="SCHEDULE" hint={grouped.earlier.length ? `${grouped.active.length} · ${grouped.earlier.length} earlier` : `${grouped.active.length}`} color={brandColor} width={width} />
       {nextWake ? (
         <Text color={theme.color.t2} wrap="truncate-end">
           {` ⏰ next wake ${nextWake}`}
         </Text>
       ) : null}
-      {visible.map((item) => {
-        const detail = scheduleLineDetail(item);
-        // Mirror desktop's history row: a fired-behind-schedule wake reads `· late`.
-        const label = `${scheduleKindLabel(item.kind)} · ${item.status}${item.late ? " · late" : ""}`;
-        const titleBudget = Math.max(6, inner - label.length - 4);
-        return (
-          <Box key={item.id} flexDirection="column">
-            <Text color={scheduleStatusColor(item.status)} wrap="truncate-end">
-              {scheduleStatusGlyph(item.status)} {endTruncate(item.title, titleBudget)} <Text color={theme.color.t4}>{label}</Text>
-            </Text>
-            {detail ? (
-              <Text color={theme.color.t4} dimColor wrap="truncate-end">
-                {"  "}{endTruncate(detail, inner - 2)}
-              </Text>
-            ) : null}
-          </Box>
-        );
-      })}
-      {hiddenAfter > 0 ? <Text color={theme.color.t4} dimColor>{`  ↓ ${hiddenAfter} more`}</Text> : null}
+      {capped.visible.map((item) => renderItem(item, false))}
+      {capped.hiddenCount > 0 ? <Text color={theme.color.t4} dimColor>{`  + show all (${capped.hiddenCount})`}</Text> : null}
+      {grouped.earlier.length > 0 || grouped.clearedCount > 0 ? (
+        <Text color={theme.color.t4} dimColor>{`  ${earlierExpanded ? "▾" : "▸"} earlier (${grouped.earlier.length})${grouped.clearedCount ? ` · ${grouped.clearedCount} hidden` : ""}`}</Text>
+      ) : null}
+      {earlierExpanded ? grouped.earlier.map((item) => renderItem(item, true)) : null}
+      {earlierExpanded && grouped.clearedCount > 0 ? <Text color={theme.color.t4} dimColor>{`  restore (${grouped.clearedCount})`}</Text> : null}
     </Box>
   );
 }
 
 // Background command tasks — mirrors the desktop actions-pane Background
 // section. Each row: `$ <smart label>  status` (ASCII, one line).
-function ChatInfoBackgroundBlock({ info, brandColor, width }: { info: ChatInfoSnapshot; brandColor: string; width: number }) {
+function ChatInfoBackgroundBlock({ info, brandColor, width, viewState }: { info: ChatInfoSnapshot; brandColor: string; width: number; viewState: SubagentPaneViewState }) {
   if (!info.backgroundWork.length) return null;
   const inner = Math.max(10, width - 4);
-  const visible = info.backgroundWork.slice(0, SCHEDULE_VISIBLE_CAP);
-  const hiddenAfter = info.backgroundWork.length - visible.length;
+  const clearedIds = new Set(viewState.cleared?.background ?? []);
+  const grouped = groupPaneSectionItems(info.backgroundWork, {
+    isEarlier: isEarlierBackgroundItem,
+    isCleared: (item) => clearedIds.has(item.id),
+    isPinned: () => false,
+  });
+  const capped = viewState.showAll?.background
+    ? { visible: grouped.active, hiddenCount: 0 }
+    : capPaneSectionItems(grouped.active, BACKGROUND_ACTIVE_CAP, (item) => item.status === "failed");
+  const earlierExpanded = viewState.earlierExpanded?.background === true;
+  const renderItem = (item: ChatScheduledWorkSnapshot) => {
+    const raw = (item.title || item.prompt || item.summary || "").trim();
+    const label = backgroundCommandLabel(raw) || raw || "background command";
+    const status = ` ${item.status}`;
+    const labelBudget = Math.max(6, inner - status.length - 4);
+    return (
+      <Text key={item.id} color={scheduleStatusColor(item.status)} wrap="truncate-end">
+        {"$ "}{endTruncate(label, labelBudget)} <Text color={theme.color.t4}>{item.status}</Text>
+      </Text>
+    );
+  };
   return (
     <Box flexDirection="column">
-      <ChatInfoSectionHead title="BACKGROUND" hint={`${info.backgroundWork.length}`} color={brandColor} width={width} />
-      {visible.map((item) => {
-        const raw = (item.title || item.prompt || item.summary || "").trim();
-        const label = backgroundCommandLabel(raw) || raw || "background command";
-        const status = ` ${item.status}`;
-        const labelBudget = Math.max(6, inner - status.length - 4);
-        return (
-          <Text key={item.id} color={scheduleStatusColor(item.status)} wrap="truncate-end">
-            {"$ "}{endTruncate(label, labelBudget)} <Text color={theme.color.t4}>{item.status}</Text>
-          </Text>
-        );
-      })}
-      {hiddenAfter > 0 ? <Text color={theme.color.t4} dimColor>{`  ↓ ${hiddenAfter} more`}</Text> : null}
+      <ChatInfoSectionHead title="BACKGROUND" hint={grouped.earlier.length ? `${grouped.active.length} · ${grouped.earlier.length} earlier` : `${grouped.active.length}`} color={brandColor} width={width} />
+      {capped.visible.map(renderItem)}
+      {capped.hiddenCount > 0 ? <Text color={theme.color.t4} dimColor>{`  + show all (${capped.hiddenCount})`}</Text> : null}
+      {grouped.earlier.length > 0 || grouped.clearedCount > 0 ? <Text color={theme.color.t4} dimColor>{`  ${earlierExpanded ? "▾" : "▸"} earlier (${grouped.earlier.length})`}</Text> : null}
+      {earlierExpanded ? grouped.earlier.map(renderItem) : null}
     </Box>
   );
 }
@@ -1181,10 +1235,12 @@ function ChatInfoPane({
   info,
   selectedIndex,
   width,
+  subagentPaneViewState,
 }: {
   info: ChatInfoSnapshot;
   selectedIndex: number;
   width: number;
+  subagentPaneViewState: SubagentPaneViewState;
 }) {
   const brand = theme.provider(info.provider);
   // With the resume row visible the selection space shifts by one (0 = resume,
@@ -1197,10 +1253,10 @@ function ChatInfoPane({
       <ChatInfoHeader info={info} width={width} />
       <ChatInfoPlanBlock info={info} brandColor={brand.color} width={width} />
       <ChatInfoGoalBlock info={info} brandColor={brand.color} width={width} />
-      <ChatInfoRoster info={info} selectedIndex={selectedIndex - resumeOffset} brandColor={brand.color} width={width} />
+      <ChatInfoRoster info={info} selectedIndex={selectedIndex - resumeOffset} brandColor={brand.color} width={width} viewState={subagentPaneViewState} />
       <ChatInfoTasksBlock info={info} brandColor={brand.color} width={width} />
-      <ChatInfoBackgroundBlock info={info} brandColor={brand.color} width={width} />
-      <ChatInfoScheduleBlock info={info} brandColor={brand.color} width={width} />
+      <ChatInfoBackgroundBlock info={info} brandColor={brand.color} width={width} viewState={subagentPaneViewState} />
+      <ChatInfoScheduleBlock info={info} brandColor={brand.color} width={width} viewState={subagentPaneViewState} />
       <ChatInfoPrBlock info={info} brandColor={brand.color} width={width} />
     </Box>
   );
@@ -2147,6 +2203,7 @@ function RightPaneComponent({
   modelPickerInputs,
   onModelPickerMeasureOrigin,
   scrollOffsetRows = 0,
+  subagentPaneViewState = {},
 }: {
   content: RightPaneContent;
   formValues?: Record<string, string>;
@@ -2156,6 +2213,7 @@ function RightPaneComponent({
   activeProvider?: AdeCodeProvider | null;
   width?: number;
   scrollOffsetRows?: number;
+  subagentPaneViewState?: SubagentPaneViewState;
   /** Reports the model-picker's measured content origin for click hit-testing. */
   onModelPickerMeasureOrigin?: (origin: { x: number; y: number; width: number }) => void;
   /** Data passed in by app.tsx for the model-picker content kind. */
@@ -2310,7 +2368,7 @@ function RightPaneComponent({
       ) : null}
 
       {content.kind === "chat-info" ? (
-        <ChatInfoPane info={content.info} selectedIndex={selectedIndex} width={paneWidth} />
+        <ChatInfoPane info={content.info} selectedIndex={selectedIndex} width={paneWidth} subagentPaneViewState={subagentPaneViewState} />
       ) : null}
 
       {content.kind === "model-picker" && modelPickerInputs ? (
diff --git a/apps/ade-cli/src/tuiClient/subagentPane.ts b/apps/ade-cli/src/tuiClient/subagentPane.ts
index 1b0a20665..3300c47cf 100644
--- a/apps/ade-cli/src/tuiClient/subagentPane.ts
+++ b/apps/ade-cli/src/tuiClient/subagentPane.ts
@@ -6,13 +6,19 @@ export {
   buildSubagentTranscriptEvents,
   isLifecycleEventForSnapshot,
   selectedSubagentSnapshot,
+  SUBAGENT_PANE_ROSTER_CAPACITY,
   subagentIndexForPaneLine,
   subagentPaneSelectableLineOffsets,
   subagentTranscriptMessagesToEvents,
+  windowSubagentPaneRows,
 } from "../../../desktop/src/shared/chatSubagents";
 export type {
+  SubagentPaneDisclosureSection,
   SubagentPaneRow,
   SubagentPaneSection,
+  SubagentPaneTarget,
+  SubagentPaneViewSection,
+  SubagentPaneViewState,
 } from "../../../desktop/src/shared/chatSubagents";
 
 export type SubagentPaneContent = SharedSubagentPaneContent & {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
index 3d0e6decc..8225256eb 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
@@ -434,6 +434,63 @@ describe("AgentChatMessageList transcript rendering", () => {
     });
   });
 
+  it("copies a multi-block assistant turn from the last text row", async () => {
+    const writeText = vi.fn().mockResolvedValue(undefined);
+    Object.defineProperty(navigator, "clipboard", {
+      configurable: true,
+      value: { writeText },
+    });
+
+    renderMessageList([
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: { type: "text", text: "First block.", itemId: "text-1", turnId: "turn-1" },
+      },
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:01.000Z",
+        event: { type: "text", text: "Second block.", itemId: "text-2", turnId: "turn-1" },
+      },
+    ]);
+
+    expect(screen.getAllByRole("button", { name: "Copy message" })).toHaveLength(2);
+    const turnButton = screen.getByRole("button", { name: "Copy whole turn" });
+    fireEvent.click(turnButton);
+    await waitFor(() => expect(writeText).toHaveBeenCalledWith("First block.\n\nSecond block."));
+  });
+
+  it("does not add turn-copy chrome for single-block or legacy null-turn text", () => {
+    const { rerender } = renderMessageList([
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: { type: "text", text: "One block.", itemId: "text-1", turnId: "turn-1" },
+      },
+    ]);
+    expect(screen.queryByRole("button", { name: "Copy whole turn" })).toBeNull();
+
+    rerender(
+      <MemoryRouter>
+        <AgentChatMessageList
+          events={[
+            {
+              sessionId: "session-1",
+              timestamp: "2026-03-17T10:00:00.000Z",
+              event: { type: "text", text: "Legacy one.", itemId: "legacy-1" },
+            },
+            {
+              sessionId: "session-1",
+              timestamp: "2026-03-17T10:00:01.000Z",
+              event: { type: "text", text: "Legacy two.", itemId: "legacy-2" },
+            },
+          ]}
+        />
+      </MemoryRouter>,
+    );
+    expect(screen.queryByRole("button", { name: "Copy whole turn" })).toBeNull();
+  });
+
   it("copies assistant code blocks from the transcript", async () => {
     const writeText = vi.fn().mockResolvedValue(undefined);
     Object.defineProperty(navigator, "clipboard", {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
index 1aaf6311c..65ca71ee6 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
@@ -287,6 +287,30 @@ function getEventTurnId(event: AgentChatEvent): string | null {
   return turnId.length ? turnId : null;
 }
 
+export type AssistantTurnCopyInfo = {
+  text: string;
+  lastTextEventKey: string;
+  textEventCount: number;
+};
+
+export function deriveAssistantTurnCopyMap(
+  rows: readonly TranscriptRenderEnvelope[],
+): Map<string, AssistantTurnCopyInfo> {
+  const result = new Map<string, AssistantTurnCopyInfo>();
+  for (const row of rows) {
+    if (row.event.type !== "text") continue;
+    const turnId = getEventTurnId(row.event);
+    if (!turnId) continue;
+    const existing = result.get(turnId);
+    result.set(turnId, {
+      text: existing ? `${existing.text}\n\n${row.event.text}` : row.event.text,
+      lastTextEventKey: row.key,
+      textEventCount: (existing?.textEventCount ?? 0) + 1,
+    });
+  }
+  return result;
+}
+
 function basenamePathLabel(value: string): string {
   const normalized = normalizePath(value);
   const basename = normalized.split("/").pop()?.trim();
@@ -622,9 +646,13 @@ type RenderEnvelope = {
 function MessageCopyButton({
   value,
   className,
+  label = "Copy",
+  title = "Copy message",
 }: {
   value: string;
   className?: string;
+  label?: string;
+  title?: string;
 }) {
   const [copied, setCopied] = useState(false);
   const mountedRef = useRef(true);
@@ -673,11 +701,11 @@ function MessageCopyButton({
         className,
       )}
       onClick={handleCopy}
-      title={copied ? "Copied" : "Copy message"}
-      aria-label={copied ? "Copied" : "Copy message"}
+      title={copied ? "Copied" : title}
+      aria-label={copied ? "Copied" : title}
     >
       {copied ? <Checks size={10} weight="bold" /> : <CopySimple size={10} weight="regular" />}
-      <span>{copied ? "Copied" : "Copy"}</span>
+      <span>{copied ? "Copied" : label}</span>
     </button>
   );
 }
@@ -2626,6 +2654,7 @@ function renderEvent(
     mosaic?: MosaicRenderContext;
     /** Scroll a row into view by its stable render key (subagent jump affordances). */
     onScrollToRowKey?: (rowKey: string) => void;
+    assistantTurnCopy?: { text: string } | null;
   }
 ) {
   const event = envelope.event;
@@ -2768,8 +2797,15 @@ function renderEvent(
       >
         {/* Unbubbled assistant prose — plain markdown on the flat canvas (Codex/t3 reference). */}
         <div className="group relative min-w-0 max-w-full overflow-visible py-0.5 pr-7 text-[length:var(--chat-font-size)] leading-[1.7]">
-          <div className="absolute right-0 top-0 opacity-0 transition-opacity duration-200 group-hover:opacity-100 focus-within:opacity-100">
+          <div className="absolute right-0 top-0 flex items-center gap-1 opacity-0 transition-opacity duration-200 group-hover:opacity-100 focus-within:opacity-100">
             <MessageCopyButton value={event.text} />
+            {options?.assistantTurnCopy ? (
+              <MessageCopyButton
+                value={options.assistantTurnCopy.text}
+                label="Copy turn"
+                title="Copy whole turn"
+              />
+            ) : null}
           </div>
           <div className="min-w-0">
             <MarkdownBlock markdown={event.text} onOpenWorkspacePath={options?.onOpenWorkspacePath} mosaic={options?.mosaic} mosaicScopeKey={envelope.key} />
@@ -4129,6 +4165,7 @@ type EventRowProps = {
   mosaic?: MosaicRenderContext;
   anchored?: boolean;
   onScrollToRowKey?: (rowKey: string) => void;
+  assistantTurnCopy?: { text: string } | null;
 };
 
 const EventRow = React.memo(function EventRow({
@@ -4161,6 +4198,7 @@ const EventRow = React.memo(function EventRow({
   mosaic,
   anchored,
   onScrollToRowKey,
+  assistantTurnCopy,
 }: EventRowProps) {
   const workLogAnimate = Boolean(turnActive)
     && !sessionEnded
@@ -4223,6 +4261,7 @@ const EventRow = React.memo(function EventRow({
             turnDiffSummaries,
             mosaic,
             onScrollToRowKey,
+            assistantTurnCopy,
           })}
       {envelope.event.type === "done" ? (
         <DoneTurnDivider
@@ -4702,6 +4741,13 @@ function AgentChatMessageListMain({
     collapseCacheRef.current = { events, rows: nextRows, context };
     return nextRows;
   }, [events]);
+  const assistantTurnCopyByRowKey = useMemo(() => {
+    const byRowKey = new Map<string, AssistantTurnCopyInfo>();
+    for (const info of deriveAssistantTurnCopyMap(rows).values()) {
+      if (info.textEventCount >= 2) byRowKey.set(info.lastTextEventKey, info);
+    }
+    return byRowKey;
+  }, [rows]);
   const groupedRows = useMemo(() => groupChatTranscriptRows(rows), [rows]);
   const groupedRowKeys = useMemo(() => groupedRows.map((row) => row.key), [groupedRows]);
   const prevGroupedRowKeysRef = useRef<readonly string[] | null>(null);
@@ -5336,6 +5382,7 @@ function AgentChatMessageListMain({
 
     const rowTurnActive = Boolean(currentTurn && activeTurnId && currentTurn === activeTurnId) && !sessionEnded;
     const anchored = envelope.key === anchoredRowKey;
+    const assistantTurnCopy = assistantTurnCopyByRowKey.get(envelope.key) ?? null;
 
     if (virtualized) {
       return (
@@ -5372,6 +5419,7 @@ function AgentChatMessageListMain({
           mosaic={mosaic}
           anchored={anchored}
           onScrollToRowKey={scrollToRowKey}
+          assistantTurnCopy={assistantTurnCopy}
         />
       );
     }
@@ -5407,9 +5455,10 @@ function AgentChatMessageListMain({
         mosaic={mosaic}
         anchored={anchored}
         onScrollToRowKey={scrollToRowKey}
+        assistantTurnCopy={assistantTurnCopy}
       />
     );
-  }, [activeTurnId, anchoredRowKey, assistantLabel, surfaceMode, surfaceProfile, groupedRows, latestWorkLogIndex, turnModelState, handleApproval, handleMeasure, openWorkspacePath, handleNavigateSuggestion, handleReviewChanges, onCodexRecovery, onInsertDraft, onRevealChatTerminal, onRewindFiles, turnDiffSummaries, respondingApprovalIds, pendingApprovalIds, resolvedInputStates, laneId, sessionId, sessionEnded, runtimeName, mosaic, scrollToRowKey]);
+  }, [activeTurnId, anchoredRowKey, assistantLabel, assistantTurnCopyByRowKey, surfaceMode, surfaceProfile, groupedRows, latestWorkLogIndex, turnModelState, handleApproval, handleMeasure, openWorkspacePath, handleNavigateSuggestion, handleReviewChanges, onCodexRecovery, onInsertDraft, onRevealChatTerminal, onRewindFiles, turnDiffSummaries, respondingApprovalIds, pendingApprovalIds, resolvedInputStates, laneId, sessionId, sessionEnded, runtimeName, mosaic, scrollToRowKey]);
 
   // Compute the bottom spacer height for virtualized mode.
   const bottomSpacerHeight = useMemo(() => {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
index db8114943..f4809d5c5 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
@@ -9326,6 +9326,7 @@ export function AgentChatPane({
   const proofSessionId = selectedSessionId ?? "";
   const agentsTabContent = selectedSubagentPaneAvailable || selectedTodoItems.length > 0 || selectedScheduledWorkSnapshots.length > 0 ? (
     <ChatSubagentsPanel
+      sessionId={selectedSessionId}
       snapshots={selectedSubagentSnapshots}
       events={selectedEvents}
       todoItems={selectedTodoItems}
@@ -9347,6 +9348,7 @@ export function AgentChatPane({
         });
       } : undefined}
       variant="pane"
+      className="h-full"
       onSelectSubagent={(selection) => {
         setSubagentView({
           taskId: selection.taskId,
@@ -10698,7 +10700,7 @@ export function AgentChatPane({
 
   const SIDE_PANE_FADE = { duration: 0.16, ease: [0.4, 0, 0.2, 1] as const };
   const FLOATING_PANE_CARD_CLASS =
-    "ade-floating-side-pane flex w-full flex-col overflow-y-auto rounded-xl border border-white/[0.07] bg-[color:var(--work-sidebar-bg,#161618)] shadow-[0_20px_60px_-30px_rgba(0,0,0,0.8)]";
+    "ade-floating-side-pane flex w-full flex-col overflow-hidden rounded-xl border border-white/[0.07] bg-[color:var(--work-sidebar-bg,#161618)] shadow-[0_20px_60px_-30px_rgba(0,0,0,0.8)]";
   const renderFloatingPane = (content: React.ReactNode) => (
     <motion.div
       key="floating-right-pane"
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
index 7f0561ffb..eb664fd45 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
@@ -188,6 +188,7 @@ describe("ChatSubagentsPanel (pane variant)", () => {
       />,
     );
 
+    fireEvent.click(screen.getByRole("button", { name: /Earlier \(1\)/i }));
     fireEvent.click(screen.getByTitle("Audit chat renderer"));
 
     await waitFor(() => expect(probeSubagentTranscript).toHaveBeenCalledTimes(1));
@@ -414,6 +415,7 @@ describe("ChatSubagentsPanel (pane variant)", () => {
 
     // Background section shows smart labels (cwd stripped from the collapsed row).
     expect(screen.getByText("npx vitest run t")).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: /Earlier \(1\)/i }));
     expect(screen.getByText("npm run build")).toBeTruthy();
 
     // Schedule row present.
@@ -516,7 +518,7 @@ describe("ChatSubagentsPanel (pane variant)", () => {
     expect(screen.getByText("paused")).toBeTruthy();
   });
 
-  it("moves fired one-shot wakeups into collapsed history and marks late fires", () => {
+  it("moves fired one-shot wakeups into the collapsed Earlier group and marks late fires", () => {
     const firedAt = new Date(2026, 4, 12, 8, 41).toISOString();
     render(
       <ChatSubagentsPanel
@@ -544,13 +546,13 @@ describe("ChatSubagentsPanel (pane variant)", () => {
     );
 
     expect(screen.getByTitle("Recurring CI check")).toBeTruthy();
-    const historyToggle = screen.getByRole("button", { name: "History (1)" });
-    expect(historyToggle.getAttribute("aria-expanded")).toBe("false");
+    const earlierToggle = screen.getByRole("button", { name: "Earlier (1)" });
+    expect(earlierToggle.getAttribute("aria-expanded")).toBe("false");
     expect(screen.queryByText("✓ Check PR CI · fired 8:41 AM · late")).toBeNull();
 
-    fireEvent.click(historyToggle);
+    fireEvent.click(earlierToggle);
 
-    expect(historyToggle.getAttribute("aria-expanded")).toBe("true");
+    expect(earlierToggle.getAttribute("aria-expanded")).toBe("true");
     expect(screen.getByText("✓ Check PR CI · fired 8:41 AM · late")).toBeTruthy();
     expect(screen.queryByText("done")).toBeNull();
   });
@@ -597,7 +599,89 @@ describe("ChatSubagentsPanel (pane variant)", () => {
       />,
     );
 
+    fireEvent.click(screen.getByRole("button", { name: /Earlier \(1\)/i }));
     expect(screen.getByText("done")).toBeTruthy();
     expect(screen.queryByText("running")).toBeNull();
   });
+
+  it("keeps the small case free of collapse, Earlier, Show all, and Clear chrome", () => {
+    render(
+      <ChatSubagentsPanel
+        snapshots={[baseSnapshot]}
+        events={[]}
+        variant="pane"
+      />,
+    );
+
+    expect(screen.queryByRole("button", { name: /Subagents/i })).toBeNull();
+    expect(screen.queryByRole("button", { name: /Earlier/i })).toBeNull();
+    expect(screen.queryByRole("button", { name: /Show all/i })).toBeNull();
+    expect(screen.queryByRole("button", { name: "Clear" })).toBeNull();
+  });
+
+  it("caps active rows, exempts failed rows, and reveals all rows once", () => {
+    const snapshots = Array.from({ length: 14 }, (_, index): ChatSubagentSnapshot => ({
+      ...baseSnapshot,
+      taskId: `running-${index}`,
+      description: `Running ${index}`,
+      background: false,
+    }));
+    snapshots.push({
+      ...baseSnapshot,
+      taskId: "failed-beyond-cap",
+      description: "Failed beyond cap",
+      status: "failed",
+      background: false,
+    });
+
+    render(<ChatSubagentsPanel snapshots={snapshots} events={[]} variant="pane" />);
+
+    expect(screen.getByTitle("Failed beyond cap")).toBeTruthy();
+    expect(screen.queryByTitle("Running 13")).toBeNull();
+    fireEvent.click(screen.getByRole("button", { name: "Show all (2 running)" }));
+    expect(screen.getByTitle("Running 13")).toBeTruthy();
+    expect(screen.queryByRole("button", { name: /Show all/i })).toBeNull();
+  });
+
+  it("clears and restores Earlier rows with the normalized per-session storage shape", () => {
+    const sessionId = "pane-persistence";
+    window.localStorage.removeItem(`ade.chat.paneUi.v1:${sessionId}`);
+    window.localStorage.removeItem(`ade.chat.paneCleared.v1:${sessionId}`);
+    const completed = ["done-1", "done-2"].map((taskId): ChatSubagentSnapshot => ({
+      ...baseSnapshot,
+      taskId,
+      description: taskId,
+      status: "completed",
+      background: false,
+    }));
+
+    render(
+      <ChatSubagentsPanel
+        sessionId={sessionId}
+        snapshots={completed}
+        events={[]}
+        variant="pane"
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Clear" }));
+    expect(screen.getByText("Subagents · all clear")).toBeTruthy();
+    expect(JSON.parse(window.localStorage.getItem(`ade.chat.paneCleared.v1:${sessionId}`) ?? "null")).toEqual({
+      subagents: ["done-1", "done-2"],
+      background: [],
+      schedule: [],
+    });
+    fireEvent.click(screen.getByRole("button", { name: "Restore (2)" }));
+    expect(screen.getByRole("button", { name: "Earlier (2)" })).toBeTruthy();
+  });
+
+  it("owns the pane scroller and uses sticky opaque section headers", () => {
+    render(<ChatSubagentsPanel snapshots={[baseSnapshot]} events={[]} variant="pane" />);
+
+    const scroller = screen.getByTestId("chat-subagents-pane-scroll");
+    expect(scroller.className).toContain("overflow-y-auto");
+    const header = screen.getByText("Subagents").closest("div");
+    expect(header?.className).toContain("sticky");
+    expect(header?.className).toContain("--work-sidebar-bg");
+  });
 });
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
index 1f41aeb85..8f55f55c9 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState, type ReactNode } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
 import { AnimatePresence, motion } from "motion/react";
 import {
   CaretDown,
@@ -17,11 +17,23 @@ import type { ChatScheduledWorkSnapshot, ChatSubagentSnapshot } from "./chatExec
 import { derivePlan } from "./chatExecutionSummary";
 import type { TodoItemSnapshot } from "./chatExecutionSummary";
 import { ChatTaskList } from "./ChatTasksPanel";
-import type { ChatInfoPlanStep } from "../../../shared/chatSubagents";
-import { isBackgroundShellCommand } from "../../../shared/chatSubagents";
+import type { ChatInfoPlanStep, PaneSectionKey } from "../../../shared/chatSubagents";
+import {
+  BACKGROUND_ACTIVE_CAP,
+  PROGRESS_CAP,
+  SCHEDULE_ACTIVE_CAP,
+  SUBAGENTS_ACTIVE_CAP,
+  TASKS_CAP,
+  capPaneSectionItems,
+  groupPaneSectionItems,
+  isBackgroundShellCommand,
+  isEarlierSubagentSnapshot,
+} from "../../../shared/chatSubagents";
 import {
   backgroundCommandCwd,
   backgroundCommandLabel,
+  isEarlierBackgroundItem,
+  isEarlierScheduleItem,
   isFiredOneShotWakeup,
   scheduledNextFireLabel,
 } from "../../../shared/chatScheduledWork";
@@ -32,6 +44,117 @@ import { CodexGoalCard } from "./codex/CodexGoalCard";
 import { ChatSubagentGlyph, chatSubagentColor, chatSubagentDisplayName } from "./chatSubagentIdentity";
 
 const GLYPH_SIZE = 16;
+const PANE_UI_STORAGE_PREFIX = "ade.chat.paneUi.v1";
+const PANE_CLEARED_STORAGE_PREFIX = "ade.chat.paneCleared.v1";
+const PANE_STORAGE_ENTRY_CAP = 100;
+
+type PaneUiStorageState = {
+  collapsed: Partial<Record<PaneSectionKey, boolean>>;
+  earlier: Partial<Record<Extract<PaneSectionKey, "subagents" | "background" | "schedule">, boolean>>;
+};
+
+type PaneClearedStorageState = Record<Extract<PaneSectionKey, "subagents" | "background" | "schedule">, string[]>;
+
+type PaneStorage = Pick<Storage, "getItem" | "setItem" | "removeItem" | "key" | "length">;
+
+const EMPTY_PANE_UI_STATE: PaneUiStorageState = { collapsed: {}, earlier: {} };
+const EMPTY_PANE_CLEARED_STATE: PaneClearedStorageState = { subagents: [], background: [], schedule: [] };
+const PANE_SECTION_KEYS: PaneSectionKey[] = ["progress", "tasks", "subagents", "background", "schedule"];
+const PANE_EARLIER_SECTION_KEYS = ["subagents", "background", "schedule"] as const;
+
+export function chatPaneUiStorageKey(sessionId: string): string {
+  return `${PANE_UI_STORAGE_PREFIX}:${sessionId}`;
+}
+
+export function chatPaneClearedStorageKey(sessionId: string): string {
+  return `${PANE_CLEARED_STORAGE_PREFIX}:${sessionId}`;
+}
+
+function booleanMap<T extends string>(value: unknown, keys: readonly T[]): Partial<Record<T, boolean>> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const record = value as Record<string, unknown>;
+  const result: Partial<Record<T, boolean>> = {};
+  for (const key of keys) {
+    if (typeof record[key] === "boolean") result[key] = record[key] as boolean;
+  }
+  return result;
+}
+
+export function parseChatPaneUiState(raw: string | null): PaneUiStorageState {
+  if (!raw) return EMPTY_PANE_UI_STATE;
+  try {
+    const parsed = JSON.parse(raw) as { collapsed?: unknown; earlier?: unknown };
+    return {
+      collapsed: booleanMap(parsed.collapsed, PANE_SECTION_KEYS),
+      earlier: booleanMap(parsed.earlier, PANE_EARLIER_SECTION_KEYS),
+    };
+  } catch {
+    return EMPTY_PANE_UI_STATE;
+  }
+}
+
+export function parseChatPaneClearedState(raw: string | null): PaneClearedStorageState {
+  if (!raw) return EMPTY_PANE_CLEARED_STATE;
+  try {
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    return Object.fromEntries(PANE_EARLIER_SECTION_KEYS.map((section) => [
+      section,
+      Array.isArray(parsed[section])
+        ? [...new Set(parsed[section].filter((id): id is string => typeof id === "string" && id.length > 0))]
+        : [],
+    ])) as PaneClearedStorageState;
+  } catch {
+    return EMPTY_PANE_CLEARED_STATE;
+  }
+}
+
+export function cleanupChatPaneStorage(storage: PaneStorage): void {
+  for (const prefix of [PANE_UI_STORAGE_PREFIX, PANE_CLEARED_STORAGE_PREFIX]) {
+    const keys: string[] = [];
+    for (let index = 0; index < storage.length; index += 1) {
+      const key = storage.key(index);
+      if (key?.startsWith(`${prefix}:`)) keys.push(key);
+    }
+    for (const key of keys.slice(0, Math.max(0, keys.length - PANE_STORAGE_ENTRY_CAP))) {
+      storage.removeItem(key);
+    }
+  }
+}
+
+function readPaneUiState(sessionId?: string | null): PaneUiStorageState {
+  if (!sessionId || typeof window === "undefined") return EMPTY_PANE_UI_STATE;
+  try {
+    return parseChatPaneUiState(window.localStorage.getItem(chatPaneUiStorageKey(sessionId)));
+  } catch {
+    return EMPTY_PANE_UI_STATE;
+  }
+}
+
+function readPaneClearedState(sessionId?: string | null): PaneClearedStorageState {
+  if (!sessionId || typeof window === "undefined") return EMPTY_PANE_CLEARED_STATE;
+  try {
+    return parseChatPaneClearedState(window.localStorage.getItem(chatPaneClearedStorageKey(sessionId)));
+  } catch {
+    return EMPTY_PANE_CLEARED_STATE;
+  }
+}
+
+function paneSectionHint(args: {
+  activeCount: number;
+  earlierCount: number;
+  clearedCount: number;
+  runningCount?: number;
+  failedCount?: number;
+}): string {
+  const active = args.runningCount && args.failedCount
+    ? `${args.runningCount} running · ${args.failedCount} failed`
+    : `${args.activeCount}`;
+  return [
+    active,
+    ...(args.earlierCount ? [`${args.earlierCount} earlier`] : []),
+    ...(args.clearedCount ? [`${args.clearedCount} hidden`] : []),
+  ].join(" · ");
+}
 
 type GlyphCategory = "subagent" | "background";
 
@@ -73,15 +196,59 @@ function SectionHeader({
   action,
   tone = "neutral",
   emphasized = false,
+  sticky = false,
+  collapsible = false,
+  collapsed = false,
+  onToggle,
 }: {
   label: string;
   hint?: string;
   action?: ReactNode;
   tone?: SectionTone;
   emphasized?: boolean;
+  sticky?: boolean;
+  collapsible?: boolean;
+  collapsed?: boolean;
+  onToggle?: () => void;
 }) {
+  const wrapperClass = cn(
+    "flex items-center justify-between px-3.5",
+    emphasized ? "pb-1.5 pt-3" : "pb-1 pt-2.5",
+    sticky && "sticky top-0 z-[5] bg-[color:var(--work-sidebar-bg,#161618)]",
+  );
+  if (collapsible) {
+    return (
+      <div className={wrapperClass}>
+        <button
+          type="button"
+          className="flex min-w-0 flex-1 items-center justify-between text-left"
+          onClick={onToggle}
+          aria-expanded={!collapsed}
+        >
+          <span
+            className={cn(
+              "flex min-w-0 items-center gap-1.5 font-sans uppercase tracking-[0.06em] text-fg/45",
+              emphasized ? "text-[10.5px] font-medium" : "text-[10px] font-medium",
+            )}
+          >
+            <span aria-hidden className="shrink-0 text-fg/35">
+              {collapsed ? <CaretRight size={10} weight="bold" /> : <CaretDown size={10} weight="bold" />}
+            </span>
+            <span aria-hidden className={cn("inline-block h-1 w-1 shrink-0 rounded-full", SECTION_DOT_CLASS[tone])} />
+            <span className="truncate">{label}</span>
+          </span>
+          {hint ? (
+            <span className="ml-2 shrink-0 font-sans text-[10.5px] tabular-nums text-fg/35">
+              {hint}
+            </span>
+          ) : null}
+        </button>
+        {action ? <span className="ml-1.5 flex items-center gap-1.5">{action}</span> : null}
+      </div>
+    );
+  }
   return (
-    <div className={cn("flex items-center justify-between px-3.5", emphasized ? "pb-1.5 pt-3" : "pb-1 pt-2.5")}>
+    <div className={wrapperClass}>
       <span
         className={cn(
           "flex items-center gap-1.5 font-sans uppercase tracking-[0.06em] text-fg/45",
@@ -106,6 +273,72 @@ function SectionHeader({
   );
 }
 
+function SectionDisclosure({ open, children }: { open: boolean; children: ReactNode }) {
+  return (
+    <AnimatePresence initial={false}>
+      {open ? (
+        <motion.div
+          initial={{ height: 0, opacity: 0 }}
+          animate={{ height: "auto", opacity: 1 }}
+          exit={{ height: 0, opacity: 0 }}
+          transition={{ duration: 0.18, ease: [0.4, 0, 0.2, 1] }}
+          className="overflow-hidden"
+        >
+          {children}
+        </motion.div>
+      ) : null}
+    </AnimatePresence>
+  );
+}
+
+function EarlierToggle({
+  count,
+  clearedCount,
+  expanded,
+  onToggle,
+}: {
+  count: number;
+  clearedCount: number;
+  expanded: boolean;
+  onToggle: () => void;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onToggle}
+      aria-expanded={expanded}
+      className="flex w-full items-center gap-1.5 rounded-md px-2 py-1 text-left font-sans text-[10.5px] text-fg/40 transition-colors hover:bg-white/[0.035] hover:text-fg/60"
+    >
+      <span aria-hidden>{expanded ? <CaretDown size={10} weight="bold" /> : <CaretRight size={10} weight="bold" />}</span>
+      Earlier ({count}){clearedCount ? ` · ${clearedCount} hidden` : ""}
+    </button>
+  );
+}
+
+function ShowAllButton({ hiddenLabel, onClick }: { hiddenLabel: string; onClick: () => void }) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className="mx-2 flex w-[calc(100%-1rem)] items-center rounded-md px-2 py-1 text-left font-sans text-[10.5px] text-fg/40 transition-colors hover:bg-white/[0.035] hover:text-fg/60"
+    >
+      Show all ({hiddenLabel})
+    </button>
+  );
+}
+
+function PaneTextAction({ children, onClick }: { children: ReactNode; onClick: () => void }) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className="font-sans text-[10px] text-fg/35 transition-colors hover:text-fg/60"
+    >
+      {children}
+    </button>
+  );
+}
+
 /* ── Progress bar — 1 px hairline rule ── */
 
 function ProgressBar({ percent }: { percent: number }) {
@@ -580,6 +813,7 @@ export type SubagentSelection = {
 };
 
 export function ChatSubagentsPanel({
+  sessionId,
   snapshots,
   events,
   onSelectSubagent,
@@ -601,6 +835,7 @@ export function ChatSubagentsPanel({
   schedulesPaused = false,
   onToggleSchedulesPaused,
 }: {
+  sessionId?: string | null;
   snapshots: ChatSubagentSnapshot[];
   events: AgentChatEventEnvelope[];
   onSelectSubagent?: (selection: SubagentSelection) => void;
@@ -633,7 +868,9 @@ export function ChatSubagentsPanel({
   onToggleSchedulesPaused?: () => void;
 }) {
   const [expanded, setExpanded] = useState(false);
-  const [scheduleHistoryExpanded, setScheduleHistoryExpanded] = useState(false);
+  const [paneUi, setPaneUi] = useState<PaneUiStorageState>(() => readPaneUiState(sessionId));
+  const [paneCleared, setPaneCleared] = useState<PaneClearedStorageState>(() => readPaneClearedState(sessionId));
+  const [showAll, setShowAll] = useState<Partial<Record<PaneSectionKey, boolean>>>({});
   // Which agent's inline details drawer is open (agents with no transcript).
   const [expandedTaskId, setExpandedTaskId] = useState<string | null>(null);
   // Which agent we're currently probing for a transcript (shows a row spinner).
@@ -641,17 +878,77 @@ export function ChatSubagentsPanel({
   // Cached probe outcomes per task so repeat clicks are instant. Running agents
   // are never cached — their transcript can appear after a later poll.
   const [probeResults, setProbeResults] = useState<Record<string, boolean>>({});
+  const paneScrollRef = useRef<HTMLDivElement | null>(null);
 
-  const plan = useMemo(() => derivePlan(events), [events]);
+  useEffect(() => {
+    setPaneUi(readPaneUiState(sessionId));
+    setPaneCleared(readPaneClearedState(sessionId));
+    setShowAll({});
+  }, [sessionId]);
 
-  const { activeScheduleItems, scheduleHistoryItems } = useMemo(() => {
-    const active: ChatScheduledWorkSnapshot[] = [];
-    const history: ChatScheduledWorkSnapshot[] = [];
-    for (const item of scheduleItems) {
-      (isFiredOneShotWakeup(item) ? history : active).push(item);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    try {
+      cleanupChatPaneStorage(window.localStorage);
+    } catch {
+      // Renderer storage is best-effort; disclosure remains available in memory.
     }
-    return { activeScheduleItems: active, scheduleHistoryItems: history };
-  }, [scheduleItems]);
+  }, []);
+
+  const updatePaneUi = useCallback((update: (current: PaneUiStorageState) => PaneUiStorageState) => {
+    setPaneUi((current) => {
+      const next = update(current);
+      if (sessionId) {
+        try {
+          window.localStorage.setItem(chatPaneUiStorageKey(sessionId), JSON.stringify(next));
+        } catch {
+          // Keep the in-memory state when localStorage is blocked.
+        }
+      }
+      return next;
+    });
+  }, [sessionId]);
+
+  const updatePaneCleared = useCallback((update: (current: PaneClearedStorageState) => PaneClearedStorageState) => {
+    setPaneCleared((current) => {
+      const next = update(current);
+      if (sessionId) {
+        try {
+          window.localStorage.setItem(chatPaneClearedStorageKey(sessionId), JSON.stringify(next));
+        } catch {
+          // Keep the in-memory state when localStorage is blocked.
+        }
+      }
+      return next;
+    });
+  }, [sessionId]);
+
+  const toggleSection = useCallback((section: PaneSectionKey) => {
+    updatePaneUi((current) => ({
+      ...current,
+      collapsed: { ...current.collapsed, [section]: current.collapsed[section] !== true },
+    }));
+  }, [updatePaneUi]);
+
+  const toggleEarlier = useCallback((section: "subagents" | "background" | "schedule") => {
+    updatePaneUi((current) => ({
+      ...current,
+      earlier: { ...current.earlier, [section]: current.earlier[section] !== true },
+    }));
+  }, [updatePaneUi]);
+
+  const clearEarlier = useCallback((section: "subagents" | "background" | "schedule", ids: string[]) => {
+    updatePaneCleared((current) => ({
+      ...current,
+      [section]: [...new Set([...current[section], ...ids])],
+    }));
+  }, [updatePaneCleared]);
+
+  const restoreCleared = useCallback((section: "subagents" | "background" | "schedule") => {
+    updatePaneCleared((current) => ({ ...current, [section]: [] }));
+  }, [updatePaneCleared]);
+
+  const plan = useMemo(() => derivePlan(events), [events]);
 
   const { subagents, runningCount, completedCount, bgRunningCount } = useMemo(() => {
     // ONE merged subagent list — foreground + background-run agents together.
@@ -688,18 +985,75 @@ export function ChatSubagentsPanel({
     };
   }, [snapshots]);
 
+  const pinnedSubagentIds = useMemo(() => new Set(
+    [selectedTaskId, expandedTaskId].filter((id): id is string => Boolean(id)),
+  ), [expandedTaskId, selectedTaskId]);
+  const clearedSubagentIds = useMemo(() => new Set(paneCleared.subagents), [paneCleared.subagents]);
+  const clearedBackgroundIds = useMemo(() => new Set(paneCleared.background), [paneCleared.background]);
+  const clearedScheduleIds = useMemo(() => new Set(paneCleared.schedule), [paneCleared.schedule]);
+
+  const subagentGroups = useMemo(() => groupPaneSectionItems(subagents, {
+    isEarlier: isEarlierSubagentSnapshot,
+    isCleared: (snapshot) => clearedSubagentIds.has(snapshot.taskId),
+    isPinned: (snapshot) => pinnedSubagentIds.has(snapshot.taskId),
+  }), [clearedSubagentIds, pinnedSubagentIds, subagents]);
+  const backgroundGroups = useMemo(() => groupPaneSectionItems(backgroundItems, {
+    isEarlier: isEarlierBackgroundItem,
+    isCleared: (snapshot) => clearedBackgroundIds.has(snapshot.id),
+    isPinned: () => false,
+  }), [backgroundItems, clearedBackgroundIds]);
+  const scheduleGroups = useMemo(() => groupPaneSectionItems(scheduleItems, {
+    isEarlier: isEarlierScheduleItem,
+    isCleared: (snapshot) => clearedScheduleIds.has(snapshot.id),
+    isPinned: () => false,
+  }), [clearedScheduleIds, scheduleItems]);
+
+  const cappedSubagents = useMemo(() => (
+    showAll.subagents
+      ? { visible: subagentGroups.active, hiddenCount: 0 }
+      : capPaneSectionItems(subagentGroups.active, SUBAGENTS_ACTIVE_CAP, (snapshot) => (
+          snapshot.status === "failed" || pinnedSubagentIds.has(snapshot.taskId)
+        ))
+  ), [pinnedSubagentIds, showAll.subagents, subagentGroups.active]);
+  const cappedBackground = useMemo(() => (
+    showAll.background
+      ? { visible: backgroundGroups.active, hiddenCount: 0 }
+      : capPaneSectionItems(backgroundGroups.active, BACKGROUND_ACTIVE_CAP, (snapshot) => snapshot.status === "failed")
+  ), [backgroundGroups.active, showAll.background]);
+  const cappedSchedule = useMemo(() => (
+    showAll.schedule
+      ? { visible: scheduleGroups.active, hiddenCount: 0 }
+      : capPaneSectionItems(scheduleGroups.active, SCHEDULE_ACTIVE_CAP, (snapshot) => snapshot.status === "failed")
+  ), [scheduleGroups.active, showAll.schedule]);
+
+  useEffect(() => {
+    if (!selectedTaskId) return;
+    if (paneUi.collapsed.subagents) {
+      updatePaneUi((current) => ({
+        ...current,
+        collapsed: { ...current.collapsed, subagents: false },
+      }));
+    }
+    const frame = window.requestAnimationFrame(() => {
+      const target = [...(paneScrollRef.current?.querySelectorAll<HTMLElement>("[data-subagent-task-id]") ?? [])]
+        .find((element) => element.dataset.subagentTaskId === selectedTaskId);
+      target?.scrollIntoView?.({ block: "nearest" });
+    });
+    return () => window.cancelAnimationFrame(frame);
+  }, [paneUi.collapsed.subagents, selectedTaskId, updatePaneUi]);
+
   const headerSummary = useMemo(() => {
     const parts: string[] = [];
     if (runningCount) parts.push(`${runningCount} running`);
     if (bgRunningCount) parts.push(`${bgRunningCount} bg`);
-    if (backgroundItems.length) parts.push(`${backgroundItems.length} background`);
-    if (activeScheduleItems.length) parts.push(`${activeScheduleItems.length} scheduled`);
-    if (scheduleHistoryItems.length) parts.push(`${scheduleHistoryItems.length} history`);
+    if (backgroundGroups.active.length) parts.push(`${backgroundGroups.active.length} background`);
+    if (scheduleGroups.active.length) parts.push(`${scheduleGroups.active.length} scheduled`);
+    if (scheduleGroups.earlier.length) parts.push(`${scheduleGroups.earlier.length} earlier`);
     if (completedCount) parts.push(`${completedCount} done`);
     if (!parts.length && subagents.length) parts.push(`${subagents.length} tracked`);
     if (!parts.length) parts.push("idle");
     return parts.join(" · ");
-  }, [runningCount, bgRunningCount, backgroundItems.length, activeScheduleItems.length, scheduleHistoryItems.length, completedCount, subagents.length]);
+  }, [backgroundGroups.active.length, completedCount, runningCount, bgRunningCount, scheduleGroups.active.length, scheduleGroups.earlier.length, subagents.length]);
 
   const takeover = (snap: ChatSubagentSnapshot) => {
     setExpandedTaskId(null);
@@ -780,8 +1134,16 @@ export function ChatSubagentsPanel({
   const planComplete = plan?.steps.filter((step) => step.status === "completed").length ?? 0;
   const planTotal = plan?.steps.length ?? 0;
   const planPercent = planTotal > 0 ? Math.round((planComplete / planTotal) * 100) : 0;
+  const progressCollapsible = planTotal > PROGRESS_CAP;
+  const progressCollapsed = progressCollapsible && paneUi.collapsed.progress === true;
+  const visiblePlanSteps = plan && !showAll.progress ? plan.steps.slice(0, PROGRESS_CAP) : plan?.steps ?? [];
+  const hiddenPlanCount = Math.max(0, planTotal - visiblePlanSteps.length);
   const taskComplete = todoItems.filter((item) => item.status === "completed").length;
   const taskActive = todoItems.filter((item) => item.status === "in_progress").length;
+  const tasksCollapsible = todoItems.length > TASKS_CAP;
+  const tasksCollapsed = tasksCollapsible && paneUi.collapsed.tasks === true;
+  const visibleTodoItems = showAll.tasks ? todoItems : todoItems.slice(0, TASKS_CAP);
+  const hiddenTaskCount = todoItems.length - visibleTodoItems.length;
   const taskHint = todoItems.length
     ? [
         `${taskComplete}/${todoItems.length} complete`,
@@ -789,6 +1151,24 @@ export function ChatSubagentsPanel({
       ].join(" · ")
     : undefined;
 
+  const subagentRunningCount = subagentGroups.active.filter((item) => item.status === "running").length;
+  const subagentFailedCount = subagentGroups.active.filter((item) => item.status === "failed").length;
+  const backgroundRunningCount = backgroundGroups.active.filter((item) => item.status === "running").length;
+  const backgroundFailedCount = backgroundGroups.active.filter((item) => item.status === "failed").length;
+  const scheduleRunningCount = scheduleGroups.active.filter((item) => item.status === "running").length;
+  const scheduleFailedCount = scheduleGroups.active.filter((item) => item.status === "failed").length;
+
+  const subagentsCollapsible = subagentGroups.earlier.length > 0 || subagentGroups.active.length > SUBAGENTS_ACTIVE_CAP;
+  const backgroundCollapsible = backgroundGroups.earlier.length > 0 || backgroundGroups.active.length > BACKGROUND_ACTIVE_CAP;
+  const scheduleCollapsible = scheduleGroups.earlier.length > 0 || scheduleGroups.active.length > SCHEDULE_ACTIVE_CAP;
+  const subagentsCollapsed = subagentsCollapsible && paneUi.collapsed.subagents === true;
+  const backgroundCollapsed = backgroundCollapsible && paneUi.collapsed.background === true;
+  const scheduleCollapsed = scheduleCollapsible && paneUi.collapsed.schedule === true;
+  const subagentsAllClear = subagentGroups.active.length === 0 && subagentGroups.earlier.length === 0 && subagentGroups.clearedCount > 0;
+  const backgroundAllClear = backgroundGroups.active.length === 0 && backgroundGroups.earlier.length === 0 && backgroundGroups.clearedCount > 0;
+  const scheduleAllClear = scheduleGroups.active.length === 0 && scheduleGroups.earlier.length === 0 && scheduleGroups.clearedCount > 0;
+  const stickyHeaders = variant === "pane";
+
   const hasGoal = Boolean(goal?.objective?.trim());
   const hasTasks = todoItems.length > 0;
   const hasSubagents = subagents.length > 0;
@@ -797,7 +1177,7 @@ export function ChatSubagentsPanel({
   const hasAnything = hasGoal || Boolean(plan) || hasTasks || hasSubagents || hasBackground || hasScheduled;
 
   const body = (
-    <div className="flex flex-col font-sans">
+    <div className="flex min-h-full flex-col font-sans">
       {/* ── Goal (Codex chat goal) ───────────────────────────────── */}
       {hasGoal && goal ? (
         <CodexGoalCard
@@ -816,10 +1196,15 @@ export function ChatSubagentsPanel({
             label="Progress"
             hint={`${planComplete}/${planTotal} · ${planPercent}%`}
             tone="subagent"
+            sticky={stickyHeaders}
+            collapsible={progressCollapsible}
+            collapsed={progressCollapsed}
+            onToggle={() => toggleSection("progress")}
           />
-          <ProgressBar percent={planPercent} />
-          <ul className="px-4 pt-2">
-            {plan.steps.map((step, index) => {
+          <SectionDisclosure open={!progressCollapsed}>
+            <ProgressBar percent={planPercent} />
+            <ul className="px-4 pt-2">
+            {visiblePlanSteps.map((step, index) => {
               const isCompleted = step.status === "completed";
               const isInProgress = step.status === "in_progress";
               const isFailed = step.status === "failed";
@@ -841,7 +1226,11 @@ export function ChatSubagentsPanel({
                 </li>
               );
             })}
-          </ul>
+            </ul>
+            {hiddenPlanCount > 0 ? (
+              <ShowAllButton hiddenLabel={`${hiddenPlanCount}`} onClick={() => setShowAll((current) => ({ ...current, progress: true }))} />
+            ) : null}
+          </SectionDisclosure>
         </section>
       ) : null}
 
@@ -858,8 +1247,17 @@ export function ChatSubagentsPanel({
             hint={taskHint}
             tone="workflow"
             emphasized
+            sticky={stickyHeaders}
+            collapsible={tasksCollapsible}
+            collapsed={tasksCollapsed}
+            onToggle={() => toggleSection("tasks")}
           />
-          <ChatTaskList items={todoItems} className="px-1 pb-1 pt-0" />
+          <SectionDisclosure open={!tasksCollapsed}>
+            <ChatTaskList items={visibleTodoItems} className="px-1 pb-1 pt-0" />
+            {hiddenTaskCount > 0 ? (
+              <ShowAllButton hiddenLabel={`${hiddenTaskCount}`} onClick={() => setShowAll((current) => ({ ...current, tasks: true }))} />
+            ) : null}
+          </SectionDisclosure>
         </section>
       ) : null}
 
@@ -873,24 +1271,101 @@ export function ChatSubagentsPanel({
         >
           <SectionHeader
             label="Subagents"
-            hint={`${subagents.length}`}
+            hint={subagentsAllClear ? "all clear" : paneSectionHint({
+              activeCount: subagentGroups.active.length,
+              earlierCount: subagentGroups.earlier.length,
+              clearedCount: subagentGroups.clearedCount,
+              runningCount: subagentRunningCount,
+              failedCount: subagentFailedCount,
+            })}
             tone="subagent"
             emphasized
+            sticky={stickyHeaders}
+            collapsible={subagentsCollapsible}
+            collapsed={subagentsCollapsed}
+            onToggle={() => toggleSection("subagents")}
+            action={subagentsAllClear ? (
+              <PaneTextAction onClick={() => restoreCleared("subagents")}>Restore ({subagentGroups.clearedCount})</PaneTextAction>
+            ) : subagentGroups.earlier.length > 0 ? (
+              <PaneTextAction onClick={() => clearEarlier("subagents", subagentGroups.earlier.map((item) => item.taskId))}>Clear</PaneTextAction>
+            ) : null}
           />
-          <div className="space-y-px px-2 pb-1">
-            {subagents.map((snap) => (
-              <SubagentRow
-                key={snap.taskId}
-                snapshot={snap}
-                selected={selectedTaskId === snap.taskId}
-                expanded={expandedTaskId === snap.taskId}
-                probing={probingTaskId === snap.taskId}
-                canViewFullTranscript={canTakeover}
-                category={snap.background ? "background" : "subagent"}
-                onClick={() => handleRowClick(snap)}
+          <SectionDisclosure open={!subagentsCollapsed}>
+            {subagentsAllClear ? (
+              <div className="px-4 pb-2 text-[11px] text-fg/35">Subagents · all clear</div>
+            ) : null}
+            <div className="space-y-px px-2 pb-1">
+              <AnimatePresence initial={false}>
+                {cappedSubagents.visible.map((snap) => (
+                  <motion.div
+                    key={snap.taskId}
+                    data-subagent-task-id={snap.taskId}
+                    initial={{ height: 0, opacity: 0 }}
+                    animate={{ height: "auto", opacity: 1 }}
+                    exit={{ height: 0, opacity: 0 }}
+                    transition={{ duration: 0.18, ease: [0.4, 0, 0.2, 1] }}
+                    className="overflow-hidden"
+                  >
+                    <SubagentRow
+                      snapshot={snap}
+                      selected={selectedTaskId === snap.taskId}
+                      expanded={expandedTaskId === snap.taskId}
+                      probing={probingTaskId === snap.taskId}
+                      canViewFullTranscript={canTakeover}
+                      category={snap.background ? "background" : "subagent"}
+                      onClick={() => handleRowClick(snap)}
+                    />
+                  </motion.div>
+                ))}
+              </AnimatePresence>
+            </div>
+            {cappedSubagents.hiddenCount > 0 ? (
+              <ShowAllButton
+                hiddenLabel={`${cappedSubagents.hiddenCount} running`}
+                onClick={() => setShowAll((current) => ({ ...current, subagents: true }))}
               />
-            ))}
-          </div>
+            ) : null}
+            {subagentGroups.earlier.length > 0 || subagentGroups.clearedCount > 0 ? (
+              <div className="px-2 pt-0.5">
+                <EarlierToggle
+                  count={subagentGroups.earlier.length}
+                  clearedCount={subagentGroups.clearedCount}
+                  expanded={paneUi.earlier.subagents === true}
+                  onToggle={() => toggleEarlier("subagents")}
+                />
+                <SectionDisclosure open={paneUi.earlier.subagents === true}>
+                  <div className="space-y-px pb-1">
+                    <AnimatePresence initial={false}>
+                      {subagentGroups.earlier.map((snap) => (
+                        <motion.div
+                          key={snap.taskId}
+                          data-subagent-task-id={snap.taskId}
+                          initial={{ height: 0, opacity: 0 }}
+                          animate={{ height: "auto", opacity: 1 }}
+                          exit={{ height: 0, opacity: 0 }}
+                          transition={{ duration: 0.18, ease: [0.4, 0, 0.2, 1] }}
+                          className="overflow-hidden"
+                        >
+                          <SubagentRow
+                            snapshot={snap}
+                            selected={selectedTaskId === snap.taskId}
+                            expanded={expandedTaskId === snap.taskId}
+                            probing={probingTaskId === snap.taskId}
+                            canViewFullTranscript={canTakeover}
+                            category={snap.background ? "background" : "subagent"}
+                            onClick={() => handleRowClick(snap)}
+                          />
+                        </motion.div>
+                      ))}
+                    </AnimatePresence>
+                  </div>
+                  {subagentGroups.clearedCount > 0 ? (
+                    <div className="px-2 pb-1"><PaneTextAction onClick={() => restoreCleared("subagents")}>Restore ({subagentGroups.clearedCount})</PaneTextAction></div>
+                  ) : null}
+                </SectionDisclosure>
+              </div>
+            ) : null}
+          </SectionDisclosure>
         </section>
       ) : null}
 
@@ -902,12 +1377,51 @@ export function ChatSubagentsPanel({
             (hasGoal || plan || hasTasks || hasSubagents) && "border-t border-white/[0.04]",
           )}
         >
-          <SectionHeader label="Background" hint={`${backgroundItems.length}`} tone="background" emphasized />
-          <div className="space-y-px px-2 pb-1">
-            {backgroundItems.map((item) => (
-              <BackgroundCommandRow key={item.id} snapshot={item} />
-            ))}
-          </div>
+          <SectionHeader
+            label="Background"
+            hint={backgroundAllClear ? "all clear" : paneSectionHint({
+              activeCount: backgroundGroups.active.length,
+              earlierCount: backgroundGroups.earlier.length,
+              clearedCount: backgroundGroups.clearedCount,
+              runningCount: backgroundRunningCount,
+              failedCount: backgroundFailedCount,
+            })}
+            tone="background"
+            emphasized
+            sticky={stickyHeaders}
+            collapsible={backgroundCollapsible}
+            collapsed={backgroundCollapsed}
+            onToggle={() => toggleSection("background")}
+            action={backgroundAllClear ? (
+              <PaneTextAction onClick={() => restoreCleared("background")}>Restore ({backgroundGroups.clearedCount})</PaneTextAction>
+            ) : backgroundGroups.earlier.length > 0 ? (
+              <PaneTextAction onClick={() => clearEarlier("background", backgroundGroups.earlier.map((item) => item.id))}>Clear</PaneTextAction>
+            ) : null}
+          />
+          <SectionDisclosure open={!backgroundCollapsed}>
+            {backgroundAllClear ? <div className="px-4 pb-2 text-[11px] text-fg/35">Background · all clear</div> : null}
+            <div className="space-y-px px-2 pb-1">
+              <AnimatePresence initial={false}>
+                {cappedBackground.visible.map((item) => (
+                  <motion.div key={item.id} initial={{ height: 0, opacity: 0 }} animate={{ height: "auto", opacity: 1 }} exit={{ height: 0, opacity: 0 }} transition={{ duration: 0.18, ease: [0.4, 0, 0.2, 1] }} className="overflow-hidden">
+                    <BackgroundCommandRow snapshot={item} />
+                  </motion.div>
+                ))}
+              </AnimatePresence>
+            </div>
+            {cappedBackground.hiddenCount > 0 ? <ShowAllButton hiddenLabel={`${cappedBackground.hiddenCount}`} onClick={() => setShowAll((current) => ({ ...current, background: true }))} /> : null}
+            {backgroundGroups.earlier.length > 0 || backgroundGroups.clearedCount > 0 ? (
+              <div className="px-2 pt-0.5">
+                <EarlierToggle count={backgroundGroups.earlier.length} clearedCount={backgroundGroups.clearedCount} expanded={paneUi.earlier.background === true} onToggle={() => toggleEarlier("background")} />
+                <SectionDisclosure open={paneUi.earlier.background === true}>
+                  <div className="space-y-px pb-1">
+                    {backgroundGroups.earlier.map((item) => <BackgroundCommandRow key={item.id} snapshot={item} />)}
+                  </div>
+                  {backgroundGroups.clearedCount > 0 ? <div className="px-2 pb-1"><PaneTextAction onClick={() => restoreCleared("background")}>Restore ({backgroundGroups.clearedCount})</PaneTextAction></div> : null}
+                </SectionDisclosure>
+              </div>
+            ) : null}
+          </SectionDisclosure>
         </section>
       ) : null}
 
@@ -921,30 +1435,45 @@ export function ChatSubagentsPanel({
         >
           <SectionHeader
             label="Schedule"
-            hint={`${activeScheduleItems.length}`}
+            hint={scheduleAllClear ? "all clear" : paneSectionHint({
+              activeCount: scheduleGroups.active.length,
+              earlierCount: scheduleGroups.earlier.length,
+              clearedCount: scheduleGroups.clearedCount,
+              runningCount: scheduleRunningCount,
+              failedCount: scheduleFailedCount,
+            })}
             tone="scheduled"
             emphasized
-            action={onToggleSchedulesPaused ? (
-              <button
-                type="button"
-                onClick={onToggleSchedulesPaused}
-                aria-label={schedulesPaused
-                  ? "Resume scheduled work for this chat"
-                  : "Pause scheduled work for this chat"}
-                title={schedulesPaused
-                  ? "Resume scheduled work for this chat"
-                  : "Pause scheduled work for this chat"}
-                className="flex h-5 w-5 items-center justify-center rounded-sm text-fg/35 transition-colors hover:bg-white/[0.05] hover:text-fg/65"
-              >
-                {schedulesPaused
-                  ? <Play aria-hidden size={11} weight="fill" />
-                  : <Pause aria-hidden size={11} weight="fill" />}
-              </button>
-            ) : null}
+            sticky={stickyHeaders}
+            collapsible={scheduleCollapsible}
+            collapsed={scheduleCollapsed}
+            onToggle={() => toggleSection("schedule")}
+            action={(
+              <>
+                {scheduleAllClear ? (
+                  <PaneTextAction onClick={() => restoreCleared("schedule")}>Restore ({scheduleGroups.clearedCount})</PaneTextAction>
+                ) : scheduleGroups.earlier.length > 0 ? (
+                  <PaneTextAction onClick={() => clearEarlier("schedule", scheduleGroups.earlier.map((item) => item.id))}>Clear</PaneTextAction>
+                ) : null}
+                {onToggleSchedulesPaused ? (
+                  <button
+                    type="button"
+                    onClick={onToggleSchedulesPaused}
+                    aria-label={schedulesPaused ? "Resume scheduled work for this chat" : "Pause scheduled work for this chat"}
+                    title={schedulesPaused ? "Resume scheduled work for this chat" : "Pause scheduled work for this chat"}
+                    className="flex h-5 w-5 items-center justify-center rounded-sm text-fg/35 transition-colors hover:bg-white/[0.05] hover:text-fg/65"
+                  >
+                    {schedulesPaused ? <Play aria-hidden size={11} weight="fill" /> : <Pause aria-hidden size={11} weight="fill" />}
+                  </button>
+                ) : null}
+              </>
+            )}
           />
-          {activeScheduleItems.length ? (
+          <SectionDisclosure open={!scheduleCollapsed}>
+          {scheduleAllClear ? <div className="px-4 pb-2 text-[11px] text-fg/35">Schedule · all clear</div> : null}
+          {cappedSchedule.visible.length ? (
             <div className="space-y-px px-2 pb-1">
-              {activeScheduleItems.map((item) => (
+              {cappedSchedule.visible.map((item) => (
                 <ScheduledWorkRow
                   key={item.id}
                   snapshot={item}
@@ -953,30 +1482,21 @@ export function ChatSubagentsPanel({
               ))}
             </div>
           ) : null}
-          {scheduleHistoryItems.length ? (
+          {cappedSchedule.hiddenCount > 0 ? <ShowAllButton hiddenLabel={`${cappedSchedule.hiddenCount}`} onClick={() => setShowAll((current) => ({ ...current, schedule: true }))} /> : null}
+          {scheduleGroups.earlier.length > 0 || scheduleGroups.clearedCount > 0 ? (
             <div className="px-2 pt-0.5">
-              <button
-                type="button"
-                onClick={() => setScheduleHistoryExpanded((value) => !value)}
-                aria-expanded={scheduleHistoryExpanded}
-                className="flex w-full items-center gap-1.5 rounded-md px-2 py-1 text-left font-sans text-[10.5px] text-fg/40 transition-colors hover:bg-white/[0.035] hover:text-fg/60"
-              >
-                <span aria-hidden>
-                  {scheduleHistoryExpanded
-                    ? <CaretDown size={10} weight="bold" />
-                    : <CaretRight size={10} weight="bold" />}
-                </span>
-                History ({scheduleHistoryItems.length})
-              </button>
-              {scheduleHistoryExpanded ? (
+              <EarlierToggle count={scheduleGroups.earlier.length} clearedCount={scheduleGroups.clearedCount} expanded={paneUi.earlier.schedule === true} onToggle={() => toggleEarlier("schedule")} />
+              <SectionDisclosure open={paneUi.earlier.schedule === true}>
                 <div className="space-y-px pb-1">
-                  {scheduleHistoryItems.map((item) => (
-                    <ScheduleHistoryRow key={item.id} snapshot={item} />
-                  ))}
+                  {scheduleGroups.earlier.map((item) => isFiredOneShotWakeup(item)
+                    ? <ScheduleHistoryRow key={item.id} snapshot={item} />
+                    : <ScheduledWorkRow key={item.id} snapshot={item} schedulesPaused={schedulesPaused} />)}
                 </div>
-              ) : null}
+                {scheduleGroups.clearedCount > 0 ? <div className="px-2 pb-1"><PaneTextAction onClick={() => restoreCleared("schedule")}>Restore ({scheduleGroups.clearedCount})</PaneTextAction></div> : null}
+              </SectionDisclosure>
             </div>
           ) : null}
+          </SectionDisclosure>
         </section>
       ) : null}
 
@@ -993,8 +1513,10 @@ export function ChatSubagentsPanel({
 
   if (variant === "pane") {
     return (
-      <div className={cn("flex flex-col font-sans", className)}>
-        {body}
+      <div className={cn("flex h-full min-h-0 flex-col font-sans", className)}>
+        <div ref={paneScrollRef} data-testid="chat-subagents-pane-scroll" className="min-h-0 flex-1 overflow-y-auto">
+          {body}
+        </div>
       </div>
     );
   }
diff --git a/apps/desktop/src/shared/chatScheduledWork.test.ts b/apps/desktop/src/shared/chatScheduledWork.test.ts
index 2b0ba9c2b..325c790b6 100644
--- a/apps/desktop/src/shared/chatScheduledWork.test.ts
+++ b/apps/desktop/src/shared/chatScheduledWork.test.ts
@@ -8,6 +8,8 @@ import {
   deriveScheduleHistory,
   deriveScheduleItems,
   deriveScheduledWorkSnapshots,
+  isEarlierBackgroundItem,
+  isEarlierScheduleItem,
   nextCronFireAt,
   scheduledNextFireLabel,
   type ChatScheduledWorkSnapshot,
@@ -35,6 +37,15 @@ function snapshot(overrides: Partial<ChatScheduledWorkSnapshot>): ChatScheduledW
 }
 
 describe("chatScheduledWork helpers", () => {
+  it("uses the shared Earlier membership for background and schedule rows", () => {
+    expect(isEarlierBackgroundItem(snapshot({ kind: "background_task", status: "completed" }))).toBe(true);
+    expect(isEarlierBackgroundItem(snapshot({ kind: "background_task", status: "failed" }))).toBe(false);
+    expect(isEarlierScheduleItem(snapshot({ kind: "wakeup", status: "fired", recurring: false }))).toBe(true);
+    expect(isEarlierScheduleItem(snapshot({ kind: "wakeup", status: "fired", recurring: true }))).toBe(false);
+    expect(isEarlierScheduleItem(snapshot({ kind: "cron", status: "cancelled" }))).toBe(true);
+    expect(isEarlierScheduleItem(snapshot({ kind: "cron", status: "missed" }))).toBe(false);
+  });
+
   it("partitions schedule kinds from background tasks", () => {
     const kinds = ["wakeup", "cron", "loop", "remote_trigger", "background_task"] as const;
     const events = kinds.map((kind, index) => envelope({
diff --git a/apps/desktop/src/shared/chatScheduledWork.ts b/apps/desktop/src/shared/chatScheduledWork.ts
index f0a7948d0..aec85caa6 100644
--- a/apps/desktop/src/shared/chatScheduledWork.ts
+++ b/apps/desktop/src/shared/chatScheduledWork.ts
@@ -130,6 +130,19 @@ export function isFiredOneShotWakeup(snapshot: ChatScheduledWorkSnapshot): boole
     && ONE_SHOT_HISTORY_STATUSES.has(snapshot.status);
 }
 
+export function isEarlierBackgroundItem(snapshot: ChatScheduledWorkSnapshot): boolean {
+  return snapshot.status === "completed"
+    || snapshot.status === "cancelled"
+    || snapshot.status === "stopped";
+}
+
+export function isEarlierScheduleItem(snapshot: ChatScheduledWorkSnapshot): boolean {
+  return isFiredOneShotWakeup(snapshot)
+    || snapshot.status === "completed"
+    || snapshot.status === "cancelled"
+    || snapshot.status === "stopped";
+}
+
 export function deriveScheduleHistory(events: AgentChatEventEnvelope[]): ChatScheduledWorkSnapshot[] {
   return deriveScheduleItems(events).filter(isFiredOneShotWakeup);
 }
diff --git a/apps/desktop/src/shared/chatSubagents.test.ts b/apps/desktop/src/shared/chatSubagents.test.ts
index 9cfb5b642..07cc59c9f 100644
--- a/apps/desktop/src/shared/chatSubagents.test.ts
+++ b/apps/desktop/src/shared/chatSubagents.test.ts
@@ -1,13 +1,82 @@
 import { describe, expect, it } from "vitest";
 import type { AgentChatEvent } from "./types/chat";
 import {
+  buildSubagentPaneRows,
+  groupPaneSectionItems,
+  isEarlierSubagentSnapshot,
   deriveSubagentTimelineRows,
   isBackgroundShellCommand,
   isRealSubagent,
   preferSubagentSummary,
   subagentAgentKey,
+  subagentIndexForPaneLine,
+  type SubagentSnapshot,
 } from "./chatSubagents";
 
+function paneSnapshot(id: string, status: SubagentSnapshot["status"], overrides: Partial<SubagentSnapshot> = {}): SubagentSnapshot {
+  return {
+    id,
+    name: id,
+    kind: "subagent",
+    status,
+    summary: id,
+    ...overrides,
+  };
+}
+
+describe("chat pane scalability helpers", () => {
+  it("partitions in source order while pins override earlier and cleared membership", () => {
+    const running = paneSnapshot("running", "running");
+    const completed = paneSnapshot("completed", "completed");
+    const stopped = paneSnapshot("stopped", "stopped");
+    const failed = paneSnapshot("failed", "failed");
+
+    expect(groupPaneSectionItems([running, completed, stopped, failed], {
+      isEarlier: isEarlierSubagentSnapshot,
+      isCleared: (item) => item.id === "stopped" || item.id === "completed",
+      isPinned: (item) => item.id === "completed",
+    })).toEqual({
+      active: [running, completed, failed],
+      earlier: [],
+      clearedCount: 1,
+    });
+  });
+
+  it("emits grouped disclosure rows with caps, clear state, and tagged targets", () => {
+    const snapshots = Array.from({ length: 14 }, (_, index) => paneSnapshot(`running-${index}`, "running"));
+    snapshots.splice(4, 0, paneSnapshot("failed", "failed"));
+    snapshots.push(paneSnapshot("done", "completed"));
+
+    const rows = buildSubagentPaneRows({ snapshots }, {});
+    expect(rows.find((row) => row.kind === "section-header")).toMatchObject({
+      activeCount: 15,
+      earlierCount: 1,
+      collapsible: true,
+      hasClear: true,
+    });
+    expect(rows.filter((row) => row.kind === "snapshot" && row.group === "active")).toHaveLength(12);
+    expect(rows.find((row) => row.kind === "show-all")).toMatchObject({ hiddenCount: 3 });
+    expect(rows.find((row) => row.kind === "earlier-toggle")).toMatchObject({ count: 1, expanded: false });
+
+    const showAllLine = rows.slice(0, rows.findIndex((row) => row.kind === "show-all"))
+      .reduce((line, row) => line + (row.kind === "section-header" || row.kind === "main" ? 2 : 1), 0);
+    expect(subagentIndexForPaneLine({ snapshots }, showAllLine, 0, {})).toEqual({
+      type: "show-all",
+      section: "subagents",
+    });
+
+    const clearedRows = buildSubagentPaneRows({ snapshots }, {
+      earlierExpanded: { subagents: true },
+      cleared: { subagents: ["done"] },
+    });
+    expect(clearedRows.find((row) => row.kind === "earlier-toggle")).toMatchObject({
+      count: 0,
+      clearedCount: 1,
+    });
+    expect(clearedRows.find((row) => row.kind === "restore-cleared")).toMatchObject({ count: 1 });
+  });
+});
+
 describe("chatSubagents timeline helpers", () => {
   it("normalizes agent keys and prefers meaningful, richer summaries", () => {
     expect(subagentAgentKey({ agentId: "  agent-1  ", taskId: "task-1" })).toBe("agent-1");
diff --git a/apps/desktop/src/shared/chatSubagents.ts b/apps/desktop/src/shared/chatSubagents.ts
index 751fc7379..64c7ce742 100644
--- a/apps/desktop/src/shared/chatSubagents.ts
+++ b/apps/desktop/src/shared/chatSubagents.ts
@@ -56,21 +56,95 @@ export type ChatInfoPlan = {
   live: boolean;
 } | null;
 
+export const SUBAGENTS_ACTIVE_CAP = 12;
+export const BACKGROUND_ACTIVE_CAP = 8;
+export const SCHEDULE_ACTIVE_CAP = 10;
+export const PROGRESS_CAP = 14;
+export const TASKS_CAP = 12;
+export const SUBAGENT_PANE_ROSTER_CAPACITY = 5;
+
+export type PaneSectionKey = "progress" | "tasks" | "subagents" | "background" | "schedule";
+
+export function groupPaneSectionItems<T>(items: T[], opts: {
+  isEarlier: (item: T) => boolean;
+  isCleared: (item: T) => boolean;
+  isPinned: (item: T) => boolean;
+}): { active: T[]; earlier: T[]; clearedCount: number } {
+  const active: T[] = [];
+  const earlier: T[] = [];
+  let clearedCount = 0;
+
+  for (const item of items) {
+    if (opts.isPinned(item)) {
+      active.push(item);
+    } else if (opts.isCleared(item)) {
+      clearedCount += 1;
+    } else if (opts.isEarlier(item)) {
+      earlier.push(item);
+    } else {
+      active.push(item);
+    }
+  }
+
+  return { active, earlier, clearedCount };
+}
+
+export function capPaneSectionItems<T>(
+  items: T[],
+  cap: number,
+  isExempt: (item: T) => boolean,
+): { visible: T[]; hiddenCount: number } {
+  if (items.length <= cap) return { visible: items, hiddenCount: 0 };
+  const visible = items.filter((item, index) => index < cap || isExempt(item));
+  return { visible, hiddenCount: items.length - visible.length };
+}
+
+export function isEarlierSubagentSnapshot(snapshot: Pick<SubagentSnapshot, "status">): boolean {
+  return snapshot.status === "completed" || snapshot.status === "stopped";
+}
+
 export type SubagentPaneSection = "main" | "subagents" | "teammates" | "background";
 
+export type SubagentPaneDisclosureSection = Exclude<SubagentPaneSection, "main">;
+export type SubagentPaneViewSection = SubagentPaneDisclosureSection | "schedule";
+
+export type SubagentPaneViewState = {
+  collapsed?: Partial<Record<SubagentPaneViewSection, boolean>>;
+  earlierExpanded?: Partial<Record<SubagentPaneViewSection, boolean>>;
+  showAll?: Partial<Record<SubagentPaneViewSection, boolean>>;
+  cleared?: Partial<Record<SubagentPaneViewSection, readonly string[] | ReadonlySet<string>>>;
+  pinnedIds?: readonly string[] | ReadonlySet<string>;
+};
+
 export type SubagentPaneRow =
   | { kind: "main"; key: "main"; section: "main"; label: string }
-  | { kind: "snapshot"; key: string; section: Exclude<SubagentPaneSection, "main">; snapshot: SubagentSnapshot };
+  | {
+      kind: "section-header";
+      key: string;
+      section: SubagentPaneDisclosureSection;
+      label: string;
+      activeCount: number;
+      earlierCount: number;
+      clearedCount: number;
+      collapsible: boolean;
+      collapsed: boolean;
+      hasClear: boolean;
+    }
+  | {
+      kind: "snapshot";
+      key: string;
+      section: SubagentPaneDisclosureSection;
+      snapshot: SubagentSnapshot;
+      group?: "active" | "earlier";
+    }
+  | { kind: "earlier-toggle"; key: string; section: SubagentPaneDisclosureSection; count: number; expanded: boolean; clearedCount: number }
+  | { kind: "show-all"; key: string; section: SubagentPaneDisclosureSection; hiddenCount: number }
+  | { kind: "restore-cleared"; key: string; section: SubagentPaneDisclosureSection; count: number };
 
 export type SubagentPaneContent = {
   snapshots: SubagentSnapshot[];
 };
 
-// Vertical offset of the first selectable roster row in the rendered chat-info
-// pane (header + status + plan + goal occupy the preceding lines). Used only by
-// the mouse-click → row mapper.
-const SUBAGENT_PANE_TABLE_START_LINE = 4;
-
 function textField(value: unknown): string | null {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -824,82 +898,238 @@ export function subagentActivitySummaryFromEvents(events: AgentChatEventEnvelope
   return { totalCount: snapshots.size, runningCount };
 }
 
-export function buildSubagentPaneRows(content: SubagentPaneContent): SubagentPaneRow[] {
+export function buildSubagentPaneRows(
+  content: SubagentPaneContent,
+  viewState?: SubagentPaneViewState,
+): SubagentPaneRow[] {
   const foregroundSubagents = content.snapshots.filter((snap) => (
     snap.kind === "subagent"
     && snap.background !== true
   ));
-  const runningWeight = (snap: SubagentSnapshot): number => (snap.status === "running" ? 0 : 1);
-  const sortedForegroundSubagents = [...foregroundSubagents].sort(
-    (left, right) => runningWeight(left) - runningWeight(right),
-  );
   const teammates = content.snapshots.filter((snap) => snap.kind === "teammate");
   const background = content.snapshots.filter((snap) => snap.kind === "subagent" && snap.background === true);
 
-  return [
-    { kind: "main", key: "main", section: "main", label: "main" },
-    ...sortedForegroundSubagents.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "subagents" as const, snapshot })),
-    ...teammates.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "teammates" as const, snapshot })),
-    ...background.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "background" as const, snapshot })),
+  if (!viewState) {
+    const runningWeight = (snap: SubagentSnapshot): number => (snap.status === "running" ? 0 : 1);
+    const sortedForegroundSubagents = [...foregroundSubagents].sort(
+      (left, right) => runningWeight(left) - runningWeight(right),
+    );
+
+    return [
+      { kind: "main", key: "main", section: "main", label: "main" },
+      ...sortedForegroundSubagents.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "subagents" as const, snapshot })),
+      ...teammates.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "teammates" as const, snapshot })),
+      ...background.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "background" as const, snapshot })),
+    ];
+  }
+
+  const rows: SubagentPaneRow[] = [{ kind: "main", key: "main", section: "main", label: "main" }];
+  const pinnedIds = new Set(viewState.pinnedIds ?? []);
+  const sections: Array<{
+    section: SubagentPaneDisclosureSection;
+    label: string;
+    items: SubagentSnapshot[];
+    cap: number;
+    scalable: boolean;
+  }> = [
+    { section: "subagents", label: "SUBAGENTS", items: foregroundSubagents, cap: SUBAGENTS_ACTIVE_CAP, scalable: true },
+    { section: "teammates", label: "TEAMMATES", items: teammates, cap: Number.POSITIVE_INFINITY, scalable: false },
+    { section: "background", label: "BACKGROUND", items: background, cap: BACKGROUND_ACTIVE_CAP, scalable: true },
   ];
+
+  for (const { section, label, items, cap, scalable } of sections) {
+    if (!items.length) continue;
+    const clearedIds = new Set(viewState.cleared?.[section] ?? []);
+    const grouped = scalable
+      ? groupPaneSectionItems(items, {
+          isEarlier: isEarlierSubagentSnapshot,
+          isCleared: (snapshot) => clearedIds.has(snapshot.id),
+          isPinned: (snapshot) => pinnedIds.has(snapshot.id),
+        })
+      : { active: items, earlier: [], clearedCount: 0 };
+    const collapsible = scalable && (grouped.earlier.length > 0 || grouped.active.length > cap);
+    const collapsed = collapsible && viewState.collapsed?.[section] === true;
+    rows.push({
+      kind: "section-header",
+      key: `section:${section}`,
+      section,
+      label,
+      activeCount: grouped.active.length,
+      earlierCount: grouped.earlier.length,
+      clearedCount: grouped.clearedCount,
+      collapsible,
+      collapsed,
+      hasClear: grouped.earlier.length > 0,
+    });
+    if (collapsed) continue;
+
+    const capped = viewState.showAll?.[section]
+      ? { visible: grouped.active, hiddenCount: 0 }
+      : capPaneSectionItems(grouped.active, cap, (snapshot) => (
+          snapshot.status === "failed" || pinnedIds.has(snapshot.id)
+        ));
+    rows.push(...capped.visible.map((snapshot) => ({
+      kind: "snapshot" as const,
+      key: snapshot.id,
+      section,
+      snapshot,
+      group: "active" as const,
+    })));
+    if (capped.hiddenCount > 0) {
+      rows.push({ kind: "show-all", key: `show-all:${section}`, section, hiddenCount: capped.hiddenCount });
+    }
+
+    const earlierExpanded = viewState.earlierExpanded?.[section] === true;
+    if (grouped.earlier.length > 0 || grouped.clearedCount > 0) {
+      rows.push({
+        kind: "earlier-toggle",
+        key: `earlier:${section}`,
+        section,
+        count: grouped.earlier.length,
+        expanded: earlierExpanded,
+        clearedCount: grouped.clearedCount,
+      });
+    }
+    if (earlierExpanded) {
+      rows.push(...grouped.earlier.map((snapshot) => ({
+        kind: "snapshot" as const,
+        key: snapshot.id,
+        section,
+        snapshot,
+        group: "earlier" as const,
+      })));
+      if (grouped.clearedCount > 0) {
+        rows.push({ kind: "restore-cleared", key: `restore:${section}`, section, count: grouped.clearedCount });
+      }
+    } else if (grouped.active.length === 0 && grouped.earlier.length === 0 && grouped.clearedCount > 0) {
+      rows.push({ kind: "restore-cleared", key: `restore:${section}`, section, count: grouped.clearedCount });
+    }
+  }
+
+  return rows;
 }
 
 export function selectedSubagentSnapshot(
   content: SubagentPaneContent,
   selectedIndex: number,
+  viewState?: SubagentPaneViewState,
 ): SubagentSnapshot | null {
-  const row = buildSubagentPaneRows(content)[selectedIndex] ?? null;
+  const row = buildSubagentPaneRows(content, viewState)
+    .filter((candidate) => candidate.kind === "main" || candidate.kind === "snapshot")[selectedIndex] ?? null;
   return row?.kind === "snapshot" ? row.snapshot : null;
 }
 
+function subagentPaneRowLineSpan(row: SubagentPaneRow, selected: boolean): number {
+  if (row.kind === "section-header") return 2;
+  if (row.kind === "main") return 2;
+  if (row.kind === "snapshot") {
+    return selected && (row.snapshot.lastToolName || row.snapshot.summary) ? 2 : 1;
+  }
+  return 1;
+}
+
+export function windowSubagentPaneRows(
+  rows: readonly SubagentPaneRow[],
+  selectedIndex: number,
+  capacity = SUBAGENT_PANE_ROSTER_CAPACITY,
+): { visibleRows: Exclude<SubagentPaneRow, { kind: "main" }>[]; hiddenBefore: number; hiddenAfter: number } {
+  const rosterRows = rows.filter((row): row is Exclude<SubagentPaneRow, { kind: "main" }> => row.kind !== "main");
+  if (rosterRows.length <= capacity) {
+    return { visibleRows: rosterRows, hiddenBefore: 0, hiddenAfter: 0 };
+  }
+  const snapshotRows = rows.filter((row): row is Extract<SubagentPaneRow, { kind: "snapshot" }> => (
+    row.kind === "snapshot"
+  ));
+  const selectedKey = selectedIndex > 0 ? snapshotRows[selectedIndex - 1]?.key : null;
+  const selectedRosterIndex = Math.max(0, rosterRows.findIndex((row) => row.key === selectedKey));
+  const half = Math.floor(capacity / 2);
+  let start = Math.max(0, selectedRosterIndex - half);
+  let end = start + capacity;
+  if (end > rosterRows.length) {
+    end = rosterRows.length;
+    start = end - capacity;
+  }
+  return {
+    visibleRows: rosterRows.slice(start, end),
+    hiddenBefore: start,
+    hiddenAfter: rosterRows.length - end,
+  };
+}
+
 export function subagentPaneSelectableLineOffsets(
   content: SubagentPaneContent,
   selectedIndex = 0,
+  viewState?: SubagentPaneViewState,
 ): number[] {
-  const rows = buildSubagentPaneRows(content);
+  const rows = buildSubagentPaneRows(content, viewState);
   const offsets: number[] = [];
-  let line = SUBAGENT_PANE_TABLE_START_LINE;
-
-  for (let index = 0; index < rows.length; index += 1) {
-    const row = rows[index]!;
-    const previous = rows[index - 1];
-    const showSection = row.section !== "main" && previous?.section !== row.section;
-    if (showSection) line += 2;
-    offsets.push(line);
-    line += 1;
-    const selectedSnapshotHasDetail = row.kind === "snapshot"
-      && index === selectedIndex
-      && (row.snapshot.lastToolName || row.snapshot.summary);
-    if (row.kind === "main" || selectedSnapshotHasDetail) {
-      line += 1;
+  let line = 0;
+  let selectableIndex = 0;
+
+  for (const row of rows) {
+    const selectable = row.kind === "main" || row.kind === "snapshot";
+    const selected = selectable && selectableIndex === selectedIndex;
+    if (selectable) {
+      offsets.push(line);
+      selectableIndex += 1;
     }
+    line += subagentPaneRowLineSpan(row, selected);
   }
 
   return offsets;
 }
 
+export type SubagentPaneTarget =
+  | { type: "snapshot"; index: number }
+  | { type: "toggle-section"; section: SubagentPaneDisclosureSection }
+  | { type: "toggle-earlier"; section: SubagentPaneDisclosureSection }
+  | { type: "show-all"; section: SubagentPaneDisclosureSection }
+  | { type: "restore"; section: SubagentPaneDisclosureSection };
+
 export function subagentIndexForPaneLine(
   content: SubagentPaneContent,
   line: number,
   selectedIndex = 0,
-): number | null {
+  viewState?: SubagentPaneViewState,
+  windowCapacity?: number,
+): SubagentPaneTarget | null {
   if (!Number.isFinite(line)) return null;
-  const offsets = subagentPaneSelectableLineOffsets(content, selectedIndex);
-  if (!offsets.length) return null;
-  const first = offsets[0]!;
-  const last = offsets[offsets.length - 1]!;
-  if (line < first - 1 || line > last + 1) return null;
-
-  let bestIndex = 0;
-  let bestDistance = Number.POSITIVE_INFINITY;
-  for (let index = 0; index < offsets.length; index += 1) {
-    const distance = Math.abs(line - offsets[index]!);
-    if (distance < bestDistance) {
-      bestIndex = index;
-      bestDistance = distance;
+  const rows = buildSubagentPaneRows(content, viewState);
+  const snapshotIndexByKey = new Map(
+    rows
+      .filter((row): row is Extract<SubagentPaneRow, { kind: "snapshot" }> => row.kind === "snapshot")
+      .map((row, index) => [row.key, index + 1]),
+  );
+  const windowed = windowCapacity == null
+    ? { visibleRows: rows.filter((row) => row.kind !== "main"), hiddenBefore: 0, hiddenAfter: 0 }
+    : windowSubagentPaneRows(rows, selectedIndex, windowCapacity);
+  const visibleRows: Array<SubagentPaneRow | null> = [
+    rows.find((row) => row.kind === "main") ?? null,
+    ...(windowed.hiddenBefore > 0 ? [null] : []),
+    ...windowed.visibleRows,
+    ...(windowed.hiddenAfter > 0 ? [null] : []),
+  ];
+  let rowLine = 0;
+  for (const row of visibleRows) {
+    const selectableIndex = row?.kind === "main"
+      ? 0
+      : row?.kind === "snapshot"
+        ? snapshotIndexByKey.get(row.key) ?? -1
+        : -1;
+    const selected = selectableIndex === selectedIndex;
+    const span = row ? subagentPaneRowLineSpan(row, selected) : 1;
+    if (line >= rowLine && line < rowLine + span) {
+      if (!row) return null;
+      if (row.kind === "main" || row.kind === "snapshot") return { type: "snapshot", index: selectableIndex };
+      if (row.kind === "section-header" && row.collapsible) return { type: "toggle-section", section: row.section };
+      if (row.kind === "earlier-toggle") return { type: "toggle-earlier", section: row.section };
+      if (row.kind === "show-all") return { type: "show-all", section: row.section };
+      if (row.kind === "restore-cleared") return { type: "restore", section: row.section };
+      return null;
     }
+    rowLine += span;
   }
-  return bestIndex;
+  return null;
 }
 
 export function isLifecycleEventForSnapshot(event: AgentChatEvent, snapshot: SubagentSnapshot): boolean {
diff --git a/apps/ios/ADE/Models/RemoteModels.swift b/apps/ios/ADE/Models/RemoteModels.swift
index 2e7d362b6..6e3753b7b 100644
--- a/apps/ios/ADE/Models/RemoteModels.swift
+++ b/apps/ios/ADE/Models/RemoteModels.swift
@@ -1935,7 +1935,7 @@ enum AgentChatEvent: Decodable, Equatable {
   case subagentStarted(taskId: String, agentId: String?, agentType: String?, parentAgentId: String?, parentToolUseId: String?, description: String, background: Bool?, label: String?, model: String?, reasoningEffort: String?, turnId: String?)
   case subagentProgress(taskId: String, agentId: String?, agentType: String?, parentAgentId: String?, parentToolUseId: String?, description: String?, summary: String, usage: AgentChatSubagentUsage?, lastToolName: String?, label: String?, model: String?, reasoningEffort: String?, turnId: String?)
   case subagentResult(taskId: String, agentId: String?, agentType: String?, parentAgentId: String?, parentToolUseId: String?, status: AgentChatSubagentStatus, summary: String, usage: AgentChatSubagentUsage?, label: String?, model: String?, reasoningEffort: String?, turnId: String?)
-  case scheduledWorkUpdate(id: String, kind: String, status: String, origin: String?, title: String?, summary: String?, prompt: String?, reason: String?, cron: String?, nextRunAt: String?, lastRunAt: String?, recurring: Bool?, durable: Bool?, sourceToolUseId: String?, sourceTaskId: String?, turnId: String?, error: String?)
+  case scheduledWorkUpdate(id: String, kind: String, status: String, origin: String?, title: String?, summary: String?, prompt: String?, reason: String?, cron: String?, nextRunAt: String?, lastRunAt: String?, firedAt: String?, late: Bool?, recurring: Bool?, durable: Bool?, sourceToolUseId: String?, sourceTaskId: String?, turnId: String?, error: String?)
   case transcriptRetraction(messageIds: [String], reason: String?, replacementMessageId: String?, turnId: String?)
   case structuredQuestion(question: String, options: [AgentChatStructuredQuestionOption]?, itemId: String, turnId: String?)
   case toolUseSummary(summary: String, toolUseIds: [String], turnId: String?)
@@ -2041,6 +2041,8 @@ extension AgentChatEvent {
     case cron
     case nextRunAt
     case lastRunAt
+    case firedAt
+    case late
     case recurring
     case durable
     case sourceToolUseId
@@ -2353,6 +2355,8 @@ extension AgentChatEvent {
         cron: try container.decodeIfPresent(String.self, forKey: .cron),
         nextRunAt: try container.decodeIfPresent(String.self, forKey: .nextRunAt),
         lastRunAt: try container.decodeIfPresent(String.self, forKey: .lastRunAt),
+        firedAt: try container.decodeIfPresent(String.self, forKey: .firedAt),
+        late: try container.decodeIfPresent(Bool.self, forKey: .late),
         recurring: try container.decodeIfPresent(Bool.self, forKey: .recurring),
         durable: try container.decodeIfPresent(Bool.self, forKey: .durable),
         sourceToolUseId: try container.decodeIfPresent(String.self, forKey: .sourceToolUseId),
diff --git a/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift b/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift
index e7ca155bf..0331c1e15 100644
--- a/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift
+++ b/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift
@@ -2555,7 +2555,8 @@ struct WorkChatInfoActivePopup: View {
 
 func workScheduledWorkIsActive(_ item: WorkScheduledWorkSnapshot) -> Bool {
   let status = item.status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
-  return status == "scheduled" || status == "running" || status == "fired"
+  return !workScheduleItemIsEarlier(item)
+    && ["scheduled", "paused", "running", "fired", "failed", "missed"].contains(status)
 }
 
 func workScheduledWorkActiveCount(_ snapshots: [WorkScheduledWorkSnapshot]) -> Int {
@@ -2569,6 +2570,7 @@ func workScheduledWorkActiveCount(_ snapshots: [WorkScheduledWorkSnapshot]) -> I
 /// `deriveScheduleItems` / `deriveBackgroundItems`). Empty sections are hidden;
 /// a shared empty state renders only when all three are empty.
 struct WorkChatInfoDetailsSheet: View {
+  let sessionId: String
   let subagentSnapshots: [WorkSubagentSnapshot]
   let scheduledWorkSnapshots: [WorkScheduledWorkSnapshot]
   let provider: String?
@@ -2576,17 +2578,49 @@ struct WorkChatInfoDetailsSheet: View {
   let probingTaskId: String?
   @Binding var expandedTaskIds: Set<String>
   let onSelect: @MainActor (WorkSubagentSnapshot) async -> Void
+  @AppStorage private var paneUiRaw: String
+  @AppStorage private var paneClearedRaw: String
+  @State private var showAllSections: Set<String> = []
+  @Environment(\.accessibilityReduceMotion) private var reduceMotion
+
+  private let subagentsCap = 12
+  private let backgroundCap = 8
+  private let scheduleCap = 10
+
+  init(
+    sessionId: String,
+    subagentSnapshots: [WorkSubagentSnapshot],
+    scheduledWorkSnapshots: [WorkScheduledWorkSnapshot],
+    provider: String?,
+    selectedTaskId: String?,
+    probingTaskId: String?,
+    expandedTaskIds: Binding<Set<String>>,
+    onSelect: @escaping @MainActor (WorkSubagentSnapshot) async -> Void
+  ) {
+    self.sessionId = sessionId
+    self.subagentSnapshots = subagentSnapshots
+    self.scheduledWorkSnapshots = scheduledWorkSnapshots
+    self.provider = provider
+    self.selectedTaskId = selectedTaskId
+    self.probingTaskId = probingTaskId
+    self._expandedTaskIds = expandedTaskIds
+    self.onSelect = onSelect
+    self._paneUiRaw = AppStorage(
+      wrappedValue: #"{"collapsed":{},"earlier":{}}"#,
+      "ade.chat.paneUi.v1:\(sessionId)"
+    )
+    self._paneClearedRaw = AppStorage(
+      wrappedValue: #"{"subagents":[],"background":[],"schedule":[]}"#,
+      "ade.chat.paneCleared.v1:\(sessionId)"
+    )
+  }
 
   /// Real subagents only (command-shaped historical snapshots are classified
   /// out via the shared background-shell predicate), foreground + background
-  /// merged into one list; running agents sort first.
+  /// merged into one list. Source order is stable; terminal rows move into the
+  /// Earlier partition without reordering survivors.
   private var subagents: [WorkSubagentSnapshot] {
-    let real = workChatInfoSubagents(subagentSnapshots)
-    return real.sorted { lhs, rhs in
-      let lhsWeight = lhs.status == .running ? 0 : 1
-      let rhsWeight = rhs.status == .running ? 0 : 1
-      return lhsWeight < rhsWeight
-    }
+    workChatInfoSubagents(subagentSnapshots)
   }
 
   private var backgroundItems: [WorkScheduledWorkSnapshot] {
@@ -2601,7 +2635,137 @@ struct WorkChatInfoDetailsSheet: View {
     subagents.isEmpty && backgroundItems.isEmpty && scheduleItems.isEmpty
   }
 
+  private func jsonObject(_ raw: String) -> [String: Any] {
+    guard let data = raw.data(using: .utf8),
+          let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+      return [:]
+    }
+    return object
+  }
+
+  private func jsonString(_ object: [String: Any], fallback: String) -> String {
+    guard JSONSerialization.isValidJSONObject(object),
+          let data = try? JSONSerialization.data(withJSONObject: object, options: [.sortedKeys]),
+          let value = String(data: data, encoding: .utf8) else {
+      return fallback
+    }
+    return value
+  }
+
+  private func paneFlag(_ field: String, section: String) -> Bool {
+    let object = jsonObject(paneUiRaw)
+    let values = object[field] as? [String: Any]
+    return values?[section] as? Bool ?? false
+  }
+
+  private func setPaneFlag(_ field: String, section: String, value: Bool) {
+    var object = jsonObject(paneUiRaw)
+    var values = object[field] as? [String: Any] ?? [:]
+    values[section] = value
+    object[field] = values
+    paneUiRaw = jsonString(object, fallback: #"{"collapsed":{},"earlier":{}}"#)
+  }
+
+  private func clearedIds(_ section: String) -> Set<String> {
+    let object = jsonObject(paneClearedRaw)
+    return Set((object[section] as? [String] ?? []).filter { !$0.isEmpty })
+  }
+
+  private func clear(_ section: String, ids: [String]) {
+    var object = jsonObject(paneClearedRaw)
+    let existing = object[section] as? [String] ?? []
+    object[section] = (existing + ids).reduce(into: [String]()) { result, id in
+      if !id.isEmpty, !result.contains(id) { result.append(id) }
+    }
+    for key in ["subagents", "background", "schedule"] where object[key] == nil {
+      object[key] = []
+    }
+    paneClearedRaw = jsonString(object, fallback: #"{"subagents":[],"background":[],"schedule":[]}"#)
+  }
+
+  private func restore(_ section: String) {
+    var object = jsonObject(paneClearedRaw)
+    object[section] = []
+    for key in ["subagents", "background", "schedule"] where object[key] == nil {
+      object[key] = []
+    }
+    paneClearedRaw = jsonString(object, fallback: #"{"subagents":[],"background":[],"schedule":[]}"#)
+  }
+
+  private func withPaneAnimation(_ changes: () -> Void) {
+    withAnimation(reduceMotion ? nil : .easeInOut(duration: 0.18), changes)
+  }
+
+  private func partitionSubagents(_ items: [WorkSubagentSnapshot]) -> (active: [WorkSubagentSnapshot], earlier: [WorkSubagentSnapshot], clearedCount: Int) {
+    let cleared = clearedIds("subagents")
+    let pinned = Set([selectedTaskId].compactMap { $0 }).union(expandedTaskIds)
+    var active: [WorkSubagentSnapshot] = []
+    var earlier: [WorkSubagentSnapshot] = []
+    var clearedCount = 0
+    for item in items {
+      if pinned.contains(item.taskId) {
+        active.append(item)
+      } else if cleared.contains(item.taskId) {
+        clearedCount += 1
+      } else if workSubagentIsEarlier(item) {
+        earlier.append(item)
+      } else {
+        active.append(item)
+      }
+    }
+    return (active, earlier, clearedCount)
+  }
+
+  private func partitionScheduled(
+    _ items: [WorkScheduledWorkSnapshot],
+    section: String,
+    isEarlier: (WorkScheduledWorkSnapshot) -> Bool
+  ) -> (active: [WorkScheduledWorkSnapshot], earlier: [WorkScheduledWorkSnapshot], clearedCount: Int) {
+    let cleared = clearedIds(section)
+    var active: [WorkScheduledWorkSnapshot] = []
+    var earlier: [WorkScheduledWorkSnapshot] = []
+    var clearedCount = 0
+    for item in items {
+      if cleared.contains(item.id) {
+        clearedCount += 1
+      } else if isEarlier(item) {
+        earlier.append(item)
+      } else {
+        active.append(item)
+      }
+    }
+    return (active, earlier, clearedCount)
+  }
+
+  private func capped<T>(_ items: [T], cap: Int, showAll: Bool, isExempt: (T) -> Bool) -> (visible: [T], hiddenCount: Int) {
+    guard !showAll, items.count > cap else { return (items, 0) }
+    let visible = items.enumerated().compactMap { index, item in
+      index < cap || isExempt(item) ? item : nil
+    }
+    return (visible, items.count - visible.count)
+  }
+
+  private func sectionHint(active: Int, earlier: Int, hidden: Int, running: Int, failed: Int) -> String {
+    let activeLabel = running > 0 && failed > 0 ? "\(running) running · \(failed) failed" : "\(active)"
+    return ([activeLabel]
+      + (earlier > 0 ? ["\(earlier) earlier"] : [])
+      + (hidden > 0 ? ["\(hidden) hidden"] : []))
+      .joined(separator: " · ")
+  }
+
   var body: some View {
+    let subagentPartition = partitionSubagents(subagents)
+    let backgroundPartition = partitionScheduled(backgroundItems, section: "background", isEarlier: workBackgroundItemIsEarlier)
+    let schedulePartition = partitionScheduled(scheduleItems, section: "schedule", isEarlier: workScheduleItemIsEarlier)
+    let visibleSubagents = capped(subagentPartition.active, cap: subagentsCap, showAll: showAllSections.contains("subagents")) {
+      $0.status == .failed || selectedTaskId == $0.taskId || expandedTaskIds.contains($0.taskId)
+    }
+    let visibleBackground = capped(backgroundPartition.active, cap: backgroundCap, showAll: showAllSections.contains("background")) {
+      $0.status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == "failed"
+    }
+    let visibleSchedule = capped(schedulePartition.active, cap: scheduleCap, showAll: showAllSections.contains("schedule")) {
+      $0.status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == "failed"
+    }
     NavigationStack {
       ScrollView {
         LazyVStack(alignment: .leading, spacing: 16) {
@@ -2614,29 +2778,100 @@ struct WorkChatInfoDetailsSheet: View {
             .padding(.top, 24)
           } else {
             if !subagents.isEmpty {
-              section(title: "Subagents", count: subagents.count) {
+              section(
+                title: "Subagents",
+                hint: sectionHint(
+                  active: subagentPartition.active.count,
+                  earlier: subagentPartition.earlier.count,
+                  hidden: subagentPartition.clearedCount,
+                  running: subagentPartition.active.count { $0.status == .running },
+                  failed: subagentPartition.active.count { $0.status == .failed }
+                ),
+                key: "subagents",
+                collapsible: !subagentPartition.earlier.isEmpty || subagentPartition.active.count > subagentsCap,
+                clearIds: subagentPartition.earlier.map(\.taskId),
+                clearedCount: subagentPartition.clearedCount,
+                allClear: subagentPartition.active.isEmpty && subagentPartition.earlier.isEmpty && subagentPartition.clearedCount > 0
+              ) {
                 VStack(spacing: 6) {
-                  ForEach(subagents) { snapshot in
+                  if subagentPartition.active.isEmpty && subagentPartition.earlier.isEmpty && subagentPartition.clearedCount > 0 {
+                    allClearRow("Subagents")
+                  }
+                  ForEach(visibleSubagents.visible) { snapshot in
                     subagentRow(snapshot)
                   }
+                  showAllButton(section: "subagents", hiddenCount: visibleSubagents.hiddenCount)
+                  earlierButton(section: "subagents", count: subagentPartition.earlier.count, clearedCount: subagentPartition.clearedCount)
+                  if paneFlag("earlier", section: "subagents") {
+                    ForEach(subagentPartition.earlier) { snapshot in subagentRow(snapshot) }
+                    restoreButton(section: "subagents", count: subagentPartition.clearedCount)
+                  }
                 }
               }
             }
             if !backgroundItems.isEmpty {
-              section(title: "Background", count: backgroundItems.count) {
+              section(
+                title: "Background",
+                hint: sectionHint(
+                  active: backgroundPartition.active.count,
+                  earlier: backgroundPartition.earlier.count,
+                  hidden: backgroundPartition.clearedCount,
+                  running: backgroundPartition.active.count { $0.status.lowercased() == "running" },
+                  failed: backgroundPartition.active.count { $0.status.lowercased() == "failed" }
+                ),
+                key: "background",
+                collapsible: !backgroundPartition.earlier.isEmpty || backgroundPartition.active.count > backgroundCap,
+                clearIds: backgroundPartition.earlier.map(\.id),
+                clearedCount: backgroundPartition.clearedCount,
+                allClear: backgroundPartition.active.isEmpty && backgroundPartition.earlier.isEmpty && backgroundPartition.clearedCount > 0
+              ) {
                 VStack(spacing: 8) {
-                  ForEach(backgroundItems) { item in
+                  if backgroundPartition.active.isEmpty && backgroundPartition.earlier.isEmpty && backgroundPartition.clearedCount > 0 { allClearRow("Background") }
+                  ForEach(visibleBackground.visible) { item in
                     WorkBackgroundWorkRow(item: item)
                   }
+                  showAllButton(section: "background", hiddenCount: visibleBackground.hiddenCount)
+                  earlierButton(section: "background", count: backgroundPartition.earlier.count, clearedCount: backgroundPartition.clearedCount)
+                  if paneFlag("earlier", section: "background") {
+                    ForEach(backgroundPartition.earlier) { item in WorkBackgroundWorkRow(item: item) }
+                    restoreButton(section: "background", count: backgroundPartition.clearedCount)
+                  }
                 }
               }
             }
             if !scheduleItems.isEmpty {
-              section(title: "Schedule", count: scheduleItems.count) {
+              section(
+                title: "Schedule",
+                hint: sectionHint(
+                  active: schedulePartition.active.count,
+                  earlier: schedulePartition.earlier.count,
+                  hidden: schedulePartition.clearedCount,
+                  running: schedulePartition.active.count { $0.status.lowercased() == "running" },
+                  failed: schedulePartition.active.count { $0.status.lowercased() == "failed" }
+                ),
+                key: "schedule",
+                collapsible: !schedulePartition.earlier.isEmpty || schedulePartition.active.count > scheduleCap,
+                clearIds: schedulePartition.earlier.map(\.id),
+                clearedCount: schedulePartition.clearedCount,
+                allClear: schedulePartition.active.isEmpty && schedulePartition.earlier.isEmpty && schedulePartition.clearedCount > 0
+              ) {
                 VStack(spacing: 8) {
-                  ForEach(scheduleItems) { item in
+                  if schedulePartition.active.isEmpty && schedulePartition.earlier.isEmpty && schedulePartition.clearedCount > 0 { allClearRow("Schedule") }
+                  ForEach(visibleSchedule.visible) { item in
                     WorkScheduledWorkRow(item: item)
                   }
+                  showAllButton(section: "schedule", hiddenCount: visibleSchedule.hiddenCount)
+                  earlierButton(section: "schedule", count: schedulePartition.earlier.count, clearedCount: schedulePartition.clearedCount)
+                  if paneFlag("earlier", section: "schedule") {
+                    ForEach(schedulePartition.earlier) { item in
+                      if workScheduleItemIsFiredOneShotWakeup(item) {
+                        WorkScheduledWorkRow(item: item).opacity(0.55).allowsHitTesting(false)
+                      } else {
+                        WorkScheduledWorkRow(item: item)
+                      }
+                    }
+                    restoreButton(section: "schedule", count: schedulePartition.clearedCount)
+                  }
                 }
               }
             }
@@ -2663,21 +2898,105 @@ struct WorkChatInfoDetailsSheet: View {
   }
 
   @ViewBuilder
-  private func section<Content: View>(title: String, count: Int, @ViewBuilder content: () -> Content) -> some View {
+  private func section<Content: View>(
+    title: String,
+    hint: String,
+    key: String,
+    collapsible: Bool,
+    clearIds: [String],
+    clearedCount: Int,
+    allClear: Bool,
+    @ViewBuilder content: () -> Content
+  ) -> some View {
+    let collapsed = collapsible && paneFlag("collapsed", section: key)
     VStack(alignment: .leading, spacing: 8) {
-      HStack {
-        Text(title)
-          .font(.caption.weight(.semibold))
-          .foregroundStyle(ADEColor.textMuted)
-          .textCase(.uppercase)
-        Spacer(minLength: 0)
-        Text("\(count)")
-          .font(.caption2.weight(.semibold))
-          .foregroundStyle(ADEColor.textMuted)
+      HStack(spacing: 8) {
+        if collapsible {
+          Button {
+            withPaneAnimation { setPaneFlag("collapsed", section: key, value: !collapsed) }
+          } label: {
+            HStack(spacing: 6) {
+              Image(systemName: collapsed ? "chevron.right" : "chevron.down")
+                .font(.caption2.bold())
+              Text(title)
+                .font(.caption.weight(.semibold))
+                .textCase(.uppercase)
+              Spacer(minLength: 0)
+              Text(hint).font(.caption2.weight(.semibold))
+            }
+            .foregroundStyle(ADEColor.textMuted)
+            .contentShape(.rect)
+          }
+          .buttonStyle(.plain)
+          .frame(maxWidth: .infinity, minHeight: 44)
+        } else {
+          Text(title)
+            .font(.caption.weight(.semibold))
+            .foregroundStyle(ADEColor.textMuted)
+            .textCase(.uppercase)
+          Spacer(minLength: 0)
+          Text(allClear ? "all clear" : hint)
+            .font(.caption2.weight(.semibold))
+            .foregroundStyle(ADEColor.textMuted)
+        }
+        if allClear {
+          Button("Restore (\(clearedCount))") { restore(key) }
+            .font(.caption)
+            .foregroundStyle(ADEColor.textMuted)
+        } else if !clearIds.isEmpty {
+          Button("Clear") { clear(key, ids: clearIds) }
+            .font(.caption)
+            .foregroundStyle(ADEColor.textMuted)
+        }
       }
-      content()
+      if !collapsed { content() }
     }
   }
+
+  @ViewBuilder
+  private func showAllButton(section: String, hiddenCount: Int) -> some View {
+    if hiddenCount > 0 {
+      Button("Show all (\(hiddenCount))") { showAllSections.insert(section) }
+        .font(.caption)
+        .foregroundStyle(ADEColor.textMuted)
+        .frame(minHeight: 44)
+    }
+  }
+
+  @ViewBuilder
+  private func earlierButton(section: String, count: Int, clearedCount: Int) -> some View {
+    if count > 0 || clearedCount > 0 {
+      let expanded = paneFlag("earlier", section: section)
+      Button {
+        withPaneAnimation { setPaneFlag("earlier", section: section, value: !expanded) }
+      } label: {
+        Label(
+          "Earlier (\(count))\(clearedCount > 0 ? " · \(clearedCount) hidden" : "")",
+          systemImage: expanded ? "chevron.down" : "chevron.right"
+        )
+      }
+      .buttonStyle(.plain)
+      .font(.caption)
+      .foregroundStyle(ADEColor.textMuted)
+      .frame(minHeight: 44)
+    }
+  }
+
+  @ViewBuilder
+  private func restoreButton(section: String, count: Int) -> some View {
+    if count > 0 {
+      Button("Restore (\(count))") { restore(section) }
+        .font(.caption)
+        .foregroundStyle(ADEColor.textMuted)
+        .frame(minHeight: 44)
+    }
+  }
+
+  private func allClearRow(_ title: String) -> some View {
+    Text("\(title) · all clear")
+      .font(.caption)
+      .foregroundStyle(ADEColor.textMuted)
+  }
 }
 
 /// A single subagent roster row inside Chat Info. Reuses the drawer row shape
diff --git a/apps/ios/ADE/Views/Work/WorkErrorAndMessageHelpers.swift b/apps/ios/ADE/Views/Work/WorkErrorAndMessageHelpers.swift
index 00f5a9a1b..0f8479f7d 100644
--- a/apps/ios/ADE/Views/Work/WorkErrorAndMessageHelpers.swift
+++ b/apps/ios/ADE/Views/Work/WorkErrorAndMessageHelpers.swift
@@ -1760,7 +1760,7 @@ func workChatEventMergeKey(_ event: WorkChatEvent) -> String {
     return ["subagent_progress", turnId ?? "", taskId, agentId ?? "", agentType ?? "", parentToolUseId ?? "", description ?? "", summary, toolName ?? "", label ?? "", model ?? "", reasoningEffort ?? ""].joined(separator: "|")
   case .subagentResult(let taskId, let agentId, let agentType, let parentToolUseId, let status, let summary, let label, let model, let reasoningEffort, let turnId):
     return ["subagent_result", turnId ?? "", taskId, agentId ?? "", agentType ?? "", parentToolUseId ?? "", status, summary, label ?? "", model ?? "", reasoningEffort ?? ""].joined(separator: "|")
-  case .scheduledWorkUpdate(let id, let kind, let status, let origin, let title, let summary, let prompt, let reason, let cron, let nextRunAt, let lastRunAt, let recurring, let durable, let sourceToolUseId, let sourceTaskId, let turnId, let error):
+  case .scheduledWorkUpdate(let id, let kind, let status, let origin, let title, let summary, let prompt, let reason, let cron, let nextRunAt, let lastRunAt, let firedAt, let late, let recurring, let durable, let sourceToolUseId, let sourceTaskId, let turnId, let error):
     var parts = ["scheduled_work_update", id, turnId ?? "", kind, status]
     parts.append(origin ?? "")
     parts.append(title ?? "")
@@ -1770,6 +1770,8 @@ func workChatEventMergeKey(_ event: WorkChatEvent) -> String {
     parts.append(cron ?? "")
     parts.append(nextRunAt ?? "")
     parts.append(lastRunAt ?? "")
+    parts.append(firedAt ?? "")
+    parts.append(late.map { $0 ? "1" : "0" } ?? "")
     parts.append(recurring.map { $0 ? "1" : "0" } ?? "")
     parts.append(durable.map { $0 ? "1" : "0" } ?? "")
     parts.append(sourceToolUseId ?? "")
diff --git a/apps/ios/ADE/Views/Work/WorkEventMapping.swift b/apps/ios/ADE/Views/Work/WorkEventMapping.swift
index a8c8038c2..1c94c8384 100644
--- a/apps/ios/ADE/Views/Work/WorkEventMapping.swift
+++ b/apps/ios/ADE/Views/Work/WorkEventMapping.swift
@@ -241,7 +241,7 @@ func makeWorkChatEvent(from event: AgentChatEvent) -> WorkChatEvent {
       reasoningEffort: reasoningEffort,
       turnId: turnId
     )
-  case .scheduledWorkUpdate(let id, let kind, let status, let origin, let title, let summary, let prompt, let reason, let cron, let nextRunAt, let lastRunAt, let recurring, let durable, let sourceToolUseId, let sourceTaskId, let turnId, let error):
+  case .scheduledWorkUpdate(let id, let kind, let status, let origin, let title, let summary, let prompt, let reason, let cron, let nextRunAt, let lastRunAt, let firedAt, let late, let recurring, let durable, let sourceToolUseId, let sourceTaskId, let turnId, let error):
     return .scheduledWorkUpdate(
       id: id,
       kind: kind,
@@ -254,6 +254,8 @@ func makeWorkChatEvent(from event: AgentChatEvent) -> WorkChatEvent {
       cron: cron,
       nextRunAt: nextRunAt,
       lastRunAt: lastRunAt,
+      firedAt: firedAt,
+      late: late,
       recurring: recurring,
       durable: durable,
       sourceToolUseId: sourceToolUseId,
diff --git a/apps/ios/ADE/Views/Work/WorkModels.swift b/apps/ios/ADE/Views/Work/WorkModels.swift
index 3c731aefa..2b53e6d4f 100644
--- a/apps/ios/ADE/Views/Work/WorkModels.swift
+++ b/apps/ios/ADE/Views/Work/WorkModels.swift
@@ -635,6 +635,8 @@ struct WorkScheduledWorkSnapshot: Identifiable, Equatable {
   let cron: String?
   let nextRunAt: String?
   let lastRunAt: String?
+  let firedAt: String?
+  let late: Bool?
   let recurring: Bool?
   let durable: Bool?
   let sourceToolUseId: String?
@@ -880,7 +882,7 @@ enum WorkChatEvent: Equatable {
   case subagentStarted(taskId: String, agentId: String?, agentType: String?, parentToolUseId: String?, description: String, background: Bool, label: String?, model: String?, reasoningEffort: String?, turnId: String?)
   case subagentProgress(taskId: String, agentId: String?, agentType: String?, parentToolUseId: String?, description: String?, summary: String, toolName: String?, label: String?, model: String?, reasoningEffort: String?, turnId: String?)
   case subagentResult(taskId: String, agentId: String?, agentType: String?, parentToolUseId: String?, status: String, summary: String, label: String?, model: String?, reasoningEffort: String?, turnId: String?)
-  case scheduledWorkUpdate(id: String, kind: String, status: String, origin: String?, title: String?, summary: String?, prompt: String?, reason: String?, cron: String?, nextRunAt: String?, lastRunAt: String?, recurring: Bool?, durable: Bool?, sourceToolUseId: String?, sourceTaskId: String?, turnId: String?, error: String?)
+  case scheduledWorkUpdate(id: String, kind: String, status: String, origin: String?, title: String?, summary: String?, prompt: String?, reason: String?, cron: String?, nextRunAt: String?, lastRunAt: String?, firedAt: String?, late: Bool?, recurring: Bool?, durable: Bool?, sourceToolUseId: String?, sourceTaskId: String?, turnId: String?, error: String?)
   case transcriptRetraction(messageIds: [String], reason: String?, replacementMessageId: String?, turnId: String?)
   case structuredQuestion(question: String, options: [WorkPendingQuestionOption], itemId: String, turnId: String?)
   case approvalRequest(description: String, detail: String?, itemId: String, turnId: String?)
diff --git a/apps/ios/ADE/Views/Work/WorkSessionDestinationView.swift b/apps/ios/ADE/Views/Work/WorkSessionDestinationView.swift
index 14aeb079e..cf9431ae3 100644
--- a/apps/ios/ADE/Views/Work/WorkSessionDestinationView.swift
+++ b/apps/ios/ADE/Views/Work/WorkSessionDestinationView.swift
@@ -795,6 +795,7 @@ struct WorkSessionDestinationView: View {
       }
       .sheet(isPresented: $chatInfoPresented) {
         WorkChatInfoDetailsSheet(
+          sessionId: sessionId,
           subagentSnapshots: subagentSnapshots,
           scheduledWorkSnapshots: scheduledWorkSnapshots,
           provider: subagentProvider,
diff --git a/apps/ios/ADE/Views/Work/WorkTimelineHelpers.swift b/apps/ios/ADE/Views/Work/WorkTimelineHelpers.swift
index 4f2d2a10a..ee131b660 100644
--- a/apps/ios/ADE/Views/Work/WorkTimelineHelpers.swift
+++ b/apps/ios/ADE/Views/Work/WorkTimelineHelpers.swift
@@ -206,7 +206,7 @@ private func combineWorkChatEventSignature(_ event: WorkChatEvent, into hasher:
     combineOptionalText(model, into: &hasher)
     combineOptionalText(reasoningEffort, into: &hasher)
     combineOptional(turnId, into: &hasher)
-  case .scheduledWorkUpdate(let id, let kind, let status, let origin, let title, let summary, let prompt, let reason, let cron, let nextRunAt, let lastRunAt, let recurring, let durable, let sourceToolUseId, let sourceTaskId, let turnId, let error):
+  case .scheduledWorkUpdate(let id, let kind, let status, let origin, let title, let summary, let prompt, let reason, let cron, let nextRunAt, let lastRunAt, let firedAt, let late, let recurring, let durable, let sourceToolUseId, let sourceTaskId, let turnId, let error):
     hasher.combine(id)
     hasher.combine(kind)
     hasher.combine(status)
@@ -218,6 +218,8 @@ private func combineWorkChatEventSignature(_ event: WorkChatEvent, into hasher:
     combineOptional(cron, into: &hasher)
     combineOptional(nextRunAt, into: &hasher)
     combineOptional(lastRunAt, into: &hasher)
+    combineOptional(firedAt, into: &hasher)
+    combineOptional(late, into: &hasher)
     combineOptional(recurring, into: &hasher)
     combineOptional(durable, into: &hasher)
     combineOptional(sourceToolUseId, into: &hasher)
@@ -1006,6 +1008,8 @@ func buildWorkScheduledWorkSnapshots(from transcript: [WorkChatEnvelope]) -> [Wo
       let cron,
       let nextRunAt,
       let lastRunAt,
+      let firedAt,
+      let late,
       let recurring,
       let durable,
       let sourceToolUseId,
@@ -1036,6 +1040,8 @@ func buildWorkScheduledWorkSnapshots(from transcript: [WorkChatEnvelope]) -> [Wo
         cron: nonEmptyWorkTimelineText(cron) ?? existing?.snapshot.cron,
         nextRunAt: nonEmptyWorkTimelineText(nextRunAt) ?? existing?.snapshot.nextRunAt,
         lastRunAt: nonEmptyWorkTimelineText(lastRunAt) ?? existing?.snapshot.lastRunAt,
+        firedAt: nonEmptyWorkTimelineText(firedAt) ?? existing?.snapshot.firedAt,
+        late: late ?? existing?.snapshot.late,
         recurring: recurring ?? existing?.snapshot.recurring,
         durable: durable ?? existing?.snapshot.durable,
         sourceToolUseId: nonEmptyWorkTimelineText(sourceToolUseId) ?? existing?.snapshot.sourceToolUseId,
@@ -1118,6 +1124,29 @@ func workChatInfoBackgroundItems(
   }
 }
 
+func workSubagentIsEarlier(_ snapshot: WorkSubagentSnapshot) -> Bool {
+  snapshot.status == .succeeded || snapshot.status == .stopped
+}
+
+func workBackgroundItemIsEarlier(_ snapshot: WorkScheduledWorkSnapshot) -> Bool {
+  let status = snapshot.status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+  return status == "completed" || status == "cancelled" || status == "stopped"
+}
+
+func workScheduleItemIsFiredOneShotWakeup(_ snapshot: WorkScheduledWorkSnapshot) -> Bool {
+  let kind = snapshot.kind.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+  let status = snapshot.status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+  return (kind == "wakeup" || kind == "loop")
+    && snapshot.recurring != true
+    && (status == "fired" || status == "completed")
+}
+
+func workScheduleItemIsEarlier(_ snapshot: WorkScheduledWorkSnapshot) -> Bool {
+  if workScheduleItemIsFiredOneShotWakeup(snapshot) { return true }
+  let status = snapshot.status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+  return status == "completed" || status == "cancelled" || status == "stopped"
+}
+
 func workChatInfoSubagents(
   _ snapshots: [WorkSubagentSnapshot]
 ) -> [WorkSubagentSnapshot] {
@@ -2491,7 +2520,7 @@ private func eventCard(
       // badge, and the Subagents drawer. Rendering every lifecycle envelope as
       // a normal event card makes mobile chats look much longer than desktop.
       return nil
-    case .scheduledWorkUpdate(_, let kind, let status, _, let title, let summary, let prompt, let reason, let cron, let nextRunAt, _, _, _, _, _, let turnId, let error):
+    case .scheduledWorkUpdate(_, let kind, let status, _, let title, let summary, let prompt, let reason, let cron, let nextRunAt, _, _, _, _, _, _, _, let turnId, let error):
       // Background shell commands are owned by the Chat Info pane's Background
       // section (and a compact timeline finish chip). Mirrors desktop, which
       // stops rendering an inline scheduled-work card for background_task.
@@ -2873,7 +2902,7 @@ private func workTurnId(for event: WorkChatEvent) -> String? {
        .subagentStarted(_, _, _, _, _, _, _, _, _, let turnId),
        .subagentProgress(_, _, _, _, _, _, _, _, _, _, let turnId),
        .subagentResult(_, _, _, _, _, _, _, _, _, let turnId),
-       .scheduledWorkUpdate(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, let turnId, _),
+       .scheduledWorkUpdate(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, let turnId, _),
        .transcriptRetraction(_, _, _, let turnId),
        .structuredQuestion(_, _, _, let turnId),
        .approvalRequest(_, _, _, let turnId),
diff --git a/apps/ios/ADE/Views/Work/WorkTranscriptParser.swift b/apps/ios/ADE/Views/Work/WorkTranscriptParser.swift
index 0b5cc8310..9b356530e 100644
--- a/apps/ios/ADE/Views/Work/WorkTranscriptParser.swift
+++ b/apps/ios/ADE/Views/Work/WorkTranscriptParser.swift
@@ -247,6 +247,8 @@ func parseWorkChatTranscript(_ raw: String) -> [WorkChatEnvelope] {
           cron: optionalString(eventDict["cron"]),
           nextRunAt: optionalString(eventDict["nextRunAt"]),
           lastRunAt: optionalString(eventDict["lastRunAt"]),
+          firedAt: optionalString(eventDict["firedAt"]),
+          late: workBoolValue(eventDict["late"]),
           recurring: workBoolValue(eventDict["recurring"]),
           durable: workBoolValue(eventDict["durable"]),
           sourceToolUseId: optionalString(eventDict["sourceToolUseId"]),
diff --git a/apps/ios/ADETests/ADETests.swift b/apps/ios/ADETests/ADETests.swift
index aef8d9edb..32f25c1ca 100644
--- a/apps/ios/ADETests/ADETests.swift
+++ b/apps/ios/ADETests/ADETests.swift
@@ -9741,9 +9741,8 @@ final class ADETests: XCTestCase {
 
   /// Durable-wakeup parity (desktop 93d7f889): the host now emits `paused`,
   /// `fired`, and `late` on scheduled_work_update. iOS carries `status` as a raw
-  /// String, so new/unknown statuses must decode without crashing and must not
-  /// be treated as active. Extra host fields (`firedAt`, `late`) that iOS does
-  /// not model must be ignored, not fatal.
+  /// String, so new/unknown statuses must decode without crashing. Host
+  /// `firedAt` / `late` fields are retained for the Earlier history row.
   func testParseWorkChatTranscriptToleratesPausedAndUnknownScheduleStatuses() {
     let raw = """
     {"sessionId":"chat-1","timestamp":"2026-07-08T00:00:01.000Z","sequence":1,"event":{"type":"scheduled_work_update","id":"cron-1","kind":"cron","status":"paused","origin":"schedule_cron","title":"Nightly checks","cron":"0 9 * * *","turnId":"turn-1"}}
@@ -9763,20 +9762,23 @@ final class ADETests: XCTestCase {
     )
     XCTAssertEqual(byId["cron-1"]?.status, "paused")
     XCTAssertEqual(byId["wakeup-2"]?.status, "fired")
+    XCTAssertEqual(byId["wakeup-2"]?.firedAt, "2026-07-08T00:00:02.000Z")
+    XCTAssertEqual(byId["wakeup-2"]?.late, true)
     XCTAssertEqual(byId["future-1"]?.status, "totally_new_status")
 
-    // Paused schedules are dormant, not active — they must not inflate the
-    // Chat Info active badge count.
+    // Paused schedules stay in the active partition but read dormant in UI.
     XCTAssertTrue(workScheduledWorkIsPaused("paused"))
     XCTAssertFalse(workScheduledWorkIsPaused("scheduled"))
     if let paused = byId["cron-1"] {
-      XCTAssertFalse(workScheduledWorkIsActive(paused))
+      XCTAssertTrue(workScheduledWorkIsActive(paused))
     } else {
       XCTFail("Expected paused snapshot")
     }
-    // `fired` still counts as active (an in-flight wakeup turn).
+    // Fired one-shot wakeups move to Earlier, while recurring fires stay active.
     if let fired = byId["wakeup-2"] {
-      XCTAssertTrue(workScheduledWorkIsActive(fired))
+      XCTAssertTrue(workScheduleItemIsFiredOneShotWakeup(fired))
+      XCTAssertTrue(workScheduleItemIsEarlier(fired))
+      XCTAssertFalse(workScheduledWorkIsActive(fired))
     } else {
       XCTFail("Expected fired snapshot")
     }
@@ -9787,6 +9789,24 @@ final class ADETests: XCTestCase {
     XCTAssertEqual(Set(scheduleItems.map(\.id)), ["cron-1", "wakeup-2", "future-1"])
   }
 
+  func testChatInfoEarlierMembershipMatchesDesktopPredicates() throws {
+    let raw = """
+    {"sessionId":"chat-1","timestamp":"2026-07-08T00:00:01.000Z","sequence":1,"event":{"type":"scheduled_work_update","id":"bg-done","kind":"background_task","status":"completed","title":"Done"}}
+    {"sessionId":"chat-1","timestamp":"2026-07-08T00:00:02.000Z","sequence":2,"event":{"type":"scheduled_work_update","id":"bg-failed","kind":"background_task","status":"failed","title":"Failed"}}
+    {"sessionId":"chat-1","timestamp":"2026-07-08T00:00:03.000Z","sequence":3,"event":{"type":"scheduled_work_update","id":"wake-one","kind":"wakeup","status":"fired","recurring":false,"title":"One shot"}}
+    {"sessionId":"chat-1","timestamp":"2026-07-08T00:00:04.000Z","sequence":4,"event":{"type":"scheduled_work_update","id":"wake-recurring","kind":"wakeup","status":"fired","recurring":true,"title":"Recurring"}}
+    {"sessionId":"chat-1","timestamp":"2026-07-08T00:00:05.000Z","sequence":5,"event":{"type":"scheduled_work_update","id":"cron-cancelled","kind":"cron","status":"cancelled","title":"Cancelled"}}
+    """
+    let snapshots = buildWorkScheduledWorkSnapshots(from: parseWorkChatTranscript(raw))
+    let byId = Dictionary(uniqueKeysWithValues: snapshots.map { ($0.id, $0) })
+
+    XCTAssertTrue(workBackgroundItemIsEarlier(try XCTUnwrap(byId["bg-done"])))
+    XCTAssertFalse(workBackgroundItemIsEarlier(try XCTUnwrap(byId["bg-failed"])))
+    XCTAssertTrue(workScheduleItemIsEarlier(try XCTUnwrap(byId["wake-one"])))
+    XCTAssertFalse(workScheduleItemIsEarlier(try XCTUnwrap(byId["wake-recurring"])))
+    XCTAssertTrue(workScheduleItemIsEarlier(try XCTUnwrap(byId["cron-cancelled"])))
+  }
+
   func testWorkTimelineKeepsSubagentsOutOfMainActivityBundles() {
     // The two activity updates are consecutive so they cluster into one bundle;
     // the real subagent's spawn row is a hard timeline boundary that sits
diff --git a/docs/features/chat/README.md b/docs/features/chat/README.md
index 2c30c41e3..d1bcfb57d 100644
--- a/docs/features/chat/README.md
+++ b/docs/features/chat/README.md
@@ -59,8 +59,8 @@ for its separate RPC, sync, storage, and UI contracts.
 | `apps/desktop/src/main/services/opencode/openCodeBinaryManager.ts` | Resolves the OpenCode CLI: PATH first, then the bundled `node_modules/.bin/opencode`. Cache entries are re-validated with `canRunBinaryCandidate` on every lookup so user installs after launch are picked up; missing-binary lookups are intentionally not cached. `clearOpenCodeBinaryCache()` is wired into the AI integration's full cache reset. |
 | `apps/desktop/src/main/services/opencode/openCodeInventory.ts` | OpenCode provider/model probe. Now classifies model variants into `reasoningTiers` + `serviceTiers` (alias map covering `minimal`/`mini`/`med`/`xhigh`/`extra-high`), reads `capabilities` (tools/vision/reasoning) into descriptor capabilities, and tracks both `modelIds` (connected providers only) and `catalogModelIds` (the full browseable catalog). Anthropic rows normalize retired Sonnet 4.6 / basic Opus 4.7 ids to Sonnet 5 / Opus 4.8 so runtime catalogs cannot reintroduce removed picker rows. `OpenCodeProviderInfo.availableModelCount` exposes the connected count separately from `modelCount`. |
 | `apps/desktop/src/shared/chatTranscript.ts` | Pure JSON-lines parser for `AgentChatEventEnvelope` values. Used by both the main process and the renderer. |
-| `apps/desktop/src/shared/chatSubagents.ts` | Cross-target subagent helpers: `normalizeSubagentLifecycleEvent` (canonicalizes legacy `subagent_*` and dotted `subagent.*` envelopes), `buildSubagentPaneRows`, `selectedSubagentSnapshot`, `subagentIndexForPaneLine`, `subagentPaneSelectableLineOffsets`, `buildSubagentTranscriptEvents`, `isLifecycleEventForSnapshot`, plus the `latestPlan` derivation. It also owns the shared subagent-vs-background classification (`isBackgroundShellCommand`, `isRealSubagent`, `subagentAgentKey`), summary-quality helpers (`preferSubagentSummary`, `longerSubagentText`, `preferredSubagentAgentType`, `SUBAGENT_PLACEHOLDER_SUMMARY`), and `deriveSubagentTimelineRows` → `SubagentTimelineRow` (`spawn` / `result` / `background_chip`), the inline transcript timeline that desktop `SubagentActivityCards` and iOS `buildWorkSubagentTimelineRows` both mirror. Both the desktop `ChatSubagentsPanel` and the `apps/ade-cli/src/tuiClient/subagentPane.ts` / `chatInfo.ts` modules re-export from here so the desktop pane and the terminal TUI render the same roster, transcript filter, and plan summary. |
-| `apps/desktop/src/shared/chatScheduledWork.ts` | Cross-target scheduled-work derivation. Folds `scheduled_work_update` envelopes into stable snapshots for Claude wakeups, cron tasks, `/loop`, remote triggers, and background work, then partitions them by surface: `deriveScheduleItems` / `deriveActiveScheduleItems` / `deriveScheduleHistory` return the schedule kinds (`wakeup` / `cron` / `loop` / `remote_trigger`) for the Schedule block, while `deriveBackgroundItems` returns `background_task` rows for a separate Background block. Also owns next-fire labels (`scheduledNextFireLabel`, `compactRelativeDuration`, `nextCronFireAt`) and the `backgroundCommandLabel` / `backgroundCommandCwd` helpers that turn a wrapped background shell command into a readable `$ <label>` row. Consumed by desktop Chat Info, ADE Code Chat Info, and iOS Work chat so scheduled/background activity presents consistently. |
+| `apps/desktop/src/shared/chatSubagents.ts` | Cross-target subagent helpers: `normalizeSubagentLifecycleEvent` (canonicalizes legacy `subagent_*` and dotted `subagent.*` envelopes), the stable `groupPaneSectionItems` partition and pane caps, `buildSubagentPaneRows`, tagged pane click targets, `buildSubagentTranscriptEvents`, `isLifecycleEventForSnapshot`, plus the `latestPlan` derivation. The partition keeps source order, forces pinned rows into the active cap, and excludes visually cleared Earlier ids. It also owns the shared subagent-vs-background classification (`isBackgroundShellCommand`, `isRealSubagent`, `subagentAgentKey`), summary-quality helpers, and `deriveSubagentTimelineRows` → `SubagentTimelineRow` (`spawn` / `result` / `background_chip`). Desktop consumes the partition directly; ADE Code consumes the expanded row model; iOS mirrors the same predicates and caps. |
+| `apps/desktop/src/shared/chatScheduledWork.ts` | Cross-target scheduled-work derivation. Folds `scheduled_work_update` envelopes into stable snapshots for Claude wakeups, cron tasks, `/loop`, remote triggers, and background work, then partitions them by surface: `deriveScheduleItems` returns the schedule kinds (`wakeup` / `cron` / `loop` / `remote_trigger`) while `deriveBackgroundItems` returns `background_task` rows. `isEarlierBackgroundItem`, `isFiredOneShotWakeup`, and `isEarlierScheduleItem` define the shared Earlier membership mirrored by ADE Code and iOS; the older active/history helpers remain available to existing callers. Also owns next-fire labels and readable background command labels/cwds. |
 | `apps/desktop/src/main/services/chat/claudeWorkflowProgress.ts` | Defensive normalizer for the Claude Agent SDK's undocumented `workflow_progress` snapshot on `system:task_progress` (Workflow orchestration runs). Parses phases + per-agent entries (caps counts, clips previews, drops malformed entries, unknown states degrade to queued/running; unparseable snapshots return undefined so the generic task rendering is untouched), then `planClaudeWorkflowAgentTransitions` diffs each cumulative tick against per-task emit state to fan out `subagent_started/progress/result` events under a stable `<taskId>::a<index>` identity with the emitted agentId latched at first emission. Consumed by `agentChatService`'s `task_progress`/`task_notification` handlers and the interrupt path (which close still-running agents as `stopped`). |
 | `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. |
@@ -79,7 +79,7 @@ for its separate RPC, sync, storage, and UI contracts.
 | `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. |
 | `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 app-server `thread/rollback` plus ADE's git-backed file restore plan. `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, latest plan, `todo_update` tasks, scheduled work, and subagent/background rosters. The Schedule header exposes the chat-level pause/play control; paused rows dim in place, recurring rows show last-run plus next-fire timing, and fired one-shot wakeups move into a collapsed History group. `chatSubagentIdentity.tsx` centralizes deterministic subagent display names, colours, and identicon glyphs so the drawer roster and the inline transcript spawn/result cards render the same agent identity. The goal card sits above the plan/subagent roster, exposes edit/status/clear affordances through typed ADE goal APIs, and shows usage context as tokens/time only; provider token budgets are hidden and cleared so ADE goals stay unlimited. |
+| `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. Terminal work moves into one Earlier disclosure without reordering survivors; failed and pinned rows stay active; Clear hides only terminal Earlier rows and Restore reverses it. Per-session collapse/Earlier/cleared state persists in normalized renderer storage while Show all remains mount-local. The pane variant owns one scroll container with sticky opaque section headers. Schedule pause/play remains beside Clear, recurring rows show last-run plus next-fire timing, and fired one-shot wakeups keep their dim history-row treatment inside Earlier. ADE Code and iOS mirror the grouping and cap behavior. `chatSubagentIdentity.tsx` centralizes deterministic subagent identity, and the Codex goal card stays above the roster. |
 | `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`. 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. |
diff --git a/docs/features/chat/composer-and-ui.md b/docs/features/chat/composer-and-ui.md
index 989ddb2e3..7b06d277f 100644
--- a/docs/features/chat/composer-and-ui.md
+++ b/docs/features/chat/composer-and-ui.md
@@ -15,7 +15,7 @@ subagents, computer use). The pane derives all visible state from the
 | `apps/desktop/src/renderer/components/usage/UsageActivityCarousel.tsx` | Cross-client activity, token, code-movement, and client-mix charts. `AgentChatPane` mounts `WorkUsageActivityCarousel` beneath the empty Work draft composer when no app panel is open; the component persists the chosen chart and day/week/month/year range. |
 | `apps/desktop/src/renderer/lib/draftLaunchJobs.ts` | Pure helper for Work draft-launch job DTOs, terminal/stale-state detection, and pruning. The list keeps active rows ahead of terminal rows, fills remaining retained slots with terminal rows, and keeps at least one terminal row alongside active jobs. Also owns the durability constants/helpers: `DRAFT_LAUNCH_TIMEOUT_MS` (90 s) + `withDraftLaunchTimeout` (fails a step whose runtime call never settles; the underlying IPC is not cancellable, so it keeps running detached and the timeout only unwedges the renderer-side job) and `LAUNCH_PROJECT_CHANGED_MESSAGE` (the legacy/unpinned abort error used only when no originating project binding is available and the active project drifts mid-launch). |
 | `apps/desktop/src/renderer/lib/handoffLaunchJobs.ts` | Pure helper for handoff placeholder DTOs, scope keys, stable placeholder ids, status labels, and search matching. `AgentChatPane` writes these jobs into the root store while `TerminalsPage` passes matching jobs into the Work session sidebar. The handoff drawer can offer a brief summarized handoff or a full-history fork when source and target stay within Claude or within Codex; Codex forks use the app-server thread id returned by `thread/fork`. |
-| `AgentChatMessageList.tsx` | Virtualized message list (`@tanstack/react-virtual`). Renders transcript rows and turn dividers, including a `Woke on schedule` divider before every synthetic scheduled turn and inline `SubagentSpawnCard` / `SubagentResultCard` / `BackgroundFinishChip` rows (from `SubagentActivityCards.tsx`) for real subagents and backgrounded shell commands, and accepts stable row-key jump requests from the while-you-were-away strip and the spawn/result jump affordances. Keeps sticky-bottom sessions pinned across streamed row growth and late virtual-height measurements. Plan-approval rows with non-empty body text render a scrollable markdown block (capped at `360px`) beneath the header so the user can review plan content inline. Codex goal lifecycle rows use user-facing text such as `Goal set`, `Goal paused`, and `Goal cleared`. A stalled Codex turn renders a clickable Wait / Nudge / Retry / Resume recovery card wired to `agentChat.recoverCodexTurn`. User messages marked `metadata.hideFullPrompt` render and copy only their `displayText`, keeping internal handoff briefs out of the visible transcript details. |
+| `AgentChatMessageList.tsx` | Virtualized message list (`@tanstack/react-virtual`). Renders transcript rows and turn dividers, including a `Woke on schedule` divider before every synthetic scheduled turn and inline `SubagentSpawnCard` / `SubagentResultCard` / `BackgroundFinishChip` rows (from `SubagentActivityCards.tsx`) for real subagents and backgrounded shell commands, and accepts stable row-key jump requests from the while-you-were-away strip and the spawn/result jump affordances. Keeps sticky-bottom sessions pinned across streamed row growth and late virtual-height measurements. The last text block of a multi-block assistant turn exposes Copy turn, which joins only that turn's assistant text blocks with blank lines; legacy rows without a turn id and single-block turns keep only the normal block copy. Plan-approval rows with non-empty body text render a scrollable markdown block (capped at `360px`) beneath the header so the user can review plan content inline. Codex goal lifecycle rows use user-facing text such as `Goal set`, `Goal paused`, and `Goal cleared`. A stalled Codex turn renders a clickable Wait / Nudge / Retry / Resume recovery card wired to `agentChat.recoverCodexTurn`. User messages marked `metadata.hideFullPrompt` render and copy only their `displayText`, keeping internal handoff briefs out of the visible transcript details. |
 | `AgentChatComposer.tsx` | Text input, attachments, model selector, compact title-only permission controls, slash commands, pending-input answering (including Codex MCP form/URL elicitations), voice-dictation target registration, and parallel model-slot controls. Launch-prompt clipboard reminder text is controlled by `launchPromptClipboardNoticeEnabled`, separate from the `launchPromptClipboardEnabled` copy behavior. For orchestration model-selection pending inputs it decodes the agent briefing metadata (`workDescription`, `filesHint`, `dependsOn`) before rendering the selection card. |
 | `ChatActionsDrawerPanel.tsx`, `ChatSourcesPanel.tsx`, `chatSources.ts` | Chat Actions tab shell plus Codex Sources view. The source derivation deduplicates files, web queries/results, MCP apps/tools, and external resource URLs from transcript events; safe web rows open in ADE's browser. |
 | `VoiceDictationButton.tsx`, `apps/desktop/src/renderer/services/globalVoiceRecorder.ts`, `apps/desktop/src/renderer/components/voice/*` | Desktop dictation UI and recorder. The module-level recorder owns mic capture across navigation, writes live state to the root app store, transcribes via `window.ade.transcription`, inserts cleaned text into the registered composer, and always copies the cleaned transcript to the clipboard. The header indicator and composer pill render the same recording state. |
@@ -27,10 +27,10 @@ subagents, computer use). The pane derives all visible state from the
 | `ChatCommandMenu.tsx` | Popover for slash commands and `@`-prefixed file search. Consumes a `ComposerTrigger` from `shared/composerTriggers.ts` (so the menu opens for a mid-draft trigger, not just a leading one), debounces file search at 40 ms, and keeps a per-menu-session query cache (`QUERY_CACHE_MAX = 40`) so cached queries render same-frame while a background revalidation still runs; the cache clears when the menu closes. |
 | `apps/desktop/src/shared/composerTriggers.ts` | Cursor-relative typed-trigger detection shared by the desktop chat composer (rich + textarea), the `WorkViewArea` continue composer, and the ade-code TUI (iOS mirrors the same regexes in Swift). `detectComposerTrigger(text, cursorPos)` finds an in-progress `/command` / `@file` token ending at the cursor at any position; `replaceComposerTriggerSpan` splices exactly that span; `findConfirmedComposerTokens` locates confirmed chip tokens for overlay/prompt styling; `composerTriggerSpansWholeDraft` distinguishes a lone leading command from a mid-sentence one. |
 | `ChatTasksPanel.tsx` | Todo list rendered from `todo_update` events. |
-| `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; partitions active rows from fired one-shot history; and formats next-fire labels. Shared by desktop, ADE Code, and iOS. |
+| `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. 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 uses `thread/rollback` for the latest user message and restores files through ADE's git plan. |
-| `ChatSubagentsPanel.tsx`, `ChatSubagentStrip.tsx` | Chat Info panels. They render the Codex goal card, latest plan, tasks, schedule, and subagent/background rosters. The Schedule header owns the per-chat pause/play action; active rows dim and read `paused` while paused, cron rows combine last-run and next-fire timing, and fired one-shot wakeups live in a collapsed History group. For Codex sessions the goal card stays above plan/subagent progress so the current objective stays visible without crowding the chat header. |
+| `ChatSubagentsPanel.tsx`, `ChatSubagentStrip.tsx` | Chat Info panels. They render the Codex goal card, latest plan, tasks, schedule, and subagent/background rosters. Large sections cap active rows and add Show all; terminal rows move into one Earlier 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 beside Clear. 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). |
@@ -555,8 +555,17 @@ state. The desktop Schedule header calls the typed
 `agentChat.setScheduledWorkPaused` API for the owning chat. While paused,
 active schedule rows remain visible but dim and show `paused`; on resume,
 overdue work fires once. Cron rows show `last ran <time> · next <relative>`.
-Completed one-shot wakeups leave the active list and appear in a collapsed
-`History (N)` group with their fired time and optional `late` marker.
+Large Chat Info rosters use the shared stable partition in
+`shared/chatSubagents.ts`: Subagents cap at 12 active rows, Background at 8,
+Schedule at 10, Progress at 14, and Tasks at 12. Terminal rows move into a
+single `Earlier (N)` disclosure without sorting either group; failed and
+pinned rows remain active and cap-exempt. Clear only hides clearable terminal
+ids, Restore brings them back, collapse/Earlier/clear state is scoped to the
+chat session, and Show all resets when the surface remounts. Small sections
+retain the original static header without disclosure chrome. Fired one-shot
+wakeups keep their fired time and optional `late` marker in the dim Earlier
+row. ADE Code mirrors the grouped row model in-memory, while iOS mirrors the
+same predicates, caps, persistence semantics, and fired/late decoding.
 
 Desktop renders those rows in the Chat Info drawer, ADE Code renders them
 in the Chat Info right pane, and iOS shows a Chat Info popup/sheet for

From 2417bf1e4f6f2dc50117866d55a1d571bc845fad Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Fri, 10 Jul 2026 04:41:31 -0400
Subject: [PATCH 4/9] fix(tui): restore roster mouse-map baseline and near-miss
 snapping

The grouped-row rewrite moved the pane line mapper's origin from the
calibrated preamble baseline (4) to 0 while app.tsx's subagentPaneTop
formula stayed unchanged, shifting every roster click up by four lines,
and its exact-span matching dead-dropped near misses the old mapper
snapped to the nearest row. Reinstate SUBAGENT_PANE_TABLE_START_LINE as
the shared origin and add a nearest-interactive-row fallback for clicks
inside non-interactive spans or one line off the roster bounds.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../tuiClient/__tests__/subagentPane.test.ts  | 19 ++++++-
 apps/desktop/src/shared/chatSubagents.test.ts |  4 +-
 apps/desktop/src/shared/chatSubagents.ts      | 55 +++++++++++++++----
 3 files changed, 65 insertions(+), 13 deletions(-)

diff --git a/apps/ade-cli/src/tuiClient/__tests__/subagentPane.test.ts b/apps/ade-cli/src/tuiClient/__tests__/subagentPane.test.ts
index b01bca958..a38eb4375 100644
--- a/apps/ade-cli/src/tuiClient/__tests__/subagentPane.test.ts
+++ b/apps/ade-cli/src/tuiClient/__tests__/subagentPane.test.ts
@@ -92,9 +92,24 @@ describe("subagent pane helpers", () => {
   });
 
   it("only accounts for detail lines on the selected subagent row", () => {
+    // Offsets are anchored at the calibrated preamble baseline (4) that
+    // app.tsx's subagentPaneTop formula assumes — see
+    // SUBAGENT_PANE_TABLE_START_LINE in shared/chatSubagents.ts.
     const content = rosterPaneContent();
-    expect(subagentPaneSelectableLineOffsets(content, 1)).toEqual([0, 2, 4, 5, 6]);
-    expect(subagentPaneSelectableLineOffsets(content, 2)).toEqual([0, 2, 3, 5, 6]);
+    expect(subagentPaneSelectableLineOffsets(content, 1)).toEqual([4, 6, 8, 9, 10]);
+    expect(subagentPaneSelectableLineOffsets(content, 2)).toEqual([4, 6, 7, 9, 10]);
+  });
+
+  it("snaps near-miss clicks to the nearest interactive row", () => {
+    const content = rosterPaneContent();
+    const offsets = subagentPaneSelectableLineOffsets(content, 1);
+    // One line above/below a row (inside a non-interactive span or gap) still
+    // resolves — the TUI's constant paneTop drifts when variable blocks render
+    // above the roster, and dead-dropping every near miss made clicks brittle.
+    expect(subagentIndexForPaneLine(content, offsets[0]! + 1, 1)).toEqual({ type: "snapshot", index: 0 });
+    // Far outside the roster stays null.
+    expect(subagentIndexForPaneLine(content, 0, 1)).toBeNull();
+    expect(subagentIndexForPaneLine(content, offsets[4]! + 4, 1)).toBeNull();
   });
 
   it("emits grouped section, show-all, Earlier, and tagged action rows", () => {
diff --git a/apps/desktop/src/shared/chatSubagents.test.ts b/apps/desktop/src/shared/chatSubagents.test.ts
index 07cc59c9f..80a7ab5c2 100644
--- a/apps/desktop/src/shared/chatSubagents.test.ts
+++ b/apps/desktop/src/shared/chatSubagents.test.ts
@@ -58,8 +58,10 @@ describe("chat pane scalability helpers", () => {
     expect(rows.find((row) => row.kind === "show-all")).toMatchObject({ hiddenCount: 3 });
     expect(rows.find((row) => row.kind === "earlier-toggle")).toMatchObject({ count: 1, expanded: false });
 
+    // Lines are anchored at the calibrated TUI preamble baseline (4) — see
+    // SUBAGENT_PANE_TABLE_START_LINE in chatSubagents.ts.
     const showAllLine = rows.slice(0, rows.findIndex((row) => row.kind === "show-all"))
-      .reduce((line, row) => line + (row.kind === "section-header" || row.kind === "main" ? 2 : 1), 0);
+      .reduce((line, row) => line + (row.kind === "section-header" || row.kind === "main" ? 2 : 1), 4);
     expect(subagentIndexForPaneLine({ snapshots }, showAllLine, 0, {})).toEqual({
       type: "show-all",
       section: "subagents",
diff --git a/apps/desktop/src/shared/chatSubagents.ts b/apps/desktop/src/shared/chatSubagents.ts
index 64c7ce742..5896caa2f 100644
--- a/apps/desktop/src/shared/chatSubagents.ts
+++ b/apps/desktop/src/shared/chatSubagents.ts
@@ -1019,6 +1019,13 @@ export function selectedSubagentSnapshot(
   return row?.kind === "snapshot" ? row.snapshot : null;
 }
 
+// Calibrated preamble offset the ade-code TUI mouse mapper assumes. The caller
+// passes `mouse.y - subagentPaneTop`, and app.tsx's subagentPaneTop formula was
+// tuned against this baseline (the CHATS head + chat-info preamble rows that
+// render above the "main" row). Changing one side without the other shifts
+// every roster click by the same amount.
+const SUBAGENT_PANE_TABLE_START_LINE = 4;
+
 function subagentPaneRowLineSpan(row: SubagentPaneRow, selected: boolean): number {
   if (row.kind === "section-header") return 2;
   if (row.kind === "main") return 2;
@@ -1063,7 +1070,7 @@ export function subagentPaneSelectableLineOffsets(
 ): number[] {
   const rows = buildSubagentPaneRows(content, viewState);
   const offsets: number[] = [];
-  let line = 0;
+  let line = SUBAGENT_PANE_TABLE_START_LINE;
   let selectableIndex = 0;
 
   for (const row of rows) {
@@ -1109,7 +1116,10 @@ export function subagentIndexForPaneLine(
     ...windowed.visibleRows,
     ...(windowed.hiddenAfter > 0 ? [null] : []),
   ];
-  let rowLine = 0;
+  let rowLine = SUBAGENT_PANE_TABLE_START_LINE;
+  const anchors: Array<{ line: number; target: SubagentPaneTarget }> = [];
+  let exactHit: SubagentPaneTarget | null = null;
+  let insideNonInteractive = false;
   for (const row of visibleRows) {
     const selectableIndex = row?.kind === "main"
       ? 0
@@ -1118,18 +1128,43 @@ export function subagentIndexForPaneLine(
         : -1;
     const selected = selectableIndex === selectedIndex;
     const span = row ? subagentPaneRowLineSpan(row, selected) : 1;
+    const target: SubagentPaneTarget | null = !row
+      ? null
+      : row.kind === "main" || row.kind === "snapshot"
+        ? { type: "snapshot", index: selectableIndex }
+        : row.kind === "section-header"
+          ? (row.collapsible ? { type: "toggle-section", section: row.section } : null)
+          : row.kind === "earlier-toggle"
+            ? { type: "toggle-earlier", section: row.section }
+            : row.kind === "show-all"
+              ? { type: "show-all", section: row.section }
+              : { type: "restore", section: row.section };
+    if (target) anchors.push({ line: rowLine, target });
     if (line >= rowLine && line < rowLine + span) {
-      if (!row) return null;
-      if (row.kind === "main" || row.kind === "snapshot") return { type: "snapshot", index: selectableIndex };
-      if (row.kind === "section-header" && row.collapsible) return { type: "toggle-section", section: row.section };
-      if (row.kind === "earlier-toggle") return { type: "toggle-earlier", section: row.section };
-      if (row.kind === "show-all") return { type: "show-all", section: row.section };
-      if (row.kind === "restore-cleared") return { type: "restore", section: row.section };
-      return null;
+      if (target) exactHit = target;
+      else insideNonInteractive = true;
     }
     rowLine += span;
   }
-  return null;
+  if (exactHit) return exactHit;
+  if (!anchors.length) return null;
+  // Near-miss tolerance (the pre-grouping mapper snapped to the nearest row):
+  // the constant paneTop the TUI passes drifts by a line or two when variable
+  // blocks (plan, goal banner) sit above the roster, so a click inside a
+  // non-interactive span or just past the roster bounds snaps to the nearest
+  // interactive row instead of dead-dropping.
+  const first = anchors[0]!.line;
+  if (!insideNonInteractive && (line < first - 1 || line > rowLine)) return null;
+  let best = anchors[0]!;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const anchor of anchors) {
+    const distance = Math.abs(line - anchor.line);
+    if (distance < bestDistance) {
+      best = anchor;
+      bestDistance = distance;
+    }
+  }
+  return best.target;
 }
 
 export function isLifecycleEventForSnapshot(event: AgentChatEvent, snapshot: SubagentSnapshot): boolean {

From e764700a230c7083bf0d7eb0adae666ce1cd5c69 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Fri, 10 Jul 2026 05:19:26 -0400
Subject: [PATCH 5/9] feat(chat): SessionStore-backed self-heal, full-fidelity
 transcript view, tags

(a) Resume-time envelope splice repair: detects the pre-fix streamed-fragment
signature (3+ consecutive single-fragment text envelopes with distinct
messageIds in one turn), rebuilds the span from SDK getSessionMessages with
stable message ids (lossless local merge when SDK coverage is partial or
missing), preserves ADE-only and unparseable lines byte-identically, writes
atomically with a one-time .splice.bak, skips >64MB files, and invalidates
history caches + nudges open renderers. Idempotent; runs once per session per
process at the pre-resume repair sites.

(b) ade.agentChat.getMainTranscript: Claude-only alternate full-fidelity view
of the main thread via the SDK transcript, byte-bounded like subagent
transcripts, rendered through the existing subagent takeover path on desktop
and the TUI main row; ADE envelopes remain the render backend.

(c) Claude session tags surfaced: claudeTag on session summaries from the
mirrored session pointer, inline tag editing via updateSession, chips in Work
session rows and the chat header, sidebar search haystack, TUI Chat Info.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../sync/syncRemoteCommandService.test.ts     |  20 ++
 .../services/sync/syncRemoteCommandService.ts |  16 ++
 .../tuiClient/__tests__/RightPane.test.tsx    |  15 ++
 .../src/tuiClient/__tests__/adeApi.test.ts    |  17 +-
 .../src/tuiClient/__tests__/chatInfo.test.ts  |  16 ++
 apps/ade-cli/src/tuiClient/adeApi.ts          |  16 ++
 apps/ade-cli/src/tuiClient/app.tsx            |  77 +++++-
 apps/ade-cli/src/tuiClient/chatInfo.ts        |   1 +
 .../src/tuiClient/components/RightPane.tsx    |  13 +-
 apps/ade-cli/src/tuiClient/types.ts           |   1 +
 .../main/services/adeActions/registry.test.ts |  18 ++
 .../src/main/services/adeActions/registry.ts  |   1 +
 .../services/chat/agentChatService.test.ts    | 245 +++++++++++++++++-
 .../main/services/chat/agentChatService.ts    | 160 ++++++++++--
 .../chat/chatEnvelopeSpliceRepair.test.ts     | 236 +++++++++++++++++
 .../services/chat/chatEnvelopeSpliceRepair.ts | 228 ++++++++++++++++
 .../src/main/services/ipc/registerIpc.ts      |  10 +
 .../main/services/ipc/runtimeBridge.test.ts   |  34 +++
 apps/desktop/src/preload/global.d.ts          |   4 +
 apps/desktop/src/preload/preload.ts           |   7 +
 apps/desktop/src/renderer/browserMock.ts      |   1 +
 .../components/chat/AgentChatPane.test.tsx    |  67 +++++
 .../components/chat/AgentChatPane.tsx         | 128 ++++++++-
 .../components/chat/ChatSubagentsPanel.tsx    |  15 ++
 .../components/terminals/SessionCard.test.tsx |  14 +
 .../components/terminals/SessionCard.tsx      |  11 +
 .../terminals/SessionContextMenu.test.tsx     |  76 ++++++
 .../terminals/SessionContextMenu.tsx          |  54 +++-
 .../components/terminals/TerminalsPage.tsx    |  16 ++
 .../terminals/useWorkSessions.test.ts         |  35 +++
 .../components/terminals/useWorkSessions.ts   |   1 +
 apps/desktop/src/shared/ipc.ts                |   1 +
 apps/desktop/src/shared/types/chat.ts         |  12 +
 apps/desktop/src/shared/types/sessions.ts     |   2 +
 apps/desktop/src/shared/types/sync.ts         |   1 +
 docs/features/chat/README.md                  |  36 ++-
 36 files changed, 1552 insertions(+), 53 deletions(-)
 create mode 100644 apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.test.ts
 create mode 100644 apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.ts
 create mode 100644 apps/desktop/src/renderer/components/terminals/SessionContextMenu.test.tsx

diff --git a/apps/ade-cli/src/services/sync/syncRemoteCommandService.test.ts b/apps/ade-cli/src/services/sync/syncRemoteCommandService.test.ts
index 22396150d..c0eca4372 100644
--- a/apps/ade-cli/src/services/sync/syncRemoteCommandService.test.ts
+++ b/apps/ade-cli/src/services/sync/syncRemoteCommandService.test.ts
@@ -742,6 +742,26 @@ describe("createSyncRemoteCommandService", () => {
     ]);
   });
 
+  it("routes main transcript fetches to the chat service", async () => {
+    const transcript = [
+      { type: "assistant", uuid: "msg-1", sessionId: "sdk-1", parentToolUseId: null, message: {}, text: "main" },
+    ];
+    const getMainTranscript = vi.fn().mockResolvedValue(transcript);
+    const { service } = createService({ agentChatService: { getMainTranscript } });
+
+    expect(service.getDescriptor("chat.getMainTranscript")).toEqual({
+      action: "chat.getMainTranscript",
+      scope: "project",
+      policy: { viewerAllowed: true, queueable: false },
+    });
+    await expect(service.execute(makePayload("chat.getMainTranscript", {
+      sessionId: "chat-1",
+      limit: 50,
+      offset: 2,
+    }))).resolves.toEqual(transcript);
+    expect(getMainTranscript).toHaveBeenCalledWith({ sessionId: "chat-1", limit: 50, offset: 2 });
+  });
+
   it("routes subagent roster fetches to the chat service", async () => {
     const listSubagents = vi.fn().mockReturnValue([
       { taskId: "agent-1", agentId: "agent-1", agentType: "Sagan", description: "Read files", status: "stopped" },
diff --git a/apps/ade-cli/src/services/sync/syncRemoteCommandService.ts b/apps/ade-cli/src/services/sync/syncRemoteCommandService.ts
index dc3ee598e..6b9501953 100644
--- a/apps/ade-cli/src/services/sync/syncRemoteCommandService.ts
+++ b/apps/ade-cli/src/services/sync/syncRemoteCommandService.ts
@@ -24,6 +24,7 @@ import type {
   AgentChatHandoffArgs,
   AgentChatLaunchArgs,
   AgentChatListArgs,
+  AgentChatMainTranscriptArgs,
   AgentChatModelCatalogArgs,
   AgentChatSuggestLaneNameArgs,
   AgentChatModelCatalogMode,
@@ -2077,6 +2078,17 @@ function parseAgentChatSubagentTranscriptArgs(value: Record<string, unknown>): A
   return parsed;
 }
 
+function parseAgentChatMainTranscriptArgs(value: Record<string, unknown>): AgentChatMainTranscriptArgs {
+  const parsed: AgentChatMainTranscriptArgs = {
+    sessionId: requireString(value.sessionId, "chat.getMainTranscript requires sessionId."),
+  };
+  const limit = asOptionalNumber(value.limit);
+  const offset = asOptionalNumber(value.offset);
+  if (limit !== undefined) parsed.limit = limit;
+  if (offset !== undefined) parsed.offset = offset;
+  return parsed;
+}
+
 function parseAgentChatSubagentListArgs(value: Record<string, unknown>): AgentChatSubagentListArgs {
   return {
     sessionId: requireString(value.sessionId, "chat.listSubagents requires sessionId."),
@@ -3619,6 +3631,10 @@ function registerChatRemoteCommands({ args, register }: RemoteCommandRegistratio
     requireService(args.agentChatService, "Agent chat service not available.").getSubagentTranscript(
       parseAgentChatSubagentTranscriptArgs(payload),
     ));
+  register("chat.getMainTranscript", { viewerAllowed: true, queueable: false }, async (payload) =>
+    requireService(args.agentChatService, "Agent chat service not available.").getMainTranscript(
+      parseAgentChatMainTranscriptArgs(payload),
+    ));
   register("chat.listSubagents", { viewerAllowed: true, queueable: false }, async (payload) =>
     requireService(args.agentChatService, "Agent chat service not available.").listSubagents(
       parseAgentChatSubagentListArgs(payload),
diff --git a/apps/ade-cli/src/tuiClient/__tests__/RightPane.test.tsx b/apps/ade-cli/src/tuiClient/__tests__/RightPane.test.tsx
index ce0f4d6b6..86921c426 100644
--- a/apps/ade-cli/src/tuiClient/__tests__/RightPane.test.tsx
+++ b/apps/ade-cli/src/tuiClient/__tests__/RightPane.test.tsx
@@ -124,6 +124,21 @@ describe("RightPane chat info", () => {
     expect(frame).not.toContain("GOAL");
   });
 
+  it("renders the Claude session tag in the chat info header", () => {
+    const result = render(
+      <RightPane
+        content={{
+          kind: "chat-info",
+          info: chatInfo({ provider: "claude", claudeTag: "review-ready" }),
+        }}
+        focused
+        width={80}
+      />,
+    );
+
+    expect(stripAnsi(result.lastFrame() ?? "")).toContain("tag:review-ready");
+  });
+
   it("shows the main row + a 'no subagents yet' hint when the roster is empty", () => {
     const result = render(
       <RightPane
diff --git a/apps/ade-cli/src/tuiClient/__tests__/adeApi.test.ts b/apps/ade-cli/src/tuiClient/__tests__/adeApi.test.ts
index 3834ee026..fcdd63ffd 100644
--- a/apps/ade-cli/src/tuiClient/__tests__/adeApi.test.ts
+++ b/apps/ade-cli/src/tuiClient/__tests__/adeApi.test.ts
@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { AgentChatEventEnvelope } from "../../../../desktop/src/shared/types/chat";
-import { archiveChatSession, cancelSteerMessage, createChatSession, DEFAULT_CODEX_REASONING_EFFORT, deleteChatSession, dispatchSteerMessage, discoverProjectSlashCommands, editSteerMessage, getAvailableModels, getChatHistoryPage, latestGoal, latestTokenStats, listChatSessions, listLaneDiffStats, listPrsByLane, listTerminalSessions, messageChatSession, recoverCodexTurn, resumeTerminalSession, runDefaultLaneSetup, sendChatMessage, signalTerminal, startCliTerminalSession, steerChatMessage, trackedCliTerminalProvider, unarchiveChatSession } from "../adeApi";
+import { archiveChatSession, cancelSteerMessage, createChatSession, DEFAULT_CODEX_REASONING_EFFORT, deleteChatSession, dispatchSteerMessage, discoverProjectSlashCommands, editSteerMessage, getAvailableModels, getChatHistoryPage, getMainTranscript, latestGoal, latestTokenStats, listChatSessions, listLaneDiffStats, listPrsByLane, listTerminalSessions, messageChatSession, recoverCodexTurn, resumeTerminalSession, runDefaultLaneSetup, sendChatMessage, signalTerminal, startCliTerminalSession, steerChatMessage, trackedCliTerminalProvider, unarchiveChatSession } from "../adeApi";
 import type { ChatTerminalSession } from "../../../../desktop/src/shared/types/sessions";
 import type { AdeCodeConnection } from "../types";
 
@@ -57,6 +57,21 @@ describe("listLaneDiffStats", () => {
   });
 });
 
+describe("getMainTranscript", () => {
+  it("calls the main transcript chat action with paging arguments", async () => {
+    const action = vi.fn().mockResolvedValue([]);
+    const connection = { action } as unknown as AdeCodeConnection;
+
+    await expect(getMainTranscript(connection, { sessionId: "chat-1", limit: 50, offset: 2 }))
+      .resolves.toEqual([]);
+    expect(action).toHaveBeenCalledWith("chat", "getMainTranscript", {
+      sessionId: "chat-1",
+      limit: 50,
+      offset: 2,
+    });
+  });
+});
+
 describe("runDefaultLaneSetup", () => {
   it("applies the configured default template when it still exists", async () => {
     const calls: Array<{ domain: string; action: string; args: Record<string, unknown> | undefined }> = [];
diff --git a/apps/ade-cli/src/tuiClient/__tests__/chatInfo.test.ts b/apps/ade-cli/src/tuiClient/__tests__/chatInfo.test.ts
index 4b1c5ae17..b54725633 100644
--- a/apps/ade-cli/src/tuiClient/__tests__/chatInfo.test.ts
+++ b/apps/ade-cli/src/tuiClient/__tests__/chatInfo.test.ts
@@ -193,6 +193,22 @@ describe("deriveChatInfoSnapshot", () => {
     expect(snapshot.nextWakeAt).toBe("2026-07-09T12:12:00.000Z");
   });
 
+  it("carries the Claude session tag into the chat info header", () => {
+    const snapshot = deriveChatInfoSnapshot({
+      events: [],
+      activeSession: session({ claudeTag: "review-ready" }),
+      provider: "claude",
+      modelLabel: "claude-opus-4-8",
+      laneLabel: "lane",
+      snapshots: [],
+      tokenStats: null,
+      goal: null,
+      streaming: false,
+    });
+
+    expect(snapshot.claudeTag).toBe("review-ready");
+  });
+
   it("derives todos, plan explanation, and the lane PR rollup", () => {
     const snapshot = deriveChatInfoSnapshot({
       events: [
diff --git a/apps/ade-cli/src/tuiClient/adeApi.ts b/apps/ade-cli/src/tuiClient/adeApi.ts
index cdad12748..83d4a7f1d 100644
--- a/apps/ade-cli/src/tuiClient/adeApi.ts
+++ b/apps/ade-cli/src/tuiClient/adeApi.ts
@@ -21,6 +21,7 @@ import type {
   AgentChatDispatchSteerResult,
   AgentChatDroidPermissionMode,
   AgentChatEventEnvelope,
+  AgentChatMainTranscriptArgs,
   AgentChatEventHistoryPage,
   AgentChatFileRef,
   AgentChatInteractionMode,
@@ -702,6 +703,21 @@ export async function getSubagentTranscript(
   );
 }
 
+export async function getMainTranscript(
+  connection: AdeCodeConnection,
+  args: AgentChatMainTranscriptArgs,
+): Promise<AgentChatSubagentTranscriptMessage[] | null> {
+  return await connection.action<AgentChatSubagentTranscriptMessage[] | null>(
+    "chat",
+    "getMainTranscript",
+    {
+      sessionId: args.sessionId,
+      ...(typeof args.limit === "number" ? { limit: args.limit } : {}),
+      ...(typeof args.offset === "number" ? { offset: args.offset } : {}),
+    },
+  );
+}
+
 /** Daemon-backed roster of subagents for a session (richer than event-derived snapshots). */
 export async function listSubagents(
   connection: AdeCodeConnection,
diff --git a/apps/ade-cli/src/tuiClient/app.tsx b/apps/ade-cli/src/tuiClient/app.tsx
index 7f266eff9..71a6e6e23 100644
--- a/apps/ade-cli/src/tuiClient/app.tsx
+++ b/apps/ade-cli/src/tuiClient/app.tsx
@@ -56,9 +56,10 @@ import {
   getAiSettingsStatus,
   getChatHistory,
   getChatHistoryPage,
-	  getContextUsage,
-	  getModelCatalog,
-	  getModelPickerFavorites,
+  getMainTranscript,
+  getContextUsage,
+  getModelCatalog,
+  getModelPickerFavorites,
   getModelPickerRecents,
   pushModelPickerRecent,
   toggleModelPickerFavorite,
@@ -2981,6 +2982,7 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
   // keyed by subagent id so a stale fetch never bleeds into a different agent. Null
   // ⇒ fall back to the locally-reconstructed transcript.
   const [realSubagentTranscript, setRealSubagentTranscript] = useState<{ id: string; status: SubagentSnapshot["status"]; envelopes: AgentChatEventEnvelope[] } | null>(null);
+  const [realMainTranscript, setRealMainTranscript] = useState<{ sessionId: string; envelopes: AgentChatEventEnvelope[] } | null>(null);
   const unavailableSubagentTranscriptKeysRef = useRef<Set<string>>(new Set());
   const [mentionSuggestions, setMentionSuggestions] = useState<MentionSuggestion[]>([]);
   const [mentionIndex, setMentionIndex] = useState(0);
@@ -3972,6 +3974,7 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
   }, [inspectedSubagentId, rightOpen, rightPane.kind, subagentSnapshots]);
   useEffect(() => {
     setInspectedSubagentId(null);
+    setRealMainTranscript(null);
   }, [activeSessionId]);
   const openSubagentsPane = useCallback((): boolean => {
     if (!subagentPaneCommandAvailable) return false;
@@ -4552,6 +4555,10 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
     return subagentSnapshots.find((snapshot) => snapshot.id === inspectedSubagentId) ?? null;
   }, [inspectedSubagentId, rightOpen, rightPane.kind, subagentSnapshots]);
   const displayEvents = useMemo(() => {
+    const mainTranscript = realMainTranscript;
+    if (mainTranscript && mainTranscript.sessionId === activeSession?.sessionId) {
+      return mainTranscript.envelopes;
+    }
     if (!selectedAgentSnapshot) return events;
     // Prefer the real daemon-backed child transcript when we've fetched it for
     // THIS subagent (Codex/OpenCode); otherwise reconstruct locally from the
@@ -4560,7 +4567,7 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
       return realSubagentTranscript.envelopes;
     }
     return buildSubagentTranscriptEvents({ events, activeSession, snapshot: selectedAgentSnapshot });
-  }, [activeSession, events, realSubagentTranscript, selectedAgentSnapshot]);
+  }, [activeSession, events, realMainTranscript, realSubagentTranscript, selectedAgentSnapshot]);
   const displayPendingSteers = useMemo(
     () => displayEvents === events ? pendingSteers : derivePendingSteers(displayEvents),
     [displayEvents, events, pendingSteers],
@@ -4572,6 +4579,7 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
     ]);
   }, []);
   const inspectSubagentWithTranscriptProbe = useCallback((snapshot: SubagentSnapshot | null) => {
+    setRealMainTranscript(null);
     if (!snapshot) {
       setInspectedSubagentId(null);
       setChatScrollOffset(0);
@@ -4613,6 +4621,49 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
         setChatScrollOffset(0);
       });
   }, [addTranscriptProbeNotice, chatInfo.capability.canViewFullTranscript, setChatScrollOffset]);
+  const inspectMainTranscript = useCallback(() => {
+    const conn = connectionRef.current;
+    const sessionId = activeSessionIdRef.current;
+    const chatSession = activeSessionRef.current;
+    if (
+      !conn
+      || !sessionId
+      || chatInfoRef.current.provider !== "claude"
+      || chatSession?.sessionId !== sessionId
+      || chatSession.provider !== "claude"
+    ) {
+      setRealMainTranscript(null);
+      setInspectedSubagentId(null);
+      setChatScrollOffset(0);
+      return;
+    }
+    void getMainTranscript(conn, { sessionId })
+      .then((messages) => {
+        const snapshot: SubagentSnapshot = {
+          id: "main",
+          name: "Full session transcript (SDK)",
+          kind: "subagent",
+          status: "completed",
+          summary: "Provider-fidelity view; ADE-only events are not shown.",
+        };
+        const envelopes = messages && messages.length > 0
+          ? subagentTranscriptMessagesToEvents({ messages, snapshot, sessionId })
+          : [];
+        if (!envelopes.length) {
+          addTranscriptProbeNotice("Full session transcript unavailable.");
+          setRealMainTranscript(null);
+          return;
+        }
+        setInspectedSubagentId(null);
+        setRealSubagentTranscript(null);
+        setRealMainTranscript({ sessionId, envelopes });
+        setChatScrollOffset(0);
+      })
+      .catch((err) => {
+        addTranscriptProbeNotice(`Full session transcript unavailable. ${err instanceof Error ? err.message : String(err)}`);
+        setRealMainTranscript(null);
+      });
+  }, [addTranscriptProbeNotice, setChatScrollOffset]);
   // Fetch the real child transcript for the inspected subagent when the runtime
   // can produce one (Codex app-server threads / OpenCode child sessions). Falls
   // back silently to local reconstruction on null/empty/error.
@@ -13255,6 +13306,11 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
       // First Esc unwinds a subagent transcript back to the main chat; the
       // right pane stays focused on the main agent's info, so a second Esc
       // would close the pane normally.
+      if (realMainTranscript) {
+        setRealMainTranscript(null);
+        setChatScrollOffset(0);
+        return;
+      }
       if (
         pane === "details"
         && rightOpen
@@ -13634,11 +13690,20 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
         }
         // Capability gate: only runtimes with a real child transcript
         // (Codex/OpenCode) take over the main chat. Cursor/Droid keep the row
-        // selected with its inline detail shown; selecting "main" always
-        // returns to the parent chat.
+        // selected with its inline detail shown. Claude's main row opens the
+        // alternate provider-fidelity transcript; other main rows return home.
         if (selectedSnapshot && !chatInfoRef.current.capability.canViewFullTranscript) {
           return;
         }
+        if (
+          !selectedSnapshot
+          && rightSelectionIndex === resumeOffset
+          && chatInfoRef.current.provider === "claude"
+          && chatInfoRef.current.capability.canViewFullTranscript
+        ) {
+          inspectMainTranscript();
+          return;
+        }
         inspectSubagentWithTranscriptProbe(selectedSnapshot);
         return;
       }
diff --git a/apps/ade-cli/src/tuiClient/chatInfo.ts b/apps/ade-cli/src/tuiClient/chatInfo.ts
index 0e522a896..66775c365 100644
--- a/apps/ade-cli/src/tuiClient/chatInfo.ts
+++ b/apps/ade-cli/src/tuiClient/chatInfo.ts
@@ -72,6 +72,7 @@ export function deriveChatInfoSnapshot(args: {
     provider,
     modelLabel: args.modelLabel,
     laneLabel: args.laneLabel,
+    claudeTag: args.activeSession?.claudeTag ?? null,
     contextPercent: args.tokenStats?.percent ?? null,
     tokenSummary: tokenStatsSummary(args.tokenStats),
     goal: args.goal,
diff --git a/apps/ade-cli/src/tuiClient/components/RightPane.tsx b/apps/ade-cli/src/tuiClient/components/RightPane.tsx
index 1ab4d36ee..953d4016e 100644
--- a/apps/ade-cli/src/tuiClient/components/RightPane.tsx
+++ b/apps/ade-cli/src/tuiClient/components/RightPane.tsx
@@ -710,11 +710,16 @@ function ChatInfoHeader({ info, width }: { info: ChatInfoSnapshot; width: number
         <Text color={brand.color} bold>{brand.glyph}</Text>
         <Text color={theme.color.t1}>{` ${endTruncate(info.modelLabel, inner - 2)}`}</Text>
       </Box>
-      {info.laneLabel ? (
+      {info.laneLabel || info.claudeTag ? (
         <Box flexDirection="row">
-          <Text color={theme.color.t4}>lane </Text>
-          <Text color={theme.color.t4} dimColor>· </Text>
-          <Text color={theme.color.t2}>{endTruncate(info.laneLabel, Math.max(6, inner - 7))}</Text>
+          {info.laneLabel ? (
+            <>
+              <Text color={theme.color.t4}>lane </Text>
+              <Text color={theme.color.t4} dimColor>· </Text>
+              <Text color={theme.color.t2}>{endTruncate(info.laneLabel, Math.max(6, inner - 7))}</Text>
+            </>
+          ) : null}
+          {info.claudeTag ? <Text color={theme.color.t4}>{`${info.laneLabel ? "  " : ""}tag:${endTruncate(info.claudeTag, 24)}`}</Text> : null}
         </Box>
       ) : null}
       <Box flexDirection="row" marginTop={1}>
diff --git a/apps/ade-cli/src/tuiClient/types.ts b/apps/ade-cli/src/tuiClient/types.ts
index c0d6d8fbd..ff698ce9b 100644
--- a/apps/ade-cli/src/tuiClient/types.ts
+++ b/apps/ade-cli/src/tuiClient/types.ts
@@ -174,6 +174,7 @@ export type ChatInfoSnapshot = {
   provider: AdeCodeProvider;
   modelLabel: string;
   laneLabel: string | null;
+  claudeTag?: string | null;
   contextPercent: number | null;
   tokenSummary: string | null;
   goal: CodexThreadGoal | null;
diff --git a/apps/desktop/src/main/services/adeActions/registry.test.ts b/apps/desktop/src/main/services/adeActions/registry.test.ts
index 4431f0e2f..60fb90c15 100644
--- a/apps/desktop/src/main/services/adeActions/registry.test.ts
+++ b/apps/desktop/src/main/services/adeActions/registry.test.ts
@@ -79,10 +79,12 @@ describe("isAllowedAdeAction", () => {
   });
 
   it("exposes subagent transcript reads through the chat runtime action surface", () => {
+    expect(isAllowedAdeAction("chat", "getMainTranscript")).toBe(true);
     expect(isAllowedAdeAction("chat", "getSubagentTranscript")).toBe(true);
     expect(isAllowedAdeAction("chat", "readTranscript")).toBe(true);
     expect(isAllowedAdeAction("chat", "sendMessage")).toBe(true);
     expect(isAllowedAdeAction("chat", "messageSession")).toBe(true);
+    expect(isCtoOnlyAdeAction("chat", "getMainTranscript")).toBe(false);
     expect(isCtoOnlyAdeAction("chat", "getSubagentTranscript")).toBe(false);
     expect(isCtoOnlyAdeAction("chat", "readTranscript")).toBe(false);
     expect(isCtoOnlyAdeAction("chat", "sendMessage")).toBe(false);
@@ -317,6 +319,7 @@ describe("ADE_ACTION_ALLOWLIST shape", () => {
   it("exposes CTO identity session and scan wrappers for runtime-backed CTO views", () => {
     const chatActions = ADE_ACTION_ALLOWLIST.chat ?? [];
     expect(chatActions).toContain("ensureCtoSession");
+    expect(chatActions).toContain("getMainTranscript");
     expect(chatActions).toContain("getSubagentTranscript");
     expect(chatActions).toContain("modelCatalog");
     expect(ADE_ACTION_ALLOWLIST.cto_state ?? []).toContain("runProjectScan");
@@ -921,6 +924,21 @@ describe("runtime session actions", () => {
     });
   });
 
+  it("forwards remote main transcript reads through chat actions", async () => {
+    const transcript = [{ role: "assistant", content: "main output" }];
+    const getMainTranscript = vi.fn(async () => transcript);
+    const runtime = {
+      agentChatService: { getMainTranscript },
+    } as unknown as Parameters<typeof getAdeActionDomainServices>[0];
+    const chatService = getAdeActionDomainServices(runtime).chat as {
+      getMainTranscript: (args: { sessionId: string }) => Promise<Array<{ role: string; content: string }>>;
+    } & Record<string, unknown>;
+
+    expect(listAllowedAdeActionNames("chat", chatService)).toContain("getMainTranscript");
+    await expect(chatService.getMainTranscript({ sessionId: "chat-1" })).resolves.toEqual(transcript);
+    expect(getMainTranscript).toHaveBeenCalledWith({ sessionId: "chat-1" });
+  });
+
   it("adds getDelta from the runtime session delta service", () => {
     const delta = { sessionId: "session-1", filesChanged: 2 };
     const runtime = {
diff --git a/apps/desktop/src/main/services/adeActions/registry.ts b/apps/desktop/src/main/services/adeActions/registry.ts
index 74c036ed4..f729b08d0 100644
--- a/apps/desktop/src/main/services/adeActions/registry.ts
+++ b/apps/desktop/src/main/services/adeActions/registry.ts
@@ -431,6 +431,7 @@ export const ADE_ACTION_ALLOWLIST: Partial<Record<AdeActionDomain, readonly stri
     "getChatEventHistoryPage",
     "getContextUsage",
     "getImageDataUrl",
+    "getMainTranscript",
     "getSubagentTranscript",
     "setCodexGoal",
     "setCodexGoalStatus",
diff --git a/apps/desktop/src/main/services/chat/agentChatService.test.ts b/apps/desktop/src/main/services/chat/agentChatService.test.ts
index 889675583..446a8fc41 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.test.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.test.ts
@@ -2,7 +2,7 @@ import fs from "node:fs";
 import { EventEmitter } from "node:events";
 import os from "node:os";
 import path from "node:path";
-import { getSessionInfo, query, startup } from "@anthropic-ai/claude-agent-sdk";
+import { getSessionInfo, getSessionMessages, query, startup, tagSession } from "@anthropic-ai/claude-agent-sdk";
 import { resolveClaudeCodeExecutable } from "../ai/claudeCodeExecutable";
 import { codexComputerUseClientCandidates } from "../../utils/codexComputerUse";
 import { buildOpenCodePromptParts, startOpenCodeSession } from "../opencode/openCodeRuntime";
@@ -1252,9 +1252,21 @@ function createMockSessionService() {
       }
     }),
     upsertClaudeSessionPointer: vi.fn((pointer: any) => {
-      claudePointers.set(pointer.chatSessionId, pointer);
-      return pointer;
+      const existing = pointer.chatSessionId
+        ? claudePointers.get(pointer.chatSessionId)
+        : Array.from(claudePointers.values()).find((candidate) => candidate.sessionId === pointer.sessionId);
+      const next = {
+        ...existing,
+        ...pointer,
+        title: pointer.title !== undefined ? pointer.title : existing?.title ?? null,
+        tags: pointer.tags !== undefined ? pointer.tags : existing?.tags ?? [],
+      };
+      if (next.chatSessionId) claudePointers.set(next.chatSessionId, next);
+      return next;
     }),
+    getClaudeSessionPointer: vi.fn((sdkSessionId: string) => (
+      Array.from(claudePointers.values()).find((pointer) => pointer.sessionId === sdkSessionId) ?? null
+    )),
     getClaudeSessionPointerByChatSessionId: vi.fn((chatSessionId: string) => claudePointers.get(chatSessionId) ?? null),
     listClaudeSessionPointers: vi.fn(() => Array.from(claudePointers.values())),
   } as any;
@@ -1643,6 +1655,9 @@ beforeEach(() => {
   vi.mocked(claudeSdkResumeSessionCompat).mockReset();
   vi.mocked(query).mockReset();
   vi.mocked(startup).mockReset();
+  vi.mocked(getSessionMessages).mockReset();
+  vi.mocked(getSessionMessages).mockResolvedValue([]);
+  vi.mocked(tagSession).mockClear();
   installClaudeSdkCompatMocks();
   vi.mocked(resolveClaudeCodeExecutable).mockClear();
   vi.mocked(resolveClaudeCodeExecutable).mockReturnValue({ path: "/usr/local/bin/claude", source: "path" });
@@ -6792,6 +6807,42 @@ describe("createAgentChatService", () => {
       expect(summary!.sessionId).toBe(created.id);
       expect(summary!.provider).toBe("opencode");
     });
+
+    it("surfaces and updates the first mirrored Claude SDK tag", async () => {
+      installClaudeResponseFixture({ sdkSessionId: "sdk-tag-session", responseText: "unused" });
+      const events: AgentChatEventEnvelope[] = [];
+      const { service, sessionService } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+      const created = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await service.runSessionTurn({
+        sessionId: created.id,
+        text: "Create the SDK session before tagging.",
+        timeoutMs: 15_000,
+      });
+
+      await service.updateSession({ sessionId: created.id, tag: "review-ready" });
+      expect(tagSession).toHaveBeenCalledWith(expect.any(String), "review-ready", {
+        dir: fs.realpathSync(tmpRoot),
+      });
+      expect(sessionService.getClaudeSessionPointerByChatSessionId(created.id)?.tags).toEqual(["review-ready"]);
+      await expect(service.getSessionSummary(created.id)).resolves.toMatchObject({
+        claudeTag: "review-ready",
+      });
+      expect(events).toContainEqual(expect.objectContaining({
+        event: { type: "session_meta_updated", claudeTag: "review-ready" },
+      }));
+
+      await service.updateSession({ sessionId: created.id, tag: "" });
+      expect(tagSession).toHaveBeenLastCalledWith(expect.any(String), null, {
+        dir: fs.realpathSync(tmpRoot),
+      });
+      await expect(service.getSessionSummary(created.id)).resolves.toMatchObject({ claudeTag: null });
+    });
   });
 
   // --------------------------------------------------------------------------
@@ -6864,6 +6915,41 @@ describe("createAgentChatService", () => {
     });
   });
 
+  describe("Claude SessionStore reads", () => {
+    it("maps SDK messages and forwards paging plus system-message options", async () => {
+      const { service } = createService();
+      vi.mocked(getSessionMessages).mockResolvedValue([{
+        type: "assistant",
+        uuid: "wire-1",
+        session_id: "sdk-session-1",
+        parent_tool_use_id: null,
+        message: {
+          id: "msg-1",
+          role: "assistant",
+          content: [{ type: "text", text: "SDK transcript text" }],
+        },
+      }] as any);
+
+      await expect(service.getClaudeSessionMessages({
+        sessionId: "sdk-session-1",
+        laneId: "lane-1",
+        limit: 25,
+        offset: 3,
+        includeSystemMessages: true,
+      })).resolves.toEqual([expect.objectContaining({
+        uuid: "wire-1",
+        sessionId: "sdk-session-1",
+        text: "SDK transcript text",
+      })]);
+      expect(getSessionMessages).toHaveBeenCalledWith("sdk-session-1", {
+        dir: fs.realpathSync(tmpRoot),
+        limit: 25,
+        offset: 3,
+        includeSystemMessages: true,
+      });
+    });
+  });
+
   // --------------------------------------------------------------------------
   // listSubagents
   // --------------------------------------------------------------------------
@@ -21571,6 +21657,159 @@ describe("createAgentChatService", () => {
       expect(sessionService.reopen).toHaveBeenCalledWith(session.id);
     });
 
+    it("repairs a spliced dedicated envelope transcript before Claude resume", async () => {
+      installClaudeResponseFixture({ sdkSessionId: "sdk-splice-repair", responseText: "unused" });
+      const initial = createService();
+      const session = await initial.service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await initial.service.dispose({ sessionId: session.id });
+
+      const persisted = readPersistedChatState(session.id);
+      writePersistedChatState(session.id, { ...persisted, sdkSessionId: "sdk-splice-repair" });
+      const transcriptPath = path.join(tmpRoot, ".ade", "transcripts", "chat", `${session.id}.jsonl`);
+      const legacyTranscriptPath = path.join(tmpRoot, "transcripts", `${session.id}.chat.jsonl`);
+      const fragments = ["Full", " ", "SDK", " ", "answer"];
+      const splicedTranscript = `${fragments.map((text, index) => JSON.stringify({
+        sessionId: session.id,
+        timestamp: "2026-07-10T12:00:00.000Z",
+        sequence: index + 1,
+        event: {
+          type: "text",
+          text,
+          messageId: `wire-${index + 1}`,
+          turnId: "turn-spliced",
+        },
+      })).join("\n")}\n`;
+      fs.writeFileSync(transcriptPath, splicedTranscript, "utf8");
+      fs.writeFileSync(legacyTranscriptPath, splicedTranscript, "utf8");
+      vi.mocked(getSessionMessages).mockResolvedValue([{
+        type: "assistant",
+        uuid: "wire-sdk",
+        session_id: "sdk-splice-repair",
+        parent_tool_use_id: null,
+        message: {
+          id: "msg-stable-sdk",
+          role: "assistant",
+          content: [{ type: "text", text: "Full SDK answer" }],
+        },
+      }] as any);
+      vi.mocked(parseAgentChatTranscript).mockImplementation((raw) => String(raw)
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((line) => JSON.parse(line)));
+      installClaudeResponseFixture({ sdkSessionId: "sdk-splice-repair", responseText: "unused" });
+
+      const repairEvents: AgentChatEventEnvelope[] = [];
+      const resumed = createService({
+        onEvent: (event: AgentChatEventEnvelope) => repairEvents.push(event),
+      });
+      await resumed.service.resumeSession({ sessionId: session.id });
+      await resumed.service.runSessionTurn({
+        sessionId: session.id,
+        text: "Continue after resume.",
+        timeoutMs: 15_000,
+      });
+      await vi.waitFor(() => {
+        expect(getSessionMessages).toHaveBeenCalledWith("sdk-splice-repair", { dir: fs.realpathSync(tmpRoot) });
+      });
+      await vi.waitFor(() => {
+        const textEvents = resumed.service.getChatEventHistory(session.id).events
+          .filter((entry) => entry.event.type === "text");
+        expect(textEvents.find((entry) => entry.event.type === "text" && entry.event.messageId === "msg-stable-sdk")?.event).toMatchObject({
+          type: "text",
+          text: "Full SDK answer",
+          messageId: "msg-stable-sdk",
+        });
+      });
+      expect(fs.existsSync(`${transcriptPath}.splice.bak`)).toBe(true);
+      expect(resumed.logger.info).toHaveBeenCalledWith(
+        "agent_chat.envelope_splice_repaired",
+        expect.objectContaining({ sessionId: session.id, repairedTurns: 1 }),
+      );
+      expect(repairEvents).toContainEqual(expect.objectContaining({
+        sessionId: session.id,
+        event: { type: "session_meta_updated", historyInvalidated: true },
+      }));
+    });
+
+    it("resolves an ADE chat id to persisted and pointer-backed Claude main transcripts", async () => {
+      installClaudeResponseFixture({ sdkSessionId: "sdk-main-transcript", responseText: "unused" });
+      const { service, sessionService } = createService();
+      const session = await service.createSession({ laneId: "lane-1", provider: "claude", model: "sonnet" });
+      await service.dispose({ sessionId: session.id });
+
+      const persisted = readPersistedChatState(session.id);
+      writePersistedChatState(session.id, { ...persisted, sdkSessionId: "sdk-persisted-main" });
+      vi.mocked(getSessionMessages).mockResolvedValue([{
+        type: "assistant",
+        uuid: "assistant-persisted",
+        session_id: "sdk-persisted-main",
+        parent_tool_use_id: null,
+        message: { id: "msg-persisted", role: "assistant", content: [{ type: "text", text: "Persisted transcript" }] },
+      }] as any);
+
+      expect(await service.getMainTranscript({ sessionId: session.id })).toEqual([
+        expect.objectContaining({ uuid: "assistant-persisted", text: "Persisted transcript" }),
+      ]);
+      expect(getSessionMessages).toHaveBeenLastCalledWith("sdk-persisted-main", expect.objectContaining({
+        dir: fs.realpathSync(tmpRoot),
+        includeSystemMessages: true,
+      }));
+
+      const pointerState = { ...persisted };
+      delete pointerState.sdkSessionId;
+      writePersistedChatState(session.id, pointerState);
+      sessionService.upsertClaudeSessionPointer({
+        sessionId: "sdk-pointer-main",
+        laneId: "lane-1",
+        laneName: "Primary",
+        chatSessionId: session.id,
+        title: null,
+        tags: [],
+        createdAt: "2026-07-10T12:00:00.000Z",
+        updatedAt: "2026-07-10T12:00:00.000Z",
+      });
+      vi.mocked(getSessionMessages).mockResolvedValue([{
+        type: "system",
+        uuid: "system-pointer",
+        session_id: "sdk-pointer-main",
+        parent_tool_use_id: null,
+        message: { role: "system", content: "Pointer transcript" },
+      }] as any);
+
+      expect(await service.getMainTranscript({ sessionId: session.id })).toEqual([
+        expect.objectContaining({ uuid: "system-pointer", type: "system", text: "Pointer transcript" }),
+      ]);
+      expect(getSessionMessages).toHaveBeenLastCalledWith("sdk-pointer-main", expect.objectContaining({
+        includeSystemMessages: true,
+      }));
+    });
+
+    it("gates main transcripts to Claude and byte-bounds the response", async () => {
+      const { service } = createService();
+      const codex = await service.createSession({ laneId: "lane-1", provider: "codex", model: "gpt-5.4" });
+      expect(await service.getMainTranscript({ sessionId: codex.id })).toBeNull();
+      expect(getSessionMessages).not.toHaveBeenCalled();
+
+      installClaudeResponseFixture({ sdkSessionId: "sdk-bounded-main", responseText: "unused" });
+      const claude = await service.createSession({ laneId: "lane-1", provider: "claude", model: "sonnet" });
+      await service.dispose({ sessionId: claude.id });
+      const persisted = readPersistedChatState(claude.id);
+      writePersistedChatState(claude.id, { ...persisted, sdkSessionId: "sdk-bounded-main" });
+      const huge = "x".repeat(2_200_000);
+      vi.mocked(getSessionMessages).mockResolvedValue([
+        { type: "assistant", uuid: "old-huge", session_id: "sdk-bounded-main", parent_tool_use_id: null, message: { role: "assistant", content: huge } },
+        { type: "assistant", uuid: "new-huge", session_id: "sdk-bounded-main", parent_tool_use_id: null, message: { role: "assistant", content: huge } },
+      ] as any);
+
+      const result = await service.getMainTranscript({ sessionId: claude.id });
+      expect(result).toHaveLength(1);
+      expect(result?.[0]?.uuid).toBe("new-huge");
+    });
+
     it("keeps requested Codex policy and reasoning effort across resume", async () => {
       mockState.codexResponseOverrides.set("thread/resume", () => ({
         thread: { id: "thread-effective-resume" },
diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index f654003a6..4297379b6 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -52,6 +52,7 @@ import {
   isCorruptThinkingTranscriptError,
   repairClaudeResumeTranscript,
 } from "./claudeThinkingTranscriptRepair";
+import { repairSplicedEnvelopeFileSync } from "./chatEnvelopeSpliceRepair";
 import {
   discoverClaudePluginPaths,
   discoverClaudePlugins,
@@ -223,6 +224,7 @@ import type {
   AgentChatClaudeSessionListArgs,
   AgentChatClaudeSessionMessage,
   AgentChatClaudeSessionMessagesArgs,
+  AgentChatMainTranscriptArgs,
   AgentChatSubagentTranscriptArgs,
   AgentChatSubagentTranscriptMessage,
   AgentChatSuggestLaneNameArgs,
@@ -5801,6 +5803,7 @@ export function createAgentChatService(args: {
   const CHAT_EVENT_HISTORY_BUFFER_MAX_CHARS = 4_000_000;
   const CHAT_EVENT_HISTORY_RESPONSE_MAX_CHARS = 8_000_000;
   const eventHistoryBySession = new Map<string, AgentChatEventEnvelope[]>();
+  const envelopeSpliceRepairAttemptedSessionIds = new Set<string>();
 
   const safeJsonChars = (value: unknown): number => {
     try {
@@ -14395,7 +14398,7 @@ export function createAgentChatService(args: {
       if (runtime.interrupted) {
         throw new Error("Claude turn interrupted during warmup.");
       }
-      let sessionQuery = ensureClaudeQuery(managed, runtime);
+      let sessionQuery = await ensureClaudeQuery(managed, runtime);
 
       const turnPermissionMode = resolveClaudeTurnPermissionMode(managed);
 
@@ -14414,7 +14417,7 @@ export function createAgentChatService(args: {
             error: String(permErr),
           });
           resetClaudeQuerySession(managed, runtime, "session_reset", { clearSdkSessionId: true });
-          sessionQuery = ensureClaudeQuery(managed, runtime);
+          sessionQuery = await ensureClaudeQuery(managed, runtime);
           sessionControl = getClaudeQueryControl(sessionQuery);
           if (typeof sessionControl.setPermissionMode === "function") {
             await sessionControl.setPermissionMode(turnPermissionMode);
@@ -22051,7 +22054,75 @@ export function createAgentChatService(args: {
     }
   };
 
-  const ensureClaudeQuery = (managed: ManagedChatSession, runtime: ClaudeRuntime): ClaudeQuery => {
+  const repairClaudeEnvelopeSplicesBeforeResume = async (
+    managed: ManagedChatSession,
+    sdkSessionId: string,
+  ): Promise<void> => {
+    const sessionId = managed.session.id;
+    if (envelopeSpliceRepairAttemptedSessionIds.has(sessionId)) return;
+    envelopeSpliceRepairAttemptedSessionIds.add(sessionId);
+
+    let sdkMessages: ClaudeSdkSessionMessage[];
+    try {
+      sdkMessages = await getClaudeSdkSessionMessages(sdkSessionId, {
+        dir: managed.laneWorktreePath,
+      });
+    } catch (error) {
+      logger.debug("agent_chat.envelope_splice_repair_skipped", {
+        sessionId,
+        sdkSessionId,
+        reason: "sdk_messages_unavailable",
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return;
+    }
+
+    const transcriptPaths = [...new Set([
+      path.join(chatTranscriptsDir, `${sessionId}.jsonl`),
+      managed.transcriptPath,
+    ].filter((candidate) => candidate.trim().length > 0))];
+    let repairedTurns = 0;
+    let filesChanged = 0;
+    for (const transcriptPath of transcriptPaths) {
+      flushQueuedTranscriptWrite(transcriptPath);
+      const result = repairSplicedEnvelopeFileSync(transcriptPath, sdkMessages, {
+        onSkip: (reason, detail) => {
+          logger.debug("agent_chat.envelope_splice_repair_skipped", {
+            sessionId,
+            sdkSessionId,
+            transcriptPath,
+            reason,
+            ...(reason === "oversize" && typeof detail === "number" ? { fileBytes: detail } : {}),
+          });
+        },
+      });
+      if (result.changed) {
+        filesChanged += 1;
+        // The dedicated and legacy files mirror the same turns. Report the
+        // logical repaired-turn count, not the number of repaired copies.
+        repairedTurns = Math.max(repairedTurns, result.repairedTurns);
+      }
+    }
+
+    if (!filesChanged) {
+      logger.debug("agent_chat.envelope_splice_repair_not_needed", { sessionId, sdkSessionId });
+      return;
+    }
+    eventHistoryBySession.delete(sessionId);
+    transcriptHistoryCacheBySession.delete(sessionId);
+    logger.info("agent_chat.envelope_splice_repaired", {
+      sessionId,
+      sdkSessionId,
+      repairedTurns,
+      filesChanged,
+    });
+    emitTransientChatEnvelope(sessionId, {
+      type: "session_meta_updated",
+      historyInvalidated: true,
+    });
+  };
+
+  const ensureClaudeQuery = async (managed: ManagedChatSession, runtime: ClaudeRuntime): Promise<ClaudeQuery> => {
     if (runtime.query && runtime.inputPump) return runtime.query;
 
     const pump = new ClaudeInputPump();
@@ -22092,6 +22163,7 @@ export function createAgentChatService(args: {
           at: "resume",
         });
       }
+      await repairClaudeEnvelopeSplicesBeforeResume(managed, options.resume);
     }
 
     let sessionQuery: ClaudeQuery;
@@ -22349,6 +22421,7 @@ export function createAgentChatService(args: {
               at: "prewarm",
             });
           }
+          await repairClaudeEnvelopeSplicesBeforeResume(managed, options.resume);
         }
 
         if (runtime.warmupCancelled) {
@@ -28662,6 +28735,9 @@ export function createAgentChatService(args: {
       : hasPersistedCodexServiceTier
         ? persisted?.codexServiceTier ?? null
         : undefined;
+    const claudeTag = provider === "claude"
+      ? getClaudeSessionPointerForChat(row.id)?.tags[0] ?? null
+      : undefined;
     return {
       sessionId: row.id,
       laneId: row.laneId,
@@ -28743,6 +28819,7 @@ export function createAgentChatService(args: {
       lastActivityAt: liveSession?.lastActivityAt ?? persisted?.updatedAt ?? row.endedAt ?? row.startedAt,
       lastOutputPreview: row.lastOutputPreview,
       summary: row.summary ?? null,
+      ...(provider === "claude" ? { claudeTag } : {}),
       nextWakeAt: (() => {
         const next = scheduledWorkScheduler?.nextWakeAt(row.id) ?? null;
         return next == null ? null : new Date(next).toISOString();
@@ -30821,6 +30898,10 @@ export function createAgentChatService(args: {
       mirrorClaudeSessionPointer(managed, managed.runtime.sdkSessionId, {
         tags: normalizedTag && normalizedTag.length ? [normalizedTag] : [],
       });
+      emitTransientChatEnvelope(sessionId, {
+        type: "session_meta_updated",
+        claudeTag: normalizedTag && normalizedTag.length ? normalizedTag : null,
+      });
     }
     // Allow resetting manuallyNamed independently when no title change is provided
     if (manuallyNamed !== undefined && title === undefined) {
@@ -31158,6 +31239,21 @@ export function createAgentChatService(args: {
     };
   };
 
+  const mapClaudeSdkSessionMessage = (
+    message: ClaudeSdkSessionMessage,
+  ): AgentChatClaudeSessionMessage => {
+    const parentToolUseId = (message as unknown as { parent_tool_use_id?: unknown }).parent_tool_use_id;
+    const text = extractClaudeSessionMessageText(message.message);
+    return {
+      type: message.type,
+      uuid: message.uuid,
+      sessionId: message.session_id,
+      parentToolUseId: typeof parentToolUseId === "string" ? parentToolUseId : null,
+      message: message.message,
+      ...(text ? { text } : {}),
+    };
+  };
+
   const getClaudeSessionMessages = async ({
     sessionId,
     laneId,
@@ -31181,18 +31277,7 @@ export function createAgentChatService(args: {
       ...(normalizedOffset !== undefined ? { offset: normalizedOffset } : {}),
       ...(typeof includeSystemMessages === "boolean" ? { includeSystemMessages } : {}),
     });
-    return messages.map((message: ClaudeSdkSessionMessage) => {
-      const parentToolUseId = (message as unknown as { parent_tool_use_id?: unknown }).parent_tool_use_id;
-      const text = extractClaudeSessionMessageText(message.message);
-      return {
-        type: message.type,
-        uuid: message.uuid,
-        sessionId: message.session_id,
-        parentToolUseId: typeof parentToolUseId === "string" ? parentToolUseId : null,
-        message: message.message,
-        ...(text ? { text } : {}),
-      };
-    });
+    return messages.map(mapClaudeSdkSessionMessage);
   };
 
   /**
@@ -31489,6 +31574,48 @@ export function createAgentChatService(args: {
   ): AgentChatSubagentTranscriptMessage[] =>
     keepNewestWithinCharBudget(messages, SUBAGENT_TRANSCRIPT_RESPONSE_MAX_CHARS, safeJsonChars);
 
+  const getMainTranscript = async ({
+    sessionId,
+    limit,
+    offset,
+  }: AgentChatMainTranscriptArgs): Promise<AgentChatSubagentTranscriptMessage[] | null> => {
+    const normalizedSessionId = sessionId.trim();
+    if (!normalizedSessionId.length) throw new Error("sessionId is required.");
+    const row = sessionService.get(normalizedSessionId);
+    if (!row || !isChatToolType(row.toolType)) return null;
+
+    const managed = managedSessions.get(normalizedSessionId) ?? null;
+    const persisted = readPersistedState(normalizedSessionId);
+    const provider = managed?.session.provider ?? persisted?.provider ?? providerFromToolType(row.toolType);
+    if (provider !== "claude") return null;
+
+    const pointer = getClaudeSessionPointerForChat(normalizedSessionId);
+    const claudeSessionId = (
+      (managed?.runtime?.kind === "claude" ? managed.runtime.sdkSessionId : null)
+      ?? persisted?.sdkSessionId
+      ?? pointer?.sessionId
+      ?? ""
+    ).trim();
+    if (!claudeSessionId) return null;
+
+    const normalizedLimit = typeof limit === "number" && Number.isFinite(limit) && limit > 0
+      ? Math.min(Math.trunc(limit), 500)
+      : undefined;
+    const normalizedOffset = typeof offset === "number" && Number.isFinite(offset) && offset > 0
+      ? Math.trunc(offset)
+      : undefined;
+    const laneFallback = managed?.laneWorktreePath
+      ? { dir: managed.laneWorktreePath }
+      : await resolveClaudeSessionLaneFallback(row.laneId);
+    const messages = await getClaudeSdkSessionMessages(claudeSessionId, {
+      ...(laneFallback.dir ? { dir: laneFallback.dir } : {}),
+      ...(normalizedLimit !== undefined ? { limit: normalizedLimit } : {}),
+      ...(normalizedOffset !== undefined ? { offset: normalizedOffset } : {}),
+      includeSystemMessages: true,
+    });
+    return boundSubagentTranscriptResponse(messages.map(mapClaudeSdkSessionMessage));
+  };
+
   function mergeSubagentTranscriptMessages(
     left: AgentChatSubagentTranscriptMessage[],
     right: AgentChatSubagentTranscriptMessage[],
@@ -31945,7 +32072,7 @@ export function createAgentChatService(args: {
     if (runtime.warmupDone) {
       await runtime.warmupDone.catch(() => undefined);
     }
-      const sessionQuery = ensureClaudeQuery(managed, runtime);
+      const sessionQuery = await ensureClaudeQuery(managed, runtime);
       return sessionQuery;
     };
 
@@ -33024,6 +33151,7 @@ export function createAgentChatService(args: {
     listClaudeSessions,
     getClaudeSessionInfo,
     getClaudeSessionMessages,
+    getMainTranscript,
     getSubagentTranscript,
     killDroidWorker,
     getContextUsage,
diff --git a/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.test.ts b/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.test.ts
new file mode 100644
index 000000000..b0d75091b
--- /dev/null
+++ b/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.test.ts
@@ -0,0 +1,236 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { SessionMessage } from "@anthropic-ai/claude-agent-sdk";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  repairSplicedEnvelopeFileSync,
+  repairSplicedEnvelopeLines,
+} from "./chatEnvelopeSpliceRepair";
+
+const textEnvelope = (
+  text: string,
+  messageId: string,
+  options: { turnId?: string; sequence?: number; sessionId?: string } = {},
+) => JSON.stringify({
+  sessionId: options.sessionId ?? "chat-1",
+  timestamp: "2026-07-10T12:00:00.000Z",
+  sequence: options.sequence ?? 1,
+  event: {
+    type: "text",
+    text,
+    messageId,
+    turnId: options.turnId ?? "turn-1",
+  },
+});
+
+const eventEnvelope = (event: Record<string, unknown>, sequence: number) => JSON.stringify({
+  sessionId: "chat-1",
+  timestamp: "2026-07-10T12:00:00.000Z",
+  sequence,
+  event,
+});
+
+const assistantMessage = (id: string, text: string): SessionMessage => ({
+  type: "assistant",
+  uuid: `wire-${id}`,
+  session_id: "sdk-1",
+  parent_tool_use_id: null,
+  message: { id, role: "assistant", content: [{ type: "text", text }] },
+} as SessionMessage);
+
+const splicedRun = (turnId = "turn-1", sequenceStart = 1) => [
+  textEnvelope("Hello", "wire-1", { turnId, sequence: sequenceStart }),
+  textEnvelope(" ", "wire-2", { turnId, sequence: sequenceStart + 1 }),
+  textEnvelope("from", "wire-3", { turnId, sequence: sequenceStart + 2 }),
+  textEnvelope(" the", "wire-4", { turnId, sequence: sequenceStart + 3 }),
+  textEnvelope(" SDK", "wire-5", { turnId, sequence: sequenceStart + 4 }),
+];
+
+describe("repairSplicedEnvelopeLines", () => {
+  it("rebuilds five distinct fragments as one SDK-backed message", () => {
+    const input = splicedRun();
+    const result = repairSplicedEnvelopeLines(input, [assistantMessage("msg-stable", "Hello from the SDK")]);
+
+    expect(result.changed).toBe(true);
+    expect(result.repairedTurns).toBe(1);
+    expect(result.lines).toHaveLength(1);
+    expect(JSON.parse(result.lines[0]!)).toMatchObject({
+      sequence: 1,
+      event: { type: "text", text: "Hello from the SDK", messageId: "msg-stable", turnId: "turn-1" },
+    });
+  });
+
+  it("leaves healthy fragments sharing one message id byte-identical", () => {
+    const input = [
+      textEnvelope("one", "msg-stable", { sequence: 1 }),
+      textEnvelope("two", "msg-stable", { sequence: 2 }),
+      textEnvelope("three", "msg-stable", { sequence: 3 }),
+    ];
+    expect(repairSplicedEnvelopeLines(input, [])).toEqual({
+      lines: input,
+      changed: false,
+      repairedTurns: 0,
+    });
+  });
+
+  it("does not join separate assistant messages across a tool call", () => {
+    const tool = eventEnvelope({ type: "tool_call", tool: "Read", args: {}, itemId: "tool-1", turnId: "turn-1" }, 2);
+    const input = [
+      textEnvelope("first", "msg-1", { sequence: 1 }),
+      tool,
+      textEnvelope("second", "msg-2", { sequence: 3 }),
+    ];
+    expect(repairSplicedEnvelopeLines(input, [])).toEqual({
+      lines: input,
+      changed: false,
+      repairedTurns: 0,
+    });
+  });
+
+  it("leaves a two-fragment run below the detector threshold untouched", () => {
+    const input = [
+      textEnvelope("one", "wire-1", { sequence: 1 }),
+      textEnvelope("two", "wire-2", { sequence: 2 }),
+    ];
+    expect(repairSplicedEnvelopeLines(input, [])).toEqual({
+      lines: input,
+      changed: false,
+      repairedTurns: 0,
+    });
+  });
+
+  it("preserves ADE-only and unparseable lines byte-identically around repaired runs", () => {
+    const before = eventEnvelope({ type: "approval_request", itemId: "approval-1", kind: "tool_call", description: "Allow?" }, 1);
+    const between = eventEnvelope({ type: "scheduled_work_update", id: "schedule-1", kind: "wakeup", status: "scheduled", origin: "schedule_wakeup", title: "Later" }, 8);
+    const unknown = "{ definitely-not-json";
+    const input = [
+      before,
+      ...splicedRun("turn-1", 2),
+      between,
+      unknown,
+      ...splicedRun("turn-2", 9),
+    ];
+    const result = repairSplicedEnvelopeLines(input, []);
+
+    expect(result.changed).toBe(true);
+    expect(result.repairedTurns).toBe(2);
+    expect(result.lines).toContain(before);
+    expect(result.lines).toContain(between);
+    expect(result.lines).toContain(unknown);
+    expect(result.lines.indexOf(before)).toBeLessThan(result.lines.indexOf(between));
+    expect(result.lines.indexOf(between)).toBeLessThan(result.lines.indexOf(unknown));
+  });
+
+  it("uses SDK stable ids and full text for each matched assistant message", () => {
+    const input = [
+      textEnvelope("Alpha", "wire-1", { sequence: 11 }),
+      textEnvelope("Beta", "wire-2", { sequence: 12 }),
+      textEnvelope("Gamma", "wire-3", { sequence: 13 }),
+    ];
+    const result = repairSplicedEnvelopeLines(input, [
+      assistantMessage("msg-a", "AlphaBeta"),
+      assistantMessage("msg-b", "Gamma"),
+    ]);
+
+    expect(result.lines.map((line) => JSON.parse(line).event)).toEqual([
+      expect.objectContaining({ text: "AlphaBeta", messageId: "msg-a" }),
+      expect.objectContaining({ text: "Gamma", messageId: "msg-b" }),
+    ]);
+    expect(result.lines.map((line) => JSON.parse(line).sequence)).toEqual([11, 12]);
+  });
+
+  it("rebuilds three SDK assistant messages without breaking idempotency", () => {
+    const input = [
+      textEnvelope("Alpha", "wire-1", { sequence: 21 }),
+      textEnvelope("Beta", "wire-2", { sequence: 22 }),
+      textEnvelope("Gamma", "wire-3", { sequence: 23 }),
+    ];
+    const sdkMessages = [
+      assistantMessage("msg-a", "Alpha"),
+      assistantMessage("msg-b", "Beta"),
+      assistantMessage("msg-c", "Gamma"),
+    ];
+    const once = repairSplicedEnvelopeLines(input, sdkMessages);
+    const twice = repairSplicedEnvelopeLines(once.lines, sdkMessages);
+
+    expect(once.lines.map((line) => JSON.parse(line).event.messageId)).toEqual(["msg-a", "msg-b", "msg-c"]);
+    expect(twice).toEqual({ lines: once.lines, changed: false, repairedTurns: 0 });
+  });
+
+  it("falls back to a local merge when SDK messages cover only a prefix of the run", () => {
+    // The SDK transcript is missing the run's tail (" the SDK"). A rebuild from
+    // the partial SDK match would silently drop that tail — the repair must
+    // prefer the lossless local merge instead.
+    const input = splicedRun();
+    const result = repairSplicedEnvelopeLines(input, [assistantMessage("msg-prefix", "Hello from")]);
+    expect(result.lines).toHaveLength(1);
+    expect(JSON.parse(result.lines[0]!).event).toMatchObject({
+      text: "Hello from the SDK",
+      messageId: "wire-1",
+    });
+  });
+
+  it("falls back to a local merge when SDK text does not overlap", () => {
+    const input = splicedRun();
+    const result = repairSplicedEnvelopeLines(input, [assistantMessage("msg-other", "Unrelated")]);
+    expect(result.lines).toHaveLength(1);
+    expect(JSON.parse(result.lines[0]!).event).toMatchObject({
+      text: "Hello from the SDK",
+      messageId: "wire-1",
+    });
+  });
+
+  it("is idempotent and byte-identical on the second pass", () => {
+    const once = repairSplicedEnvelopeLines(splicedRun(), [assistantMessage("msg-stable", "Hello from the SDK")]);
+    const twice = repairSplicedEnvelopeLines(once.lines, [assistantMessage("msg-stable", "Hello from the SDK")]);
+    expect(twice.changed).toBe(false);
+    expect(twice.repairedTurns).toBe(0);
+    expect(twice.lines).toEqual(once.lines);
+  });
+});
+
+describe("repairSplicedEnvelopeFileSync", () => {
+  let directory: string;
+
+  beforeEach(() => {
+    directory = fs.mkdtempSync(path.join(os.tmpdir(), "chat-envelope-splice-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(directory, { recursive: true, force: true });
+  });
+
+  it("atomically rewrites and keeps the original one-time backup", () => {
+    const filePath = path.join(directory, "chat.jsonl");
+    const original = `${splicedRun().join("\n")}\n`;
+    fs.writeFileSync(filePath, original, "utf8");
+
+    expect(repairSplicedEnvelopeFileSync(filePath, [assistantMessage("msg-stable", "Hello from the SDK")]))
+      .toEqual({ changed: true, repairedTurns: 1 });
+    expect(fs.readFileSync(`${filePath}.splice.bak`, "utf8")).toBe(original);
+    expect(fs.readFileSync(filePath, "utf8").endsWith("\n")).toBe(true);
+    expect(fs.readdirSync(directory).some((name) => name.includes(".tmp"))).toBe(false);
+
+    const firstBackup = fs.readFileSync(`${filePath}.splice.bak`, "utf8");
+    fs.writeFileSync(filePath, original.replaceAll("wire-", "again-"), "utf8");
+    expect(repairSplicedEnvelopeFileSync(filePath, [])).toEqual({ changed: true, repairedTurns: 1 });
+    expect(fs.readFileSync(`${filePath}.splice.bak`, "utf8")).toBe(firstBackup);
+  });
+
+  it("skips a file larger than 64 MB", () => {
+    const filePath = path.join(directory, "oversize.jsonl");
+    fs.writeFileSync(filePath, "", "utf8");
+    fs.truncateSync(filePath, 64 * 1024 * 1024 + 1);
+    const skips: string[] = [];
+    expect(repairSplicedEnvelopeFileSync(filePath, [], { onSkip: (reason) => skips.push(reason) }))
+      .toEqual({ changed: false, repairedTurns: 0 });
+    expect(skips).toEqual(["oversize"]);
+    expect(fs.existsSync(`${filePath}.splice.bak`)).toBe(false);
+  });
+
+  it("returns a no-op for a missing file", () => {
+    expect(repairSplicedEnvelopeFileSync(path.join(directory, "missing.jsonl"), []))
+      .toEqual({ changed: false, repairedTurns: 0 });
+  });
+});
diff --git a/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.ts b/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.ts
new file mode 100644
index 000000000..51aff43e0
--- /dev/null
+++ b/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.ts
@@ -0,0 +1,228 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import type { SessionMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { AgentChatEventEnvelope } from "../../../shared/types/chat";
+
+const MAX_ENVELOPE_REPAIR_BYTES = 64 * 1024 * 1024;
+
+export type ChatEnvelopeSpliceRepairResult = {
+  changed: boolean;
+  repairedTurns: number;
+};
+
+const NO_REPAIR: ChatEnvelopeSpliceRepairResult = { changed: false, repairedTurns: 0 };
+
+type ParsedTextEnvelope = {
+  envelope: AgentChatEventEnvelope;
+  messageId: string;
+  text: string;
+  turnId: string;
+};
+
+type SdkAssistantMessage = {
+  id: string;
+  text: string;
+  normalizedText: string;
+};
+
+function parseTextEnvelope(line: string): ParsedTextEnvelope | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const envelope = parsed as AgentChatEventEnvelope;
+  if (!envelope.event || envelope.event.type !== "text") return null;
+  const turnId = envelope.event.turnId?.trim() ?? "";
+  const messageId = envelope.event.messageId?.trim() ?? "";
+  if (!turnId || !messageId || typeof envelope.event.text !== "string") return null;
+  return { envelope, messageId, text: envelope.event.text, turnId };
+}
+
+function normalizeText(value: string): string {
+  return value.normalize("NFKC").replace(/\s+/g, "");
+}
+
+function extractSdkMessageId(message: SessionMessage): string | null {
+  const payload = message.message;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
+  const id = (payload as { id?: unknown }).id;
+  return typeof id === "string" && id.trim().length ? id.trim() : null;
+}
+
+function extractSdkAssistantText(message: SessionMessage): string {
+  const payload = message.message;
+  if (typeof payload === "string") return payload;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return "";
+  const content = (payload as { content?: unknown }).content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.flatMap((block) => {
+    if (!block || typeof block !== "object" || Array.isArray(block)) return [];
+    const record = block as { type?: unknown; text?: unknown };
+    return record.type === "text" && typeof record.text === "string" ? [record.text] : [];
+  }).join("");
+}
+
+function sdkAssistantMessages(messages: SessionMessage[]): SdkAssistantMessage[] {
+  return messages.flatMap((message) => {
+    if (message.type !== "assistant") return [];
+    const id = extractSdkMessageId(message);
+    const text = extractSdkAssistantText(message);
+    const normalizedText = normalizeText(text);
+    return id && normalizedText ? [{ id, text, normalizedText }] : [];
+  });
+}
+
+function findSdkMatch(
+  runText: string,
+  messages: SdkAssistantMessage[],
+  startAt: number,
+): { messages: SdkAssistantMessage[]; nextIndex: number } | null {
+  const normalizedRun = normalizeText(runText);
+  if (!normalizedRun) return null;
+
+  for (let start = startAt; start < messages.length; start += 1) {
+    let combined = "";
+    for (let end = start; end < messages.length; end += 1) {
+      combined = normalizeText(`${combined}${messages[end]!.normalizedText}`);
+      if (combined === normalizedRun || combined.startsWith(normalizedRun)) {
+        return { messages: messages.slice(start, end + 1), nextIndex: end + 1 };
+      }
+      // Partial coverage (SDK text is only a prefix of the run) must NOT win:
+      // rebuilding from it would drop the run's uncovered tail. Keep scanning
+      // while the SDK side could still complete the run, otherwise move on and
+      // let the caller fall back to the lossless local merge.
+      if (normalizedRun.startsWith(combined)) continue;
+      break;
+    }
+  }
+  return null;
+}
+
+function rebuiltLine(
+  first: AgentChatEventEnvelope,
+  messageId: string,
+  text: string,
+  sequenceOffset = 0,
+): string {
+  const event = first.event.type === "text"
+    ? { ...first.event, text, messageId }
+    : first.event;
+  const envelope: AgentChatEventEnvelope = {
+    ...first,
+    event,
+    ...(typeof first.sequence === "number" ? { sequence: first.sequence + sequenceOffset } : {}),
+  };
+  return JSON.stringify(envelope);
+}
+
+/**
+ * Repair the historical Claude stream-fragment splice signature in ADE JSONL.
+ * Unknown/non-envelope lines and every non-text envelope are retained verbatim.
+ */
+export function repairSplicedEnvelopeLines(
+  lines: string[],
+  sdkMessages: SessionMessage[],
+): { lines: string[]; changed: boolean; repairedTurns: number } {
+  const assistants = sdkAssistantMessages(sdkMessages);
+  const output: string[] = [];
+  let sdkCursor = 0;
+  const repairedTurnIds = new Set<string>();
+
+  for (let index = 0; index < lines.length;) {
+    const first = parseTextEnvelope(lines[index] ?? "");
+    if (!first) {
+      output.push(lines[index] ?? "");
+      index += 1;
+      continue;
+    }
+
+    const run: ParsedTextEnvelope[] = [first];
+    let nextIndex = index + 1;
+    while (nextIndex < lines.length) {
+      const next = parseTextEnvelope(lines[nextIndex] ?? "");
+      if (!next || next.turnId !== first.turnId) break;
+      run.push(next);
+      nextIndex += 1;
+    }
+
+    const distinctIds = new Set(run.map((entry) => entry.messageId));
+    const detected = run.length >= 3 && distinctIds.size === run.length;
+    if (!detected) {
+      output.push(...lines.slice(index, nextIndex));
+      index = nextIndex;
+      continue;
+    }
+
+    const runText = run.map((entry) => entry.text).join("");
+    const sdkMatch = findSdkMatch(runText, assistants, sdkCursor);
+    if (sdkMatch) {
+      output.push(...sdkMatch.messages.map((message, offset) =>
+        rebuiltLine(first.envelope, message.id, message.text, offset)));
+      sdkCursor = sdkMatch.nextIndex;
+    } else {
+      output.push(rebuiltLine(first.envelope, first.messageId, runText));
+    }
+    repairedTurnIds.add(first.turnId);
+    index = nextIndex;
+  }
+
+  const changed = output.length !== lines.length
+    || output.some((line, index) => line !== lines[index]);
+
+  return {
+    lines: changed ? output : lines.slice(),
+    changed,
+    repairedTurns: changed ? repairedTurnIds.size : 0,
+  };
+}
+
+/** Bounded, best-effort, atomic file wrapper. Never throws. */
+export function repairSplicedEnvelopeFileSync(
+  filePath: string,
+  sdkMessages: SessionMessage[],
+  options?: { onSkip?: (reason: "oversize" | "read_failed" | "write_failed", detail?: unknown) => void },
+): ChatEnvelopeSpliceRepairResult {
+  try {
+    if (!filePath || !fs.existsSync(filePath)) return NO_REPAIR;
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) return NO_REPAIR;
+    if (stat.size > MAX_ENVELOPE_REPAIR_BYTES) {
+      options?.onSkip?.("oversize", stat.size);
+      return NO_REPAIR;
+    }
+    const raw = fs.readFileSync(filePath, "utf8");
+    const repaired = repairSplicedEnvelopeLines(raw.split("\n"), sdkMessages);
+    if (!repaired.changed) return NO_REPAIR;
+
+    const backupPath = `${filePath}.splice.bak`;
+    if (!fs.existsSync(backupPath)) {
+      try {
+        fs.copyFileSync(filePath, backupPath);
+      } catch {
+        // Backup is best-effort; the atomic replacement remains safe.
+      }
+    }
+
+    const tempPath = `${filePath}.splice-${process.pid}-${randomUUID()}.tmp`;
+    try {
+      fs.writeFileSync(tempPath, repaired.lines.join("\n"), "utf8");
+      fs.renameSync(tempPath, filePath);
+    } catch (error) {
+      try {
+        if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+      } catch {
+        // Ignore cleanup failure.
+      }
+      options?.onSkip?.("write_failed", error);
+      return NO_REPAIR;
+    }
+    return { changed: true, repairedTurns: repaired.repairedTurns };
+  } catch (error) {
+    options?.onSkip?.("read_failed", error);
+    return NO_REPAIR;
+  }
+}
diff --git a/apps/desktop/src/main/services/ipc/registerIpc.ts b/apps/desktop/src/main/services/ipc/registerIpc.ts
index c78fca4a9..c1c632a3c 100644
--- a/apps/desktop/src/main/services/ipc/registerIpc.ts
+++ b/apps/desktop/src/main/services/ipc/registerIpc.ts
@@ -259,6 +259,7 @@ import type {
   AgentChatClaudeSessionListArgs,
   AgentChatClaudeSessionMessage,
   AgentChatClaudeSessionMessagesArgs,
+  AgentChatMainTranscriptArgs,
   AgentChatSubagentTranscriptArgs,
   AgentChatSubagentTranscriptMessage,
   AgentChatClaudeOutputStyle,
@@ -979,6 +980,7 @@ function projectChatOntoSession(
   const base: TerminalSessionSummary = {
     ...session,
     nextWakeAt: chat.nextWakeAt,
+    ...(chat.claudeTag !== undefined ? { claudeTag: chat.claudeTag } : {}),
     ...(chat.orchestrationRunId
       ? {
           orchestrationRunId: chat.orchestrationRunId,
@@ -6339,6 +6341,14 @@ export function registerIpc({
     return ctx.agentChatService.getClaudeSessionMessages(arg);
   });
 
+  ipcMain.handle(IPC.agentChatGetMainTranscript, async (_event, arg: AgentChatMainTranscriptArgs): Promise<AgentChatSubagentTranscriptMessage[] | null> => {
+    if (!arg || typeof arg.sessionId !== "string" || !arg.sessionId.trim().length) {
+      throw new Error("sessionId is required.");
+    }
+    const ctx = ensureAgentChatContext();
+    return ctx.agentChatService.getMainTranscript(arg);
+  });
+
   ipcMain.handle(IPC.agentChatGetSubagentTranscript, async (_event, arg: AgentChatSubagentTranscriptArgs): Promise<AgentChatSubagentTranscriptMessage[] | null> => {
     const ctx = ensureAgentChatContext();
     return ctx.agentChatService.getSubagentTranscript(arg);
diff --git a/apps/desktop/src/main/services/ipc/runtimeBridge.test.ts b/apps/desktop/src/main/services/ipc/runtimeBridge.test.ts
index e253ffafe..a00dfe6a1 100644
--- a/apps/desktop/src/main/services/ipc/runtimeBridge.test.ts
+++ b/apps/desktop/src/main/services/ipc/runtimeBridge.test.ts
@@ -1829,6 +1829,40 @@ describe("registerIpc sync bridge", () => {
     expect(getChatEventHistory).toHaveBeenCalledWith("chat-1", { maxEvents: 25 });
   });
 
+  it("validates and forwards main transcript requests", async () => {
+    const transcript = [{ type: "assistant", message: { content: [{ type: "text", text: "hello" }] } }];
+    const getMainTranscript = vi.fn(async () => transcript);
+    registerIpc({
+      getCtx: () => ({
+        logger: { warn: vi.fn(), info: vi.fn(), debug: vi.fn(), error: vi.fn() },
+        agentChatService: { getMainTranscript },
+      }) as any,
+      getWindowSession: () => ({
+        windowId: 7,
+        project: { rootPath: "/repo", displayName: "Repo" } as any,
+        binding: localBinding("/repo"),
+      }),
+      switchProjectFromDialog: vi.fn(),
+      closeCurrentProject: vi.fn(),
+      closeProjectByPath: vi.fn(),
+      globalStatePath: "/tmp/ade-state.json",
+    });
+
+    await expect(
+      ipcHandlers.get(IPC.agentChatGetMainTranscript)?.(
+        eventForSender(),
+        { sessionId: "   " },
+      ),
+    ).rejects.toThrow("sessionId is required");
+    expect(getMainTranscript).not.toHaveBeenCalled();
+
+    const args = { sessionId: " chat-1 ", limit: 100, offset: 5 };
+    await expect(
+      ipcHandlers.get(IPC.agentChatGetMainTranscript)?.(eventForSender(), args),
+    ).resolves.toBe(transcript);
+    expect(getMainTranscript).toHaveBeenCalledWith(args);
+  });
+
   it("disposes a live terminal runtime before deleting the session", async () => {
     const terminalSession = {
       id: "terminal-1",
diff --git a/apps/desktop/src/preload/global.d.ts b/apps/desktop/src/preload/global.d.ts
index 1accb8f22..a53a142d4 100644
--- a/apps/desktop/src/preload/global.d.ts
+++ b/apps/desktop/src/preload/global.d.ts
@@ -138,6 +138,7 @@ import type {
   AgentChatClaudeSessionListArgs,
   AgentChatClaudeSessionMessage,
   AgentChatClaudeSessionMessagesArgs,
+  AgentChatMainTranscriptArgs,
   AgentChatSubagentTranscriptArgs,
   AgentChatSubagentTranscriptMessage,
   AgentChatContextUsage,
@@ -1352,6 +1353,9 @@ declare global {
         getClaudeSessionMessages: (
           args: AgentChatClaudeSessionMessagesArgs,
         ) => Promise<AgentChatClaudeSessionMessage[]>;
+        getMainTranscript: (
+          args: AgentChatMainTranscriptArgs,
+        ) => Promise<AgentChatSubagentTranscriptMessage[] | null>;
         getSubagentTranscript: (
           args: AgentChatSubagentTranscriptArgs,
         ) => Promise<AgentChatSubagentTranscriptMessage[] | null>;
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index 714b55c18..cd25c5a6b 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -314,6 +314,7 @@ import type {
   AgentChatClaudeSessionListArgs,
   AgentChatClaudeSessionMessage,
   AgentChatClaudeSessionMessagesArgs,
+  AgentChatMainTranscriptArgs,
   AgentChatSubagentTranscriptArgs,
   AgentChatSubagentTranscriptMessage,
   AgentChatContextUsage,
@@ -5364,6 +5365,12 @@ contextBridge.exposeInMainWorld("ade", {
       callProjectRuntimeActionOr("chat", "getClaudeSessionMessages", { args }, () =>
         ipcRenderer.invoke(IPC.agentChatGetClaudeSessionMessages, args),
       ),
+    getMainTranscript: async (
+      args: AgentChatMainTranscriptArgs,
+    ): Promise<AgentChatSubagentTranscriptMessage[] | null> =>
+      callProjectRuntimeActionOr("chat", "getMainTranscript", { args }, () =>
+        ipcRenderer.invoke(IPC.agentChatGetMainTranscript, args),
+      ),
     getSubagentTranscript: async (
       args: AgentChatSubagentTranscriptArgs,
     ): Promise<AgentChatSubagentTranscriptMessage[] | null> =>
diff --git a/apps/desktop/src/renderer/browserMock.ts b/apps/desktop/src/renderer/browserMock.ts
index b91629fd1..ee746673d 100644
--- a/apps/desktop/src/renderer/browserMock.ts
+++ b/apps/desktop/src/renderer/browserMock.ts
@@ -4741,6 +4741,7 @@ if (typeof window !== "undefined" && shouldInstallBrowserMock(window)) {
       listClaudeSessions: resolvedArg([]),
       getClaudeSessionInfo: resolvedArg(null),
       getClaudeSessionMessages: resolvedArg([]),
+      getMainTranscript: resolvedArg(null),
       getSubagentTranscript: resolvedArg(null),
       getContextUsage: resolvedArg(null),
       rewindFiles: resolvedArg({
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.test.tsx
index 57af247a5..0982b5653 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.test.tsx
@@ -1307,6 +1307,73 @@ describe("AgentChatPane companion drawers", () => {
     expect(screen.queryByRole("button", { name: "Close chat actions drawer" })).toBeNull();
   });
 
+  it("swaps the main chat into the expanded Claude SDK transcript view", async () => {
+    const session = buildSession("session-claude-main", {
+      provider: "claude",
+      model: "claude-sonnet-5",
+      modelId: "anthropic/claude-sonnet-5",
+      status: "idle",
+      claudeTag: "review-ready",
+    });
+    installAdeMocks({ sessions: [session], includeClaudeModel: true });
+    const getMainTranscript = vi.fn().mockResolvedValue([{
+      type: "assistant",
+      uuid: "sdk-message-1",
+      sessionId: "sdk-session-1",
+      parentToolUseId: null,
+      message: {
+        id: "msg-stable-1",
+        role: "assistant",
+        content: [
+          { type: "text", text: "Provider fidelity answer" },
+          { type: "tool_use", id: "toolu-1", name: "Read", input: { file_path: "src/app.tsx" } },
+        ],
+      },
+    }]);
+    window.ade.agentChat.getMainTranscript = getMainTranscript as any;
+    renderPane(session);
+
+    fireEvent.click(await screen.findByRole("button", { name: "Open chat actions drawer" }));
+    fireEvent.click(await screen.findByRole("button", { name: "Agents" }));
+    fireEvent.click(await screen.findByRole("button", { name: "View full session transcript" }));
+
+    expect(await screen.findByText("Full session transcript (SDK)")).toBeTruthy();
+    expect(screen.getByText("Provider-fidelity view — ADE events (approvals, schedules, notices) are not shown.")).toBeTruthy();
+    await waitFor(() => {
+      expect(getMainTranscript).toHaveBeenCalledWith({ sessionId: session.sessionId });
+    });
+    expect(await screen.findByText("Provider fidelity answer")).toBeTruthy();
+    expect(screen.getByText("review-ready")).toBeTruthy();
+    expect(screen.getByRole("button", { name: "Return to chat" })).toBeTruthy();
+  });
+
+  it("refetches selected envelope history after a repair invalidation signal", async () => {
+    const session = buildSession("session-repaired", { status: "idle" });
+    const { emitChatEvent } = installAdeMocks({
+      sessions: [session],
+      eventHistory: {
+        sessionId: session.sessionId,
+        events: [],
+        truncated: false,
+        sessionFound: true,
+      },
+    });
+    const getEventHistory = window.ade.agentChat.getEventHistory as ReturnType<typeof vi.fn>;
+    renderPane(session);
+
+    await waitFor(() => expect(getEventHistory.mock.calls.length).toBeGreaterThan(0));
+    const callsBeforeInvalidation = getEventHistory.mock.calls.length;
+    act(() => {
+      emitChatEvent({
+        sessionId: session.sessionId,
+        timestamp: "2026-07-10T12:00:00.000Z",
+        event: { type: "session_meta_updated", historyInvalidated: true },
+      });
+    });
+
+    await waitFor(() => expect(getEventHistory.mock.calls.length).toBeGreaterThan(callsBeforeInvalidation));
+  });
+
   it("persists split resize from the real divider on a working panel", async () => {
     renderDrawerPane();
 
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
index f4809d5c5..32a3fa1a5 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
@@ -3158,6 +3158,7 @@ export function AgentChatPane({
     status: "running" | "completed" | "failed" | "stopped";
     background: boolean;
   } | null>(null);
+  const [mainTranscriptView, setMainTranscriptView] = useState(false);
   const [rewindConfirmDialog, setRewindConfirmDialog] = useState<RewindFilesConfirmDialogState | null>(null);
   const [cursorCloudLaunchModeOpen, setCursorCloudLaunchModeOpen] = useState(false);
   const cursorCloudPanelRef = useRef<ChatCursorCloudPanelHandle | null>(null);
@@ -3781,6 +3782,9 @@ export function AgentChatPane({
   const [subagentTranscriptLoading, setSubagentTranscriptLoading] = useState(false);
   const [subagentTranscriptUnsupported, setSubagentTranscriptUnsupported] = useState(false);
   const [subagentMetadata, setSubagentMetadata] = useState<AgentChatSubagentMetadata | null>(null);
+  const [mainTranscript, setMainTranscript] = useState<AgentChatSubagentTranscriptMessage[] | null>(null);
+  const [mainTranscriptLoading, setMainTranscriptLoading] = useState(false);
+  const [mainTranscriptUnsupported, setMainTranscriptUnsupported] = useState(false);
 
   // Drill-in (subagent takeover) view-model. Computed here, before any early
   // return, so the useMemo below is an unconditional hook (react-hooks rules).
@@ -3826,6 +3830,19 @@ export function AgentChatPane({
     subagentView,
   ]);
 
+  const mainTranscriptEventsForDisplay = useMemo(() => {
+    if (!mainTranscriptView) return EMPTY_CHAT_EVENTS;
+    return buildSubagentEventHistory({
+      sessionId: selectedSessionId,
+      subagentId: selectedSessionId ?? "main",
+      subagentName: "Full session transcript",
+      prompt: null,
+      messages: mainTranscript,
+      loading: mainTranscriptLoading,
+      unsupported: mainTranscriptUnsupported,
+    });
+  }, [mainTranscript, mainTranscriptLoading, mainTranscriptUnsupported, mainTranscriptView, selectedSessionId]);
+
   useEffect(() => {
     if (!subagentView || !selectedSessionId) {
       setSubagentTranscript(null);
@@ -3885,6 +3902,49 @@ export function AgentChatPane({
     };
   }, [subagentView, subagentViewSnapshot?.status, selectedSessionId]);
 
+  useEffect(() => {
+    if (!mainTranscriptView || !selectedSessionId) {
+      setMainTranscript(null);
+      setMainTranscriptLoading(false);
+      setMainTranscriptUnsupported(false);
+      return;
+    }
+    const fetchTranscript = window.ade?.agentChat?.getMainTranscript;
+    if (typeof fetchTranscript !== "function") {
+      setMainTranscript(null);
+      setMainTranscriptUnsupported(true);
+      return;
+    }
+    let cancelled = false;
+    const tick = async () => {
+      try {
+        setMainTranscriptLoading(true);
+        const result = await fetchTranscript({ sessionId: selectedSessionId });
+        if (cancelled) return;
+        setMainTranscriptUnsupported(result === null);
+        setMainTranscript(result);
+      } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error("agentChat.getMainTranscript failed", error);
+        if (!cancelled) setMainTranscript([]);
+      } finally {
+        if (!cancelled) setMainTranscriptLoading(false);
+      }
+    };
+    void tick();
+    const intervalId = selectedSession?.status === "active"
+      ? window.setInterval(() => { void tick(); }, 1500)
+      : null;
+    return () => {
+      cancelled = true;
+      if (intervalId !== null) window.clearInterval(intervalId);
+    };
+  }, [mainTranscriptView, selectedSession?.status, selectedSessionId]);
+
+  useEffect(() => {
+    setMainTranscriptView(false);
+  }, [selectedSessionId]);
+
   useEffect(() => {
     if (subagentView && !chatActionsOpen) {
       setSubagentView(null);
@@ -3918,6 +3978,7 @@ export function AgentChatPane({
         status: snapshot.status,
         background: snapshot.background ?? false,
       });
+      setMainTranscriptView(false);
     };
     window.addEventListener("ade:chat:open-info", handler);
     return () => window.removeEventListener("ade:chat:open-info", handler);
@@ -4716,8 +4777,11 @@ export function AgentChatPane({
         tone: "muted",
       });
     }
+    if (selectedSession?.claudeTag?.trim()) {
+      chips.push({ label: selectedSession.claudeTag.trim(), tone: "muted" });
+    }
     return chips;
-  }, [resolvedChips, selectedSessionImportedProvider]);
+  }, [resolvedChips, selectedSession?.claudeTag, selectedSessionImportedProvider]);
 
   // Keep configured models selectable unless a caller explicitly constrains
   // this surface. Unconstrained sessions keep their active model visible even
@@ -6113,8 +6177,12 @@ export function AgentChatPane({
       // chat event since it doesn't represent transcript content.
       if (envelope.event.type === "session_meta_updated") {
         const meta = envelope.event;
+        if (meta.historyInvalidated === true && envelope.sessionId === selectedSessionIdRef.current) {
+          void loadHistory(envelope.sessionId, { force: true });
+        }
         const summaryPatch: Partial<AgentChatSessionSummary> = {};
         if (typeof meta.title === "string" && meta.title.length > 0) summaryPatch.title = meta.title;
+        if (meta.claudeTag !== undefined) summaryPatch.claudeTag = meta.claudeTag;
         if (meta.permissionMode !== undefined) summaryPatch.permissionMode = meta.permissionMode;
         if (meta.interactionMode !== undefined) summaryPatch.interactionMode = meta.interactionMode;
         if (meta.claudePermissionMode !== undefined) summaryPatch.claudePermissionMode = meta.claudePermissionMode;
@@ -6313,7 +6381,7 @@ export function AgentChatPane({
       }
     });
     return unsubscribe;
-  }, [clearPromptSuggestionForSession, isRemoteProject, isTileVisible, layoutVariant, lockSessionId, flushQueuedEvents, patchSessionSummary, scheduleQueuedEventFlush, scheduleSessionsRefresh, touchSession]);
+  }, [clearPromptSuggestionForSession, isRemoteProject, isTileVisible, layoutVariant, loadHistory, lockSessionId, flushQueuedEvents, patchSessionSummary, scheduleQueuedEventFlush, scheduleSessionsRefresh, touchSession]);
 
   useEffect(() => {
     if (!isTileActive) return undefined;
@@ -9324,7 +9392,9 @@ export function AgentChatPane({
   const ChatActionsToolbarIcon = chatActionsToolbarIcon;
   const proofArtifactCount = computerUseSnapshot?.artifacts?.length ?? 0;
   const proofSessionId = selectedSessionId ?? "";
-  const agentsTabContent = selectedSubagentPaneAvailable || selectedTodoItems.length > 0 || selectedScheduledWorkSnapshots.length > 0 ? (
+  const canViewMainTranscript = selectedSession?.provider === "claude"
+    && selectedSubagentCapability.canViewFullTranscript;
+  const agentsTabContent = selectedSubagentPaneAvailable || selectedTodoItems.length > 0 || selectedScheduledWorkSnapshots.length > 0 || canViewMainTranscript ? (
     <ChatSubagentsPanel
       sessionId={selectedSessionId}
       snapshots={selectedSubagentSnapshots}
@@ -9350,6 +9420,7 @@ export function AgentChatPane({
       variant="pane"
       className="h-full"
       onSelectSubagent={(selection) => {
+        setMainTranscriptView(false);
         setSubagentView({
           taskId: selection.taskId,
           agentId: selection.agentId,
@@ -9359,6 +9430,10 @@ export function AgentChatPane({
         });
       }}
       onClearSelectedSubagent={() => setSubagentView(null)}
+      onViewMainTranscript={canViewMainTranscript ? () => {
+        setSubagentView(null);
+        setMainTranscriptView(true);
+      } : undefined}
       probeSubagentTranscript={probeSubagentTranscript}
       capability={selectedSubagentCapability}
       selectedTaskId={subagentView?.taskId ?? null}
@@ -10129,14 +10204,16 @@ export function AgentChatPane({
             permissionModeLocked={permissionModeLocked || identitySessionSettingsBusy || projectTransitionBlocksChat}
             hideNativeControls={hideNativeControls}
             messagePlaceholder={effectiveMessagePlaceholder}
-            inputLockMessage={subagentView
-              ? `Viewing ${subagentMetadata?.label
+            inputLockMessage={mainTranscriptView
+              ? "Viewing full session transcript"
+              : subagentView
+                ? `Viewing ${subagentMetadata?.label
                 ?? subagentMetadata?.agentNickname
                 ?? subagentView.agentType
                 ?? subagentViewSnapshot?.description
                 ?? subagentView.agentId
                 ?? subagentView.taskId}`
-              : null}
+                : null}
             onExecutionModeChange={handleExecutionModeChange}
             onInteractionModeChange={(value) => { void updateNativeControls({ interactionMode: value }); }}
             onClaudeModeChange={handleClaudeModeChange}
@@ -10928,16 +11005,37 @@ export function AgentChatPane({
                         Live view of Cursor Cloud agent. Replies run in cloud.
                       </div>
                     ) : null}
+                    {mainTranscriptView ? (
+                      <div className="flex shrink-0 items-center justify-between gap-3 border-b border-white/[0.06] bg-white/[0.02] px-4 py-2 font-sans">
+                        <div className="min-w-0">
+                          <div className="truncate text-[11px] font-medium text-fg/80">Full session transcript (SDK)</div>
+                          <div className="truncate text-[10px] text-fg/40">Provider-fidelity view — ADE events (approvals, schedules, notices) are not shown.</div>
+                        </div>
+                        <button
+                          type="button"
+                          onClick={() => setMainTranscriptView(false)}
+                          className="shrink-0 rounded-sm border border-white/[0.08] px-2 py-1 text-[10px] text-fg/55 transition-colors hover:bg-white/[0.05] hover:text-fg/80"
+                        >
+                          Return to chat
+                        </button>
+                      </div>
+                    ) : null}
                     {/* Codex chat goal is rendered in the Agents tab via
                         ChatSubagentsPanel; the in-chat banner was removed so
                         the chat header stays clean and goal context lives next
                         to subagents + progress where it belongs. */}
                     <AgentChatMessageList
-                      key={subagentView ? `subagent-${subagentView.taskId}` : selectedSessionId ?? "chat-draft"}
-                      events={subagentView ? subagentEventsForDisplay : selectedEventsForDisplay}
-                      showStreamingIndicator={subagentView
-                        ? subagentTranscriptLoading || subagentViewSnapshot?.status === "running"
-                        : turnActive && selectedSession?.status !== "ended"}
+                      key={mainTranscriptView
+                        ? `main-transcript-${selectedSessionId}`
+                        : subagentView ? `subagent-${subagentView.taskId}` : selectedSessionId ?? "chat-draft"}
+                      events={mainTranscriptView
+                        ? mainTranscriptEventsForDisplay
+                        : subagentView ? subagentEventsForDisplay : selectedEventsForDisplay}
+                      showStreamingIndicator={mainTranscriptView
+                        ? mainTranscriptLoading || selectedSession?.status === "active"
+                        : subagentView
+                          ? subagentTranscriptLoading || subagentViewSnapshot?.status === "running"
+                          : turnActive && selectedSession?.status !== "ended"}
                       sessionEnded={selectedSession?.status === "ended"}
                       className="min-h-0 border-0"
                       surfaceMode={surfaceMode}
@@ -10945,15 +11043,17 @@ export function AgentChatPane({
                       assistantLabel={assistantLabel}
                       hasOlderHistory={Boolean(
                         !subagentView
+                        && !mainTranscriptView
                         && selectedSessionId
                         && (olderHistoryCursorBySession[selectedSessionId] ?? 0) > 0,
                       )}
                       loadingOlderHistory={Boolean(
                         !subagentView
+                        && !mainTranscriptView
                         && selectedSessionId
                         && olderHistoryLoadingBySession[selectedSessionId],
                       )}
-                      onLoadOlderHistory={!subagentView && selectedSessionId ? loadOlderHistoryForSelectedSession : undefined}
+                      onLoadOlderHistory={!subagentView && !mainTranscriptView && selectedSessionId ? loadOlderHistoryForSelectedSession : undefined}
                       respondingApprovalIds={respondingApprovalIds}
                       pendingApprovalIds={pendingApprovalIds}
                       laneId={laneId}
@@ -10969,8 +11069,8 @@ export function AgentChatPane({
                       }}
                       onCodexRecovery={(args: AgentChatRecoverCodexTurnArgs) =>
                         window.ade.agentChat.recoverCodexTurn(args)}
-                      mosaic={subagentView ? undefined : mosaicContext}
-                      scrollToRowKeyRequest={subagentView ? null : wakeJumpRequest}
+                      mosaic={subagentView || mainTranscriptView ? undefined : mosaicContext}
+                      scrollToRowKeyRequest={subagentView || mainTranscriptView ? null : wakeJumpRequest}
                     />
                     {sessionDelta ? (
                       <div className="flex items-center gap-3 border-t border-white/[0.05] px-4 py-2 font-mono text-[11px]">
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
index 8f55f55c9..739e3d3a6 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
@@ -834,6 +834,7 @@ export function ChatSubagentsPanel({
   backgroundItems = [],
   schedulesPaused = false,
   onToggleSchedulesPaused,
+  onViewMainTranscript,
 }: {
   sessionId?: string | null;
   snapshots: ChatSubagentSnapshot[];
@@ -866,6 +867,8 @@ export function ChatSubagentsPanel({
   schedulesPaused?: boolean;
   /** Pause or resume all durable schedules for this chat. */
   onToggleSchedulesPaused?: () => void;
+  /** Opens the provider-fidelity transcript for the parent Claude session. */
+  onViewMainTranscript?: () => void;
 }) {
   const [expanded, setExpanded] = useState(false);
   const [paneUi, setPaneUi] = useState<PaneUiStorageState>(() => readPaneUiState(sessionId));
@@ -1508,6 +1511,18 @@ export function ChatSubagentsPanel({
         </div>
       ) : null}
 
+      {onViewMainTranscript ? (
+        <div className="mt-auto border-t border-white/[0.04] px-3 py-2">
+          <button
+            type="button"
+            onClick={onViewMainTranscript}
+            className="text-[10.5px] text-fg/40 transition-colors hover:text-fg/70"
+          >
+            View full session transcript
+          </button>
+        </div>
+      ) : null}
+
     </div>
   );
 
diff --git a/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx b/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx
index fed840122..84e752b3a 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionCard.test.tsx
@@ -106,6 +106,20 @@ describe("SessionCard orchestration identity", () => {
 
     expect(screen.queryByLabelText("Awaiting your input")).toBeNull();
   });
+
+  it("renders a Claude session tag beside the title", () => {
+    render(
+      <SessionCard
+        session={makeSession({ toolType: "claude-chat", claudeTag: "customer-ready" })}
+        lane={lane}
+        isSelected={false}
+        onSelect={vi.fn()}
+        onContextMenu={vi.fn()}
+      />,
+    );
+
+    expect(screen.getByText("customer-ready").getAttribute("title")).toBe("customer-ready");
+  });
 });
 
 describe("SessionCard auto-naming status", () => {
diff --git a/apps/desktop/src/renderer/components/terminals/SessionCard.tsx b/apps/desktop/src/renderer/components/terminals/SessionCard.tsx
index d53397c0e..c08ff967a 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionCard.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionCard.tsx
@@ -365,6 +365,17 @@ export const SessionCard = React.memo(function SessionCard({
               >
                 {primaryText}
               </span>
+              {session.claudeTag?.trim() ? (
+                <span
+                  className={cn(
+                    "inline-flex max-w-[96px] shrink-0 truncate rounded-full border border-white/[0.08] bg-white/[0.03] px-1.5 py-0.5 font-mono text-fg/50",
+                    compact ? "text-[8px]" : "text-[9px]",
+                  )}
+                  title={session.claudeTag.trim()}
+                >
+                  {session.claudeTag.trim()}
+                </span>
+              ) : null}
               {attentionBadge ? <AttentionCapsule badge={attentionBadge} compact={compact} /> : null}
               <div className="flex shrink-0 items-center gap-1.5">
                 {importedFrom ? (
diff --git a/apps/desktop/src/renderer/components/terminals/SessionContextMenu.test.tsx b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.test.tsx
new file mode 100644
index 000000000..b121ec597
--- /dev/null
+++ b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.test.tsx
@@ -0,0 +1,76 @@
+/* @vitest-environment jsdom */
+
+import React from "react";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { TerminalSessionSummary } from "../../../shared/types";
+import { SessionContextMenu } from "./SessionContextMenu";
+
+afterEach(cleanup);
+
+function makeSession(overrides: Partial<TerminalSessionSummary> = {}): TerminalSessionSummary {
+  return {
+    id: "chat-1",
+    laneId: "lane-1",
+    laneName: "Lane 1",
+    ptyId: null,
+    tracked: true,
+    pinned: false,
+    goal: null,
+    toolType: "claude-chat",
+    title: "Claude chat",
+    status: "running",
+    startedAt: "2026-07-10T12:00:00.000Z",
+    endedAt: null,
+    exitCode: null,
+    transcriptPath: "",
+    headShaStart: null,
+    headShaEnd: null,
+    lastOutputPreview: null,
+    summary: null,
+    runtimeState: "idle",
+    resumeCommand: null,
+    ...overrides,
+  };
+}
+
+function renderMenu(session: TerminalSessionSummary, onSetChatTag = vi.fn()) {
+  const onClose = vi.fn();
+  render(
+    <SessionContextMenu
+      menu={{ session, x: 20, y: 20 }}
+      onClose={onClose}
+      onStopRuntime={vi.fn()}
+      onStopAndDelete={vi.fn()}
+      onDeleteChat={vi.fn()}
+      onDeleteSession={vi.fn()}
+      deletingSessionId={null}
+      onGoToLane={vi.fn()}
+      onCopySessionId={vi.fn()}
+      onRename={vi.fn()}
+      onSetChatTag={onSetChatTag}
+    />,
+  );
+  return { onClose, onSetChatTag };
+}
+
+describe("SessionContextMenu Claude tags", () => {
+  it("opens an inline input and treats an empty submit as clearing the tag", () => {
+    const session = makeSession({ claudeTag: "review-ready" });
+    const { onClose, onSetChatTag } = renderMenu(session);
+
+    fireEvent.click(screen.getByRole("button", { name: "Set tag…" }));
+    const input = screen.getByRole("textbox", { name: "Set Claude session tag" }) as HTMLInputElement;
+    expect(input.value).toBe("review-ready");
+    fireEvent.change(input, { target: { value: "   " } });
+    fireEvent.keyDown(input, { key: "Enter" });
+
+    expect(onSetChatTag).toHaveBeenCalledWith(session, null);
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not offer SDK tags for non-Claude chat sessions", () => {
+    renderMenu(makeSession({ toolType: "codex-chat" }));
+    expect(screen.queryByRole("button", { name: "Set tag…" })).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx
index 71fdaa0e2..5bfed2538 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx
@@ -20,6 +20,7 @@ type SessionContextMenuProps = {
   onGoToLane: (session: TerminalSessionSummary) => void;
   onCopySessionId: (id: string) => void;
   onRename: (session: TerminalSessionSummary, newTitle: string) => void;
+  onSetChatTag?: (session: TerminalSessionSummary, tag: string | null) => void;
   onCopySessionDeepLink?: (session: TerminalSessionSummary) => void;
   onOpenSessionInWeb?: (session: TerminalSessionSummary) => void;
   onTogglePinned?: (session: TerminalSessionSummary) => void;
@@ -40,6 +41,7 @@ export function SessionContextMenu({
   onGoToLane,
   onCopySessionId,
   onRename,
+  onSetChatTag,
   onCopySessionDeepLink,
   onOpenSessionInWeb,
   onTogglePinned,
@@ -48,28 +50,30 @@ export function SessionContextMenu({
   onRemoveFromGrid,
 }: SessionContextMenuProps) {
   const [renaming, setRenaming] = useState(false);
+  const [tagging, setTagging] = useState(false);
   const [draft, setDraft] = useState("");
   const inputRef = useRef<HTMLInputElement>(null);
   const finalizedRef = useRef(false);
   const { ref: menuRef, position: clampedPosition } = useClampedFixedPosition(
     menu ? { x: menu.x, y: menu.y } : null,
-    renaming,
+    renaming || tagging,
   );
 
-  // Reset rename state when menu changes
+  // Reset inline edit state when the target menu changes.
   useEffect(() => {
     setRenaming(false);
+    setTagging(false);
     setDraft("");
     finalizedRef.current = false;
   }, [menu]);
 
-  // Focus input when entering rename mode
+  // Focus whichever inline editor was opened.
   useEffect(() => {
-    if (renaming && inputRef.current) {
+    if ((renaming || tagging) && inputRef.current) {
       inputRef.current.focus();
       inputRef.current.select();
     }
-  }, [renaming]);
+  }, [renaming, tagging]);
 
   if (!menu) return null;
 
@@ -87,6 +91,13 @@ export function SessionContextMenu({
     }
     onClose();
   };
+  const commitTag = () => {
+    if (finalizedRef.current) return;
+    finalizedRef.current = true;
+    const trimmed = draft.trim();
+    onSetChatTag?.(session, trimmed.length ? trimmed : null);
+    onClose();
+  };
 
   return (
     <>
@@ -122,7 +133,26 @@ export function SessionContextMenu({
             />
           </div>
         )}
-        {!renaming && (
+        {tagging && (
+          <div className="px-3 py-1.5">
+            <input
+              ref={inputRef}
+              type="text"
+              aria-label="Set Claude session tag"
+              value={draft}
+              onChange={(e) => setDraft(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") { e.preventDefault(); commitTag(); }
+                if (e.key === "Escape") { e.preventDefault(); finalizedRef.current = true; onClose(); }
+              }}
+              onBlur={commitTag}
+              className="w-full rounded border border-border/30 bg-transparent px-2 py-1 text-xs text-[--color-fg] outline-none focus:border-[--color-accent]"
+              placeholder="Tag (empty clears)..."
+              maxLength={48}
+            />
+          </div>
+        )}
+        {!renaming && !tagging && (
           <button
             className="flex w-full items-center gap-2 rounded px-3 py-1.5 text-left text-xs hover:bg-muted/40 transition-colors"
             onClick={() => { setDraft(session.title); setRenaming(true); }}
@@ -130,6 +160,18 @@ export function SessionContextMenu({
             Rename
           </button>
         )}
+        {!renaming && !tagging && session.toolType === "claude-chat" && onSetChatTag ? (
+          <button
+            className="flex w-full items-center gap-2 rounded px-3 py-1.5 text-left text-xs hover:bg-muted/40 transition-colors"
+            onClick={() => {
+              finalizedRef.current = false;
+              setDraft(session.claudeTag ?? "");
+              setTagging(true);
+            }}
+          >
+            Set tag…
+          </button>
+        ) : null}
 
         {isRunning && session.ptyId && !isChat ? (
           <button
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx b/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
index 7b7afc19d..6cbd93c7f 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
@@ -1168,6 +1168,22 @@ export function TerminalsPage({ active = true }: { active?: boolean }) {
         pinnedSessionIds={work.pinnedSessionIds}
         gridSessionIds={gridSessionIds}
         onRemoveFromGrid={(session) => handleRemoveSessionFromGrid(session.id)}
+        onSetChatTag={(session, tag) => {
+          setSessionActionError(null);
+          window.ade.agentChat.updateSession({ sessionId: session.id, tag })
+            .then(() => {
+              invalidateSessionListCache();
+              work.refresh({ showLoading: false, force: true }).catch((refreshErr: unknown) => {
+                console.error("[TerminalsPage] refresh after tag failed", { sessionId: session.id, refreshErr });
+              });
+            })
+            .catch((err: unknown) => {
+              const message = err instanceof Error ? err.message : String(err);
+              console.error("[TerminalsPage] set session tag failed", { sessionId: session.id, err });
+              setSessionActionError(`Set tag failed: ${message}`);
+              window.setTimeout(() => setSessionActionError(null), 6000);
+            });
+        }}
         onRename={(session, newTitle) => {
           setSessionActionError(null);
           const renamePromise = isChatToolType(session.toolType)
diff --git a/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts b/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts
index 881b6c1ee..c8d0db855 100644
--- a/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts
+++ b/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts
@@ -1414,6 +1414,41 @@ describe("useWorkSessions — refresh-before-focus ordering", () => {
     expect(result.current.endedFiltered.map((s) => s.id)).toEqual(["session-ended"]);
   });
 
+  it("includes Claude session tags in the Work sidebar search", async () => {
+    const taggedSession = makeSession("session-tagged", "lane-1", {
+      title: "Unrelated title",
+      claudeTag: "customer-ready",
+    });
+    const untaggedSession = makeSession("session-untagged", "lane-1", {
+      title: "Another title",
+    });
+    listSessionsCachedMock.mockResolvedValue([taggedSession, untaggedSession]);
+    fakeAppStoreState = {
+      ...fakeAppStoreState,
+      workViewByProject: {
+        "/fake/project": {
+          openItemIds: [],
+          activeItemId: null,
+          selectedItemId: null,
+          draftKind: "chat",
+          laneFilter: "all",
+          statusFilter: "all",
+          search: "customer-ready",
+          sessionListOrganization: "by-lane",
+          workCollapsedLaneIds: [],
+          workCollapsedTabGroupIds: [],
+          workFocusSessionsHidden: false,
+        },
+      },
+    };
+
+    const { result } = renderHook(() => useWorkSessions());
+
+    await waitFor(() => {
+      expect(result.current.filtered.map((session) => session.id)).toEqual(["session-tagged"]);
+    });
+  });
+
   it("reapplies the same stale-session URL filters after navigating to a valid session and back", async () => {
     const session = {
       id: "session-2",
diff --git a/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts b/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
index 364e2a614..bcc5cb46a 100644
--- a/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
+++ b/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
@@ -1266,6 +1266,7 @@ export function useWorkSessions({ active = true }: UseWorkSessionsOptions = {})
         (session.toolType ?? "").toLowerCase().includes(needle) ||
         (session.lastOutputPreview ?? "").toLowerCase().includes(needle) ||
         (session.summary ?? "").toLowerCase().includes(needle) ||
+        (session.claudeTag ?? "").toLowerCase().includes(needle) ||
         (session.resumeCommand ?? "").toLowerCase().includes(needle)
       );
     });
diff --git a/apps/desktop/src/shared/ipc.ts b/apps/desktop/src/shared/ipc.ts
index 7254f8394..effd8a908 100644
--- a/apps/desktop/src/shared/ipc.ts
+++ b/apps/desktop/src/shared/ipc.ts
@@ -216,6 +216,7 @@ export const IPC = {
   agentChatListClaudeSessions: "ade.agentChat.claudeSessions.list",
   agentChatGetClaudeSessionInfo: "ade.agentChat.claudeSessions.info",
   agentChatGetClaudeSessionMessages: "ade.agentChat.claudeSessions.messages",
+  agentChatGetMainTranscript: "ade.agentChat.getMainTranscript",
   agentChatGetSubagentTranscript: "ade.agentChat.getSubagentTranscript",
   agentChatGetContextUsage: "ade.agentChat.getContextUsage",
   agentChatRewindFiles: "ade.agentChat.rewindFiles",
diff --git a/apps/desktop/src/shared/types/chat.ts b/apps/desktop/src/shared/types/chat.ts
index 257871767..4d0f14c99 100644
--- a/apps/desktop/src/shared/types/chat.ts
+++ b/apps/desktop/src/shared/types/chat.ts
@@ -973,6 +973,9 @@ export type AgentChatEvent =
       type: "session_meta_updated";
       title?: string;
       manuallyNamed?: boolean;
+      claudeTag?: string | null;
+      /** Signals that persisted envelope history changed and open views must refetch. */
+      historyInvalidated?: boolean;
       // Permission/interaction mode fields — emitted when a client (e.g. iOS)
       // changes the mode via updateSession so other renderers patch their
       // composer state without waiting for a turn-lifecycle event. All optional
@@ -1237,6 +1240,8 @@ export type AgentChatSessionSummary = {
   lastActivityAt: string;
   lastOutputPreview: string | null;
   summary: string | null;
+  /** First tag mirrored from the backing Claude SDK session pointer. */
+  claudeTag?: string | null;
   awaitingInput?: boolean;
   pendingInputItemId?: string | null;
   /** Earliest armed, unpaused schedule for this chat. */
@@ -1460,6 +1465,13 @@ export type AgentChatSubagentTranscriptArgs = {
   offset?: number | null;
 };
 
+export type AgentChatMainTranscriptArgs = {
+  /** ADE chat session id; the service resolves the backing Claude SDK session. */
+  sessionId: string;
+  limit?: number | null;
+  offset?: number | null;
+};
+
 /**
  * One subagent transcript entry. Shape mirrors AgentChatClaudeSessionMessage
  * (the SDK's `SessionMessage` is identical for parent sessions and subagent
diff --git a/apps/desktop/src/shared/types/sessions.ts b/apps/desktop/src/shared/types/sessions.ts
index b4ee26b9a..e04dc5e0d 100644
--- a/apps/desktop/src/shared/types/sessions.ts
+++ b/apps/desktop/src/shared/types/sessions.ts
@@ -111,6 +111,8 @@ export type TerminalSessionSummary = {
   chatIdleSinceAt?: string | null;
   /** Earliest armed, unpaused scheduled wake for chat-backed sessions. */
   nextWakeAt?: string | null;
+  /** First tag mirrored from the backing Claude SDK session pointer. */
+  claudeTag?: string | null;
   /** Owner session id for attached terminals, historically a parent chat id and now also a tracked CLI session id. */
   chatSessionId?: string | null;
   /**
diff --git a/apps/desktop/src/shared/types/sync.ts b/apps/desktop/src/shared/types/sync.ts
index 608c76f85..bb57b3913 100644
--- a/apps/desktop/src/shared/types/sync.ts
+++ b/apps/desktop/src/shared/types/sync.ts
@@ -1006,6 +1006,7 @@ export type SyncRemoteCommandAction =
   | "chat.getChatEventHistory"
   | "chat.listSubagents"
   | "chat.getSubagentTranscript"
+  | "chat.getMainTranscript"
   | "chat.create"
   | "chat.send"
   | "chat.interrupt"
diff --git a/docs/features/chat/README.md b/docs/features/chat/README.md
index d1bcfb57d..37b391c4e 100644
--- a/docs/features/chat/README.md
+++ b/docs/features/chat/README.md
@@ -30,6 +30,7 @@ for its separate RPC, sync, storage, and UI contracts.
 | `apps/desktop/src/main/services/chat/buildClaudeV2Message.ts` | Builds Claude SDK user messages for the `query()` input stream. Handles base64 image content blocks and MIME inference. |
 | `apps/desktop/src/main/services/chat/claudeInputPump.ts` | Async iterable input pump that feeds live user turns into the Claude Agent SDK `query()` stream. |
 | `apps/desktop/src/main/services/chat/claudeThinkingTranscriptRepair.ts` | Best-effort repair for Claude SDK JSONL transcripts where multiple distinct assistant responses reused one `message.id`. The repair preserves top-level threading, tool ids, thinking content, and signatures, but rekeys later responses before resume so Anthropic thinking blocks remain in the message shape originally generated by the model. |
+| `apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.ts` | Resume-time repair for historical ADE envelope streams written before Claude text fragments used the stable SDK message id. It detects only runs of at least three consecutive text envelopes in one turn with distinct message ids, rebuilds from SDK message text when possible (otherwise locally merges), preserves every other JSONL line verbatim, skips files over 64 MB, and rewrites atomically with a one-time `.splice.bak`. |
 | `apps/desktop/src/main/services/chat/claudeSubprocessReaper.ts` | Tracks Claude SDK subprocesses and tears them down on runtime shutdown. |
 | `apps/desktop/src/main/services/chat/claudeOutputStyles.ts` | Discovers Claude output styles and plugins from project/user roots. Project roots are walked directly, while user-installed marketplace plugins are loaded only from Claude's installed-plugin registry when enabled in settings, so cache/source copies do not leak into ADE sessions. |
 | `apps/desktop/src/main/services/chat/markdownSlashCommandDiscovery.ts` | Shared markdown-based slash command discovery engine. Provides frontmatter parsing, filesystem walking, command/agent/skill file discovery, command resolution, prompt expansion (`$ARGUMENTS` substitution), ancestor config root traversal, and deduplication helpers. Consumed by the provider-specific discovery modules (`claudeSlashCommandDiscovery`, `codexSlashCommandDiscovery`, `cursorSlashCommandDiscovery`). |
@@ -199,8 +200,11 @@ Controls and summaries project this runtime state rather than owning it:
   scheduler independently re-arms `ScheduleWakeup`, `CronCreate`, and `/loop`
   after a runtime restart. SDK-origin and cold-start wake paths both produce
   synthetic turns plus `scheduled_work_update` snapshots for desktop, ADE
-  Code, and iOS Chat Info. Deliberately not wired yet: SDK `SessionStore` as
-  ADE's transcript backend and channels/external message origins.
+  Code, and iOS Chat Info. SessionStore reads are limited to resume-time
+  envelope self-heal and an explicit provider-fidelity transcript takeover;
+  ADE envelopes remain the normal render backend. Deliberately not wired yet:
+  SDK `SessionStore` as ADE's transcript backend and channels/external message
+  origins.
 - **Provider-agnostic sessions.** `AgentChatProvider` is one of `claude`,
   `codex`, `opencode`, `cursor`, `droid`, or a free-form string reserved for
   local providers. The service owns a pluggable adapter per provider (Claude
@@ -652,7 +656,7 @@ handlers live in `apps/desktop/src/main/services/ipc/registerIpc.ts`.
 | `ade.agentChat.approve` | invoke | Legacy approval channel (pre-pending-input). |
 | `ade.agentChat.respondToInput` | invoke | Unified pending-input answer channel, including Codex MCP elicitation form values and metadata-gated persistent consent. |
 | `ade.agentChat.delete` | invoke | Permanently remove a chat session: cancels its durable schedules, disposes the runtime if still running, cancels any pending turn collector, resolves outstanding input waiters, removes the persisted JSON + transcript, and deletes the `terminal_sessions` row. Renderer surfaces this as "Delete chat". Archiving likewise cancels the chat's schedules. |
-| `ade.agentChat.updateSession` | invoke | Mutate permission modes, `manuallyNamed`, capability mode, and the legacy-named `codexFastMode` Fast Mode toggle. |
+| `ade.agentChat.updateSession` | invoke | Mutate permission modes, `manuallyNamed`, capability mode, the legacy-named `codexFastMode` Fast Mode toggle, and Claude SDK session title/tag metadata. An empty tag clears the SDK tag. |
 | `ade.agentChat.codex.goal.get` / `.set` / `.setStatus` / `.clear` | invoke | Codex-only IPC channels behind the preload API `window.ade.agentChat.codex.getGoal` / `.setGoal` / `.setGoalStatus` / `.clearGoal`. They call the app-server goal RPCs directly instead of sending `/goal` prompt text through the chat, preserve CLI/PTY sessions, validate objective length, persist goal state into session summaries, and keep ADE goals unlimited by clearing provider token budgets. |
 | `ade.agentChat.warmupModel` | invoke | Preload a Claude SDK runtime for an eventual turn. |
 | `ade.agentChat.slashCommands` | invoke | List provider + local slash commands. |
@@ -666,6 +670,7 @@ handlers live in `apps/desktop/src/main/services/ipc/registerIpc.ts`.
 | `ade.agentChat.getImageDataUrl` | invoke | Read a bounded project-local image file through the active runtime and return a data URL for attachment previews. The service validates realpath containment, file type, and size before reading; the renderer falls back to the local guarded app reader only when no runtime preview is available or the runtime read fails for a local-only path. |
 | `ade.agentChat.listSubagents` | invoke | Claude subagent snapshot list. Snapshots are re-keyed on `agentId + parentToolUseId` (not just `taskId`) so multiple subagents spawned from the same parent tool call don't collide, and the renderer panel separates them into three tabs: Subagents, Teammates, and Background. Claude `subagent_*` envelopes are enriched with `agentType` (e.g. `code-reviewer`, `Explore`) by stashing the Task tool's `subagent_type` input at the assistant `tool_use` boundary and joining on `parentToolUseId` when the system-message `task_*` envelope arrives. Codex parallel-agent events carry an `Agent #N` label assigned at first announcement (1-based, per-turn) plus the raw threadId as `agentId`. |
 | `ade.agentChat.getSubagentTranscript` | invoke | Fetch the transcript of one subagent run within a chat session. Dispatch by runtime kind: Claude/ade-code reads the SDK's per-subagent JSONL at `~/.claude/projects/<projectDir>/<sessionId>/subagents/agent-<agentId>.jsonl`; OpenCode pulls the child session's messages over the OpenCode HTTP client (the child session id is the agentId); Codex returns captured child-thread stream rows for the registered collab thread and merges them with `thread/turns/list` app-server backfill, with the legacy parent `subagent_*` envelope filter only as fallback; Cursor filters the parent stream by the SDK-tagged `agentId`; LM Studio / Droid return `null`. Returns `AgentChatSubagentTranscriptMessage[]` (same shape as `AgentChatClaudeSessionMessage`). |
+| `ade.agentChat.getMainTranscript` | invoke | Claude-only provider-fidelity view for an ADE chat session. Resolves the mirrored SDK session id, includes SDK system messages, and returns the byte-bounded subagent-transcript message shape. This is an alternate on-demand view and does not include ADE-only envelope events. |
 | `ade.agentChat.models` | invoke | `{ provider, activateRuntime? }`. For OpenCode `activateRuntime: true` is required to *launch* a probe server; otherwise the main process only returns the cached inventory (via `peekOpenCodeInventoryCache`) and an empty list until a real probe has been run. Cursor and Droid always use `activateRuntime: true` in the TUI model listing path so the SDK can enumerate available models. The renderer cache (`aiDiscoveryCache.ts`) keys on `(projectRoot, provider, activateRuntime)` so passive and active reads don't collide. |
 | `ade.agentChat.modelCatalog` | invoke | `{ mode?, refreshProvider? }` → `AgentChatModelCatalog`. Returns the full provider-grouped catalog (claude / codex / cursor / droid / opencode plus the local `ollama` / `lmstudio` groups when OpenCode-routed) for the desktop and TUI ModelPickers. `mode: "cached"` returns the in-memory snapshot, `"refresh-stale"` reuses the cache but optionally re-probes the named runtime when its per-provider freshness TTL is expired, and `"force"` re-probes unconditionally. `refreshProvider` is one of `"opencode" | "cursor" | "droid" | "lmstudio" | "ollama"`. The catalog carries an optional `stale: true` flag and per-model `connected` / `requiresConfiguration` / `sourceRuntime` / `providerId` / `providerName` / `serviceTiers` annotations; Cursor rows also carry `cursorAvailability` so renderer and TUI pickers can separate SDK chat models from CLI launch models. |
 | `ade.agentChat.getSessionCapabilities` | invoke | Discover supported subagent/review features. |
@@ -722,6 +727,31 @@ handlers live in `apps/desktop/src/main/services/ipc/registerIpc.ts`.
   fragments that share state across events without an explicit id.
   Both flush back to plain `AgentChatTranscriptEntry` rows before
   returning so the on-wire shape is unchanged.
+- **Resume-time envelope splice repair is bounded and lossless outside the
+  detected run.** Before rebinding a persisted Claude SDK session, ADE queries
+  the SDK messages and scans both the dedicated durable chat transcript and
+  the legacy managed transcript once per process. Historical runs of at least
+  three consecutive assistant text envelopes in one turn, each with a distinct
+  message id, are rebuilt with SDK-stable message ids and full text; when SDK
+  matching is unavailable, the run is locally merged. Unknown, malformed, and
+  ADE-only event lines are preserved byte-for-byte. Healthy files are a
+  byte-identical no-op, repaired files are written via temp-file rename with a
+  one-time `.splice.bak`, and files over 64 MB are skipped. Cache invalidation
+  plus a transient `session_meta_updated` event makes an open renderer refetch.
+- **The full session transcript is an alternate Claude-only view.**
+  `ade.agentChat.getMainTranscript` resolves an ADE chat session to its live,
+  persisted, or mirrored Claude SDK session id, requests system messages, and
+  applies the same 4 MB response budget as subagent transcripts. Desktop and
+  ADE Code expand that response through the existing subagent transcript
+  conversion path. The takeover is on demand and explicitly omits ADE-only
+  events such as approvals, schedules, and notices; it never replaces ADE's
+  persisted envelope backend.
+- **Claude tags are lightweight session metadata.** The first tag stored in the
+  mirrored Claude session pointer populates optional `claudeTag` on
+  `AgentChatSessionSummary`. `updateSession({ tag })` writes or clears the SDK
+  tag and refreshes the mirror. Desktop renders it in Work session rows and the
+  chat header, includes it in the Work sidebar search haystack, and ADE Code
+  displays `tag:<value>` in Chat Info.
 - **`AgentChatSessionSummary.pendingInputItemId` is the addressable
   pending input.** When a session is awaiting input, the service
   resolves the latest pending item id from the live runtime's

From 195e0ac80d468f94ba6e3978521e2b60dcb767a0 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Fri, 10 Jul 2026 05:31:42 -0400
Subject: [PATCH 6/9] =?UTF-8?q?fix(chat):=20K=20review=20follow-ups=20?=
 =?UTF-8?q?=E2=80=94=20webclient=20getMainTranscript,=20tag=20gating,=20re?=
 =?UTF-8?q?pair-order=20note?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Wire chat.getMainTranscript into the webclient adapter so remote/web
renderers get the full-transcript view instead of silently degrading;
gate the "Set tag…" context-menu item on a running session (tag writes
need a live Claude SDK runtime); document the thinking-repair →
splice-repair ordering dependency at the resume call site.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 apps/desktop/src/main/services/chat/agentChatService.ts       | 3 +++
 .../src/renderer/components/terminals/SessionContextMenu.tsx  | 4 +++-
 apps/desktop/src/renderer/webclient/adapter/agentChat.ts      | 1 +
 3 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index 4297379b6..5219eb5d0 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -22163,6 +22163,9 @@ export function createAgentChatService(args: {
           at: "resume",
         });
       }
+      // Must run AFTER the thinking-transcript repair: that repair can rekey
+      // SDK message ids, and the splice repair keys rebuilt envelopes to the
+      // post-rekey ids it reads via getSessionMessages.
       await repairClaudeEnvelopeSplicesBeforeResume(managed, options.resume);
     }
 
diff --git a/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx
index 5bfed2538..711068756 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.tsx
@@ -160,7 +160,9 @@ export function SessionContextMenu({
             Rename
           </button>
         )}
-        {!renaming && !tagging && session.toolType === "claude-chat" && onSetChatTag ? (
+        {/* Tag writes need a live Claude SDK runtime (updateSession throws for
+            ended sessions), so only offer the item while the session runs. */}
+        {!renaming && !tagging && session.toolType === "claude-chat" && isRunning && onSetChatTag ? (
           <button
             className="flex w-full items-center gap-2 rounded px-3 py-1.5 text-left text-xs hover:bg-muted/40 transition-colors"
             onClick={() => {
diff --git a/apps/desktop/src/renderer/webclient/adapter/agentChat.ts b/apps/desktop/src/renderer/webclient/adapter/agentChat.ts
index ce98bb2d3..e7c55bf7a 100644
--- a/apps/desktop/src/renderer/webclient/adapter/agentChat.ts
+++ b/apps/desktop/src/renderer/webclient/adapter/agentChat.ts
@@ -159,6 +159,7 @@ export function createAgentChatNamespace(infra: AdapterInfra): AdeNamespace<"age
     getClaudeSessionInfo: (args: unknown) => call("chat.getClaudeSessionInfo", args, null),
     getClaudeSessionMessages: (args: unknown) => call("chat.getClaudeSessionMessages", args, []),
     getSubagentTranscript: (args: unknown) => call("chat.getSubagentTranscript", args, null),
+    getMainTranscript: (args: unknown) => call("chat.getMainTranscript", args, null),
     getContextUsage: (args: unknown) => call("chat.getContextUsage", args, null),
     rewindFiles: (args: unknown) =>
       call(

From 7aff26400a3e65e869e126e0f5575b669b304e6a Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Fri, 10 Jul 2026 06:12:10 -0400
Subject: [PATCH 7/9] =?UTF-8?q?refactor(chat):=20/quality=20pass=20?=
 =?UTF-8?q?=E2=80=94=20de-triplicate=20pane=20section=20scaffolding=20+=20?=
 =?UTF-8?q?review=20polish?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Extract PaneScalableSection (desktop) and scalableSectionBody (iOS) so the
Subagents/Background/Schedule sections share one disclosure/cap/Earlier/
Clear-Restore scaffold instead of three hand-inlined copies; row rendering
stays caller-supplied. Behavior-preserving: all pane tests pass unmodified.
Also: correct the Show-all hidden-count label (overflow is not necessarily
running), release the splice-repair once-per-process guard on transient SDK
fetch failures so a later resume can retry, and add cross-platform twin
comments on caps/keys/hints plus the intentional orphan-schedule sweep.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../main/services/chat/agentChatService.ts    |   7 +
 .../components/chat/ChatSubagentsPanel.tsx    | 401 +++++++-----------
 apps/desktop/src/shared/chatSubagents.ts      |   3 +
 .../Views/Work/WorkChatRichCardViews.swift    |  70 ++-
 4 files changed, 203 insertions(+), 278 deletions(-)

diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index 5219eb5d0..e4da118d6 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -22068,6 +22068,10 @@ export function createAgentChatService(args: {
         dir: managed.laneWorktreePath,
       });
     } catch (error) {
+      // A transient fetch failure (store locked, file not flushed yet) should
+      // not burn the once-per-process attempt — release the guard so a later
+      // resume can retry the repair.
+      envelopeSpliceRepairAttemptedSessionIds.delete(sessionId);
       logger.debug("agent_chat.envelope_splice_repair_skipped", {
         sessionId,
         sdkSessionId,
@@ -29002,6 +29006,9 @@ export function createAgentChatService(args: {
         scheduledWorkScheduler.list()
           .filter((schedule) => {
             const row = sessionService.get(schedule.sessionId);
+            // `!row` deliberately widens the sweep to globally-orphaned
+            // schedules (no session row left) — they would self-cancel at
+            // fire time anyway; lane teardown just reaps them earlier.
             return !row || row.laneId === laneId;
           })
           .map((schedule) => scheduledWorkScheduler!.cancel(schedule.id)),
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
index 739e3d3a6..a965b0109 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import { Fragment, useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
 import { AnimatePresence, motion } from "motion/react";
 import {
   CaretDown,
@@ -339,6 +339,108 @@ function PaneTextAction({ children, onClick }: { children: ReactNode; onClick: (
   );
 }
 
+type ScalablePaneSectionKey = keyof PaneClearedStorageState;
+
+function PaneScalableSection<T>({
+  sectionKey, label, hint, tone, cap, groups, capped, paneUi, sticky, extraHeaderAction,
+  idOf, renderActiveRow, renderEarlierRow, onToggleCollapsed, onToggleEarlier,
+  onClear, onRestore, onShowAll, showAll, hasPrecedingSection, showAllLabel,
+  animateActiveRows = true, animateEarlierRows = false, keepEmptyActiveList = true,
+  subagentTaskIdOf,
+}: {
+  sectionKey: ScalablePaneSectionKey;
+  label: string;
+  hint: string;
+  tone: SectionTone;
+  cap: number;
+  groups: { active: T[]; earlier: T[]; clearedCount: number };
+  capped: { visible: T[]; hiddenCount: number };
+  paneUi: PaneUiStorageState;
+  sticky: boolean;
+  extraHeaderAction?: ReactNode;
+  idOf: (item: T) => string;
+  renderActiveRow: (item: T) => ReactNode;
+  renderEarlierRow: (item: T) => ReactNode;
+  onToggleCollapsed: () => void;
+  onToggleEarlier: () => void;
+  onClear: (ids: string[]) => void;
+  onRestore: () => void;
+  onShowAll: () => void;
+  showAll: boolean;
+  hasPrecedingSection: boolean;
+  showAllLabel?: string;
+  animateActiveRows?: boolean;
+  animateEarlierRows?: boolean;
+  keepEmptyActiveList?: boolean;
+  subagentTaskIdOf?: (item: T) => string;
+}) {
+  const allClear = groups.active.length === 0 && groups.earlier.length === 0 && groups.clearedCount > 0;
+  const collapsible = groups.earlier.length > 0 || groups.active.length > cap;
+  const collapsed = collapsible && paneUi.collapsed[sectionKey] === true;
+  const earlierExpanded = paneUi.earlier[sectionKey] === true;
+  const sectionAction = allClear ? (
+    <PaneTextAction onClick={onRestore}>Restore ({groups.clearedCount})</PaneTextAction>
+  ) : groups.earlier.length > 0 ? (
+    <PaneTextAction onClick={() => onClear(groups.earlier.map(idOf))}>Clear</PaneTextAction>
+  ) : null;
+  const renderRows = (items: T[], renderRow: (item: T) => ReactNode, animated: boolean) => {
+    const rows = items.map((item) => animated ? (
+      <motion.div
+        key={idOf(item)}
+        data-subagent-task-id={subagentTaskIdOf?.(item)}
+        initial={{ height: 0, opacity: 0 }}
+        animate={{ height: "auto", opacity: 1 }}
+        exit={{ height: 0, opacity: 0 }}
+        transition={{ duration: 0.18, ease: [0.4, 0, 0.2, 1] }}
+        className="overflow-hidden"
+      >
+        {renderRow(item)}
+      </motion.div>
+    ) : <Fragment key={idOf(item)}>{renderRow(item)}</Fragment>);
+    return animated ? <AnimatePresence initial={false}>{rows}</AnimatePresence> : rows;
+  };
+
+  return (
+    <section className={cn("pb-3", hasPrecedingSection && "border-t border-white/[0.04]")}>
+      <SectionHeader
+        label={label}
+        hint={allClear ? "all clear" : hint}
+        tone={tone}
+        emphasized
+        sticky={sticky}
+        collapsible={collapsible}
+        collapsed={collapsed}
+        onToggle={onToggleCollapsed}
+        action={extraHeaderAction === undefined ? sectionAction : <>{sectionAction}{extraHeaderAction}</>}
+      />
+      <SectionDisclosure open={!collapsed}>
+        {allClear ? <div className="px-4 pb-2 text-[11px] text-fg/35">{label} · all clear</div> : null}
+        {keepEmptyActiveList || capped.visible.length > 0 ? (
+          <div className="space-y-px px-2 pb-1">
+            {renderRows(capped.visible, renderActiveRow, animateActiveRows)}
+          </div>
+        ) : null}
+        {!showAll && capped.hiddenCount > 0 ? (
+          <ShowAllButton hiddenLabel={showAllLabel ?? `${capped.hiddenCount}`} onClick={onShowAll} />
+        ) : null}
+        {groups.earlier.length > 0 || groups.clearedCount > 0 ? (
+          <div className="px-2 pt-0.5">
+            <EarlierToggle count={groups.earlier.length} clearedCount={groups.clearedCount} expanded={earlierExpanded} onToggle={onToggleEarlier} />
+            <SectionDisclosure open={earlierExpanded}>
+              <div className="space-y-px pb-1">
+                {renderRows(groups.earlier, renderEarlierRow, animateEarlierRows)}
+              </div>
+              {groups.clearedCount > 0 ? (
+                <div className="px-2 pb-1"><PaneTextAction onClick={onRestore}>Restore ({groups.clearedCount})</PaneTextAction></div>
+              ) : null}
+            </SectionDisclosure>
+          </div>
+        ) : null}
+      </SectionDisclosure>
+    </section>
+  );
+}
+
 /* ── Progress bar — 1 px hairline rule ── */
 
 function ProgressBar({ percent }: { percent: number }) {
@@ -1161,15 +1263,6 @@ export function ChatSubagentsPanel({
   const scheduleRunningCount = scheduleGroups.active.filter((item) => item.status === "running").length;
   const scheduleFailedCount = scheduleGroups.active.filter((item) => item.status === "failed").length;
 
-  const subagentsCollapsible = subagentGroups.earlier.length > 0 || subagentGroups.active.length > SUBAGENTS_ACTIVE_CAP;
-  const backgroundCollapsible = backgroundGroups.earlier.length > 0 || backgroundGroups.active.length > BACKGROUND_ACTIVE_CAP;
-  const scheduleCollapsible = scheduleGroups.earlier.length > 0 || scheduleGroups.active.length > SCHEDULE_ACTIVE_CAP;
-  const subagentsCollapsed = subagentsCollapsible && paneUi.collapsed.subagents === true;
-  const backgroundCollapsed = backgroundCollapsible && paneUi.collapsed.background === true;
-  const scheduleCollapsed = scheduleCollapsible && paneUi.collapsed.schedule === true;
-  const subagentsAllClear = subagentGroups.active.length === 0 && subagentGroups.earlier.length === 0 && subagentGroups.clearedCount > 0;
-  const backgroundAllClear = backgroundGroups.active.length === 0 && backgroundGroups.earlier.length === 0 && backgroundGroups.clearedCount > 0;
-  const scheduleAllClear = scheduleGroups.active.length === 0 && scheduleGroups.earlier.length === 0 && scheduleGroups.clearedCount > 0;
   const stickyHeaders = variant === "pane";
 
   const hasGoal = Boolean(goal?.objective?.trim());
@@ -1178,6 +1271,17 @@ export function ChatSubagentsPanel({
   const hasBackground = backgroundItems.length > 0;
   const hasScheduled = scheduleItems.length > 0;
   const hasAnything = hasGoal || Boolean(plan) || hasTasks || hasSubagents || hasBackground || hasScheduled;
+  const renderSubagentPaneRow = (snap: ChatSubagentSnapshot) => (
+    <SubagentRow
+      snapshot={snap}
+      selected={selectedTaskId === snap.taskId}
+      expanded={expandedTaskId === snap.taskId}
+      probing={probingTaskId === snap.taskId}
+      canViewFullTranscript={canTakeover}
+      category={snap.background ? "background" : "subagent"}
+      onClick={() => handleRowClick(snap)}
+    />
+  );
 
   const body = (
     <div className="flex min-h-full flex-col font-sans">
@@ -1266,241 +1370,64 @@ export function ChatSubagentsPanel({
 
       {/* ── Subagents (merged foreground + background-run agents) ──── */}
       {hasSubagents ? (
-        <section
-          className={cn(
-            "pb-3",
-            (hasGoal || plan || hasTasks) && "border-t border-white/[0.04]",
-          )}
-        >
-          <SectionHeader
-            label="Subagents"
-            hint={subagentsAllClear ? "all clear" : paneSectionHint({
-              activeCount: subagentGroups.active.length,
-              earlierCount: subagentGroups.earlier.length,
-              clearedCount: subagentGroups.clearedCount,
-              runningCount: subagentRunningCount,
-              failedCount: subagentFailedCount,
-            })}
-            tone="subagent"
-            emphasized
-            sticky={stickyHeaders}
-            collapsible={subagentsCollapsible}
-            collapsed={subagentsCollapsed}
-            onToggle={() => toggleSection("subagents")}
-            action={subagentsAllClear ? (
-              <PaneTextAction onClick={() => restoreCleared("subagents")}>Restore ({subagentGroups.clearedCount})</PaneTextAction>
-            ) : subagentGroups.earlier.length > 0 ? (
-              <PaneTextAction onClick={() => clearEarlier("subagents", subagentGroups.earlier.map((item) => item.taskId))}>Clear</PaneTextAction>
-            ) : null}
-          />
-          <SectionDisclosure open={!subagentsCollapsed}>
-            {subagentsAllClear ? (
-              <div className="px-4 pb-2 text-[11px] text-fg/35">Subagents · all clear</div>
-            ) : null}
-            <div className="space-y-px px-2 pb-1">
-              <AnimatePresence initial={false}>
-                {cappedSubagents.visible.map((snap) => (
-                  <motion.div
-                    key={snap.taskId}
-                    data-subagent-task-id={snap.taskId}
-                    initial={{ height: 0, opacity: 0 }}
-                    animate={{ height: "auto", opacity: 1 }}
-                    exit={{ height: 0, opacity: 0 }}
-                    transition={{ duration: 0.18, ease: [0.4, 0, 0.2, 1] }}
-                    className="overflow-hidden"
-                  >
-                    <SubagentRow
-                      snapshot={snap}
-                      selected={selectedTaskId === snap.taskId}
-                      expanded={expandedTaskId === snap.taskId}
-                      probing={probingTaskId === snap.taskId}
-                      canViewFullTranscript={canTakeover}
-                      category={snap.background ? "background" : "subagent"}
-                      onClick={() => handleRowClick(snap)}
-                    />
-                  </motion.div>
-                ))}
-              </AnimatePresence>
-            </div>
-            {cappedSubagents.hiddenCount > 0 ? (
-              <ShowAllButton
-                hiddenLabel={`${cappedSubagents.hiddenCount} running`}
-                onClick={() => setShowAll((current) => ({ ...current, subagents: true }))}
-              />
-            ) : null}
-            {subagentGroups.earlier.length > 0 || subagentGroups.clearedCount > 0 ? (
-              <div className="px-2 pt-0.5">
-                <EarlierToggle
-                  count={subagentGroups.earlier.length}
-                  clearedCount={subagentGroups.clearedCount}
-                  expanded={paneUi.earlier.subagents === true}
-                  onToggle={() => toggleEarlier("subagents")}
-                />
-                <SectionDisclosure open={paneUi.earlier.subagents === true}>
-                  <div className="space-y-px pb-1">
-                    <AnimatePresence initial={false}>
-                      {subagentGroups.earlier.map((snap) => (
-                        <motion.div
-                          key={snap.taskId}
-                          data-subagent-task-id={snap.taskId}
-                          initial={{ height: 0, opacity: 0 }}
-                          animate={{ height: "auto", opacity: 1 }}
-                          exit={{ height: 0, opacity: 0 }}
-                          transition={{ duration: 0.18, ease: [0.4, 0, 0.2, 1] }}
-                          className="overflow-hidden"
-                        >
-                          <SubagentRow
-                            snapshot={snap}
-                            selected={selectedTaskId === snap.taskId}
-                            expanded={expandedTaskId === snap.taskId}
-                            probing={probingTaskId === snap.taskId}
-                            canViewFullTranscript={canTakeover}
-                            category={snap.background ? "background" : "subagent"}
-                            onClick={() => handleRowClick(snap)}
-                          />
-                        </motion.div>
-                      ))}
-                    </AnimatePresence>
-                  </div>
-                  {subagentGroups.clearedCount > 0 ? (
-                    <div className="px-2 pb-1"><PaneTextAction onClick={() => restoreCleared("subagents")}>Restore ({subagentGroups.clearedCount})</PaneTextAction></div>
-                  ) : null}
-                </SectionDisclosure>
-              </div>
-            ) : null}
-          </SectionDisclosure>
-        </section>
+        <PaneScalableSection
+          sectionKey="subagents" label="Subagents" tone="subagent" cap={SUBAGENTS_ACTIVE_CAP}
+          hint={paneSectionHint({ activeCount: subagentGroups.active.length, earlierCount: subagentGroups.earlier.length, clearedCount: subagentGroups.clearedCount, runningCount: subagentRunningCount, failedCount: subagentFailedCount })}
+          groups={subagentGroups} capped={cappedSubagents} paneUi={paneUi} sticky={stickyHeaders}
+          idOf={(snap) => snap.taskId}
+          renderActiveRow={renderSubagentPaneRow} renderEarlierRow={renderSubagentPaneRow}
+          onToggleCollapsed={() => toggleSection("subagents")} onToggleEarlier={() => toggleEarlier("subagents")}
+          onClear={(ids) => clearEarlier("subagents", ids)} onRestore={() => restoreCleared("subagents")}
+          onShowAll={() => setShowAll((current) => ({ ...current, subagents: true }))} showAll={showAll.subagents === true}
+          hasPrecedingSection={Boolean(hasGoal || plan || hasTasks)} showAllLabel={`${cappedSubagents.hiddenCount} running`}
+          animateEarlierRows subagentTaskIdOf={(snap) => snap.taskId}
+        />
       ) : null}
 
       {/* ── Background (background command tasks) ─────────────────── */}
       {hasBackground ? (
-        <section
-          className={cn(
-            "pb-3",
-            (hasGoal || plan || hasTasks || hasSubagents) && "border-t border-white/[0.04]",
-          )}
-        >
-          <SectionHeader
-            label="Background"
-            hint={backgroundAllClear ? "all clear" : paneSectionHint({
-              activeCount: backgroundGroups.active.length,
-              earlierCount: backgroundGroups.earlier.length,
-              clearedCount: backgroundGroups.clearedCount,
-              runningCount: backgroundRunningCount,
-              failedCount: backgroundFailedCount,
-            })}
-            tone="background"
-            emphasized
-            sticky={stickyHeaders}
-            collapsible={backgroundCollapsible}
-            collapsed={backgroundCollapsed}
-            onToggle={() => toggleSection("background")}
-            action={backgroundAllClear ? (
-              <PaneTextAction onClick={() => restoreCleared("background")}>Restore ({backgroundGroups.clearedCount})</PaneTextAction>
-            ) : backgroundGroups.earlier.length > 0 ? (
-              <PaneTextAction onClick={() => clearEarlier("background", backgroundGroups.earlier.map((item) => item.id))}>Clear</PaneTextAction>
-            ) : null}
-          />
-          <SectionDisclosure open={!backgroundCollapsed}>
-            {backgroundAllClear ? <div className="px-4 pb-2 text-[11px] text-fg/35">Background · all clear</div> : null}
-            <div className="space-y-px px-2 pb-1">
-              <AnimatePresence initial={false}>
-                {cappedBackground.visible.map((item) => (
-                  <motion.div key={item.id} initial={{ height: 0, opacity: 0 }} animate={{ height: "auto", opacity: 1 }} exit={{ height: 0, opacity: 0 }} transition={{ duration: 0.18, ease: [0.4, 0, 0.2, 1] }} className="overflow-hidden">
-                    <BackgroundCommandRow snapshot={item} />
-                  </motion.div>
-                ))}
-              </AnimatePresence>
-            </div>
-            {cappedBackground.hiddenCount > 0 ? <ShowAllButton hiddenLabel={`${cappedBackground.hiddenCount}`} onClick={() => setShowAll((current) => ({ ...current, background: true }))} /> : null}
-            {backgroundGroups.earlier.length > 0 || backgroundGroups.clearedCount > 0 ? (
-              <div className="px-2 pt-0.5">
-                <EarlierToggle count={backgroundGroups.earlier.length} clearedCount={backgroundGroups.clearedCount} expanded={paneUi.earlier.background === true} onToggle={() => toggleEarlier("background")} />
-                <SectionDisclosure open={paneUi.earlier.background === true}>
-                  <div className="space-y-px pb-1">
-                    {backgroundGroups.earlier.map((item) => <BackgroundCommandRow key={item.id} snapshot={item} />)}
-                  </div>
-                  {backgroundGroups.clearedCount > 0 ? <div className="px-2 pb-1"><PaneTextAction onClick={() => restoreCleared("background")}>Restore ({backgroundGroups.clearedCount})</PaneTextAction></div> : null}
-                </SectionDisclosure>
-              </div>
-            ) : null}
-          </SectionDisclosure>
-        </section>
+        <PaneScalableSection
+          sectionKey="background" label="Background" tone="background" cap={BACKGROUND_ACTIVE_CAP}
+          hint={paneSectionHint({ activeCount: backgroundGroups.active.length, earlierCount: backgroundGroups.earlier.length, clearedCount: backgroundGroups.clearedCount, runningCount: backgroundRunningCount, failedCount: backgroundFailedCount })}
+          groups={backgroundGroups} capped={cappedBackground} paneUi={paneUi} sticky={stickyHeaders}
+          idOf={(item) => item.id}
+          renderActiveRow={(item) => <BackgroundCommandRow snapshot={item} />}
+          renderEarlierRow={(item) => <BackgroundCommandRow snapshot={item} />}
+          onToggleCollapsed={() => toggleSection("background")} onToggleEarlier={() => toggleEarlier("background")}
+          onClear={(ids) => clearEarlier("background", ids)} onRestore={() => restoreCleared("background")}
+          onShowAll={() => setShowAll((current) => ({ ...current, background: true }))} showAll={showAll.background === true}
+          hasPrecedingSection={Boolean(hasGoal || plan || hasTasks || hasSubagents)}
+        />
       ) : null}
 
       {/* ── Schedule (schedule kinds only) ───────────────────────── */}
       {hasScheduled ? (
-        <section
-          className={cn(
-            "pb-3",
-            (hasGoal || plan || hasTasks || hasSubagents || hasBackground) && "border-t border-white/[0.04]",
-          )}
-        >
-          <SectionHeader
-            label="Schedule"
-            hint={scheduleAllClear ? "all clear" : paneSectionHint({
-              activeCount: scheduleGroups.active.length,
-              earlierCount: scheduleGroups.earlier.length,
-              clearedCount: scheduleGroups.clearedCount,
-              runningCount: scheduleRunningCount,
-              failedCount: scheduleFailedCount,
-            })}
-            tone="scheduled"
-            emphasized
-            sticky={stickyHeaders}
-            collapsible={scheduleCollapsible}
-            collapsed={scheduleCollapsed}
-            onToggle={() => toggleSection("schedule")}
-            action={(
-              <>
-                {scheduleAllClear ? (
-                  <PaneTextAction onClick={() => restoreCleared("schedule")}>Restore ({scheduleGroups.clearedCount})</PaneTextAction>
-                ) : scheduleGroups.earlier.length > 0 ? (
-                  <PaneTextAction onClick={() => clearEarlier("schedule", scheduleGroups.earlier.map((item) => item.id))}>Clear</PaneTextAction>
-                ) : null}
-                {onToggleSchedulesPaused ? (
-                  <button
-                    type="button"
-                    onClick={onToggleSchedulesPaused}
-                    aria-label={schedulesPaused ? "Resume scheduled work for this chat" : "Pause scheduled work for this chat"}
-                    title={schedulesPaused ? "Resume scheduled work for this chat" : "Pause scheduled work for this chat"}
-                    className="flex h-5 w-5 items-center justify-center rounded-sm text-fg/35 transition-colors hover:bg-white/[0.05] hover:text-fg/65"
-                  >
-                    {schedulesPaused ? <Play aria-hidden size={11} weight="fill" /> : <Pause aria-hidden size={11} weight="fill" />}
-                  </button>
-                ) : null}
-              </>
-            )}
-          />
-          <SectionDisclosure open={!scheduleCollapsed}>
-          {scheduleAllClear ? <div className="px-4 pb-2 text-[11px] text-fg/35">Schedule · all clear</div> : null}
-          {cappedSchedule.visible.length ? (
-            <div className="space-y-px px-2 pb-1">
-              {cappedSchedule.visible.map((item) => (
-                <ScheduledWorkRow
-                  key={item.id}
-                  snapshot={item}
-                  schedulesPaused={schedulesPaused}
-                />
-              ))}
-            </div>
-          ) : null}
-          {cappedSchedule.hiddenCount > 0 ? <ShowAllButton hiddenLabel={`${cappedSchedule.hiddenCount}`} onClick={() => setShowAll((current) => ({ ...current, schedule: true }))} /> : null}
-          {scheduleGroups.earlier.length > 0 || scheduleGroups.clearedCount > 0 ? (
-            <div className="px-2 pt-0.5">
-              <EarlierToggle count={scheduleGroups.earlier.length} clearedCount={scheduleGroups.clearedCount} expanded={paneUi.earlier.schedule === true} onToggle={() => toggleEarlier("schedule")} />
-              <SectionDisclosure open={paneUi.earlier.schedule === true}>
-                <div className="space-y-px pb-1">
-                  {scheduleGroups.earlier.map((item) => isFiredOneShotWakeup(item)
-                    ? <ScheduleHistoryRow key={item.id} snapshot={item} />
-                    : <ScheduledWorkRow key={item.id} snapshot={item} schedulesPaused={schedulesPaused} />)}
-                </div>
-                {scheduleGroups.clearedCount > 0 ? <div className="px-2 pb-1"><PaneTextAction onClick={() => restoreCleared("schedule")}>Restore ({scheduleGroups.clearedCount})</PaneTextAction></div> : null}
-              </SectionDisclosure>
-            </div>
-          ) : null}
-          </SectionDisclosure>
-        </section>
+        <PaneScalableSection
+          sectionKey="schedule" label="Schedule" tone="scheduled" cap={SCHEDULE_ACTIVE_CAP}
+          hint={paneSectionHint({ activeCount: scheduleGroups.active.length, earlierCount: scheduleGroups.earlier.length, clearedCount: scheduleGroups.clearedCount, runningCount: scheduleRunningCount, failedCount: scheduleFailedCount })}
+          groups={scheduleGroups} capped={cappedSchedule} paneUi={paneUi} sticky={stickyHeaders}
+          extraHeaderAction={<>{onToggleSchedulesPaused ? (
+            <button
+              type="button"
+              onClick={onToggleSchedulesPaused}
+              aria-label={schedulesPaused ? "Resume scheduled work for this chat" : "Pause scheduled work for this chat"}
+              title={schedulesPaused ? "Resume scheduled work for this chat" : "Pause scheduled work for this chat"}
+              className="flex h-5 w-5 items-center justify-center rounded-sm text-fg/35 transition-colors hover:bg-white/[0.05] hover:text-fg/65"
+            >
+              {schedulesPaused ? <Play aria-hidden size={11} weight="fill" /> : <Pause aria-hidden size={11} weight="fill" />}
+            </button>
+          ) : null}</>}
+          idOf={(item) => item.id}
+          renderActiveRow={(item) => <ScheduledWorkRow snapshot={item} schedulesPaused={schedulesPaused} />}
+          renderEarlierRow={(item) => isFiredOneShotWakeup(item)
+            ? <ScheduleHistoryRow snapshot={item} />
+            : <ScheduledWorkRow snapshot={item} schedulesPaused={schedulesPaused} />}
+          onToggleCollapsed={() => toggleSection("schedule")} onToggleEarlier={() => toggleEarlier("schedule")}
+          onClear={(ids) => clearEarlier("schedule", ids)} onRestore={() => restoreCleared("schedule")}
+          onShowAll={() => setShowAll((current) => ({ ...current, schedule: true }))} showAll={showAll.schedule === true}
+          hasPrecedingSection={Boolean(hasGoal || plan || hasTasks || hasSubagents || hasBackground)}
+          animateActiveRows={false} keepEmptyActiveList={false}
+        />
       ) : null}
 
       {/* ── Single-agent empty state ─────────────────────────────── */}
diff --git a/apps/desktop/src/shared/chatSubagents.ts b/apps/desktop/src/shared/chatSubagents.ts
index 5896caa2f..9225b8809 100644
--- a/apps/desktop/src/shared/chatSubagents.ts
+++ b/apps/desktop/src/shared/chatSubagents.ts
@@ -56,6 +56,9 @@ export type ChatInfoPlan = {
   live: boolean;
 } | null;
 
+// iOS mirrors these caps, the pane storage-key/empty-state shapes, and the
+// section-hint format in WorkChatRichCardViews.swift (WorkChatInfoDetailsSheet)
+// — keep the twins in sync when changing any of them.
 export const SUBAGENTS_ACTIVE_CAP = 12;
 export const BACKGROUND_ACTIVE_CAP = 8;
 export const SCHEDULE_ACTIVE_CAP = 10;
diff --git a/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift b/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift
index 0331c1e15..54d30edb8 100644
--- a/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift
+++ b/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift
@@ -2583,6 +2583,10 @@ struct WorkChatInfoDetailsSheet: View {
   @State private var showAllSections: Set<String> = []
   @Environment(\.accessibilityReduceMotion) private var reduceMotion
 
+  // Mirrors SUBAGENTS_ACTIVE_CAP / BACKGROUND_ACTIVE_CAP / SCHEDULE_ACTIVE_CAP,
+  // the pane storage-key/empty-state shapes, and the section-hint format in
+  // apps/desktop/src/shared/chatSubagents.ts + ChatSubagentsPanel.tsx — keep
+  // the twins in sync when changing any of them.
   private let subagentsCap = 12
   private let backgroundCap = 8
   private let scheduleCap = 10
@@ -2793,20 +2797,7 @@ struct WorkChatInfoDetailsSheet: View {
                 clearedCount: subagentPartition.clearedCount,
                 allClear: subagentPartition.active.isEmpty && subagentPartition.earlier.isEmpty && subagentPartition.clearedCount > 0
               ) {
-                VStack(spacing: 6) {
-                  if subagentPartition.active.isEmpty && subagentPartition.earlier.isEmpty && subagentPartition.clearedCount > 0 {
-                    allClearRow("Subagents")
-                  }
-                  ForEach(visibleSubagents.visible) { snapshot in
-                    subagentRow(snapshot)
-                  }
-                  showAllButton(section: "subagents", hiddenCount: visibleSubagents.hiddenCount)
-                  earlierButton(section: "subagents", count: subagentPartition.earlier.count, clearedCount: subagentPartition.clearedCount)
-                  if paneFlag("earlier", section: "subagents") {
-                    ForEach(subagentPartition.earlier) { snapshot in subagentRow(snapshot) }
-                    restoreButton(section: "subagents", count: subagentPartition.clearedCount)
-                  }
-                }
+                scalableSectionBody(title: "Subagents", sectionKey: "subagents", spacing: 6, partition: subagentPartition, visible: visibleSubagents) { snapshot, _ in subagentRow(snapshot) }
               }
             }
             if !backgroundItems.isEmpty {
@@ -2825,18 +2816,7 @@ struct WorkChatInfoDetailsSheet: View {
                 clearedCount: backgroundPartition.clearedCount,
                 allClear: backgroundPartition.active.isEmpty && backgroundPartition.earlier.isEmpty && backgroundPartition.clearedCount > 0
               ) {
-                VStack(spacing: 8) {
-                  if backgroundPartition.active.isEmpty && backgroundPartition.earlier.isEmpty && backgroundPartition.clearedCount > 0 { allClearRow("Background") }
-                  ForEach(visibleBackground.visible) { item in
-                    WorkBackgroundWorkRow(item: item)
-                  }
-                  showAllButton(section: "background", hiddenCount: visibleBackground.hiddenCount)
-                  earlierButton(section: "background", count: backgroundPartition.earlier.count, clearedCount: backgroundPartition.clearedCount)
-                  if paneFlag("earlier", section: "background") {
-                    ForEach(backgroundPartition.earlier) { item in WorkBackgroundWorkRow(item: item) }
-                    restoreButton(section: "background", count: backgroundPartition.clearedCount)
-                  }
-                }
+                scalableSectionBody(title: "Background", sectionKey: "background", spacing: 8, partition: backgroundPartition, visible: visibleBackground) { item, _ in WorkBackgroundWorkRow(item: item) }
               }
             }
             if !scheduleItems.isEmpty {
@@ -2855,23 +2835,12 @@ struct WorkChatInfoDetailsSheet: View {
                 clearedCount: schedulePartition.clearedCount,
                 allClear: schedulePartition.active.isEmpty && schedulePartition.earlier.isEmpty && schedulePartition.clearedCount > 0
               ) {
-                VStack(spacing: 8) {
-                  if schedulePartition.active.isEmpty && schedulePartition.earlier.isEmpty && schedulePartition.clearedCount > 0 { allClearRow("Schedule") }
-                  ForEach(visibleSchedule.visible) { item in
+                scalableSectionBody(title: "Schedule", sectionKey: "schedule", spacing: 8, partition: schedulePartition, visible: visibleSchedule) { item, isEarlier in
+                  if isEarlier && workScheduleItemIsFiredOneShotWakeup(item) {
+                    WorkScheduledWorkRow(item: item).opacity(0.55).allowsHitTesting(false)
+                  } else {
                     WorkScheduledWorkRow(item: item)
                   }
-                  showAllButton(section: "schedule", hiddenCount: visibleSchedule.hiddenCount)
-                  earlierButton(section: "schedule", count: schedulePartition.earlier.count, clearedCount: schedulePartition.clearedCount)
-                  if paneFlag("earlier", section: "schedule") {
-                    ForEach(schedulePartition.earlier) { item in
-                      if workScheduleItemIsFiredOneShotWakeup(item) {
-                        WorkScheduledWorkRow(item: item).opacity(0.55).allowsHitTesting(false)
-                      } else {
-                        WorkScheduledWorkRow(item: item)
-                      }
-                    }
-                    restoreButton(section: "schedule", count: schedulePartition.clearedCount)
-                  }
                 }
               }
             }
@@ -2897,6 +2866,25 @@ struct WorkChatInfoDetailsSheet: View {
     )
   }
 
+  @ViewBuilder
+  private func scalableSectionBody<Item: Identifiable, Row: View>(
+    title: String, sectionKey: String, spacing: CGFloat,
+    partition: (active: [Item], earlier: [Item], clearedCount: Int),
+    visible: (visible: [Item], hiddenCount: Int),
+    @ViewBuilder row: @escaping (Item, _ isEarlier: Bool) -> Row
+  ) -> some View {
+    VStack(spacing: spacing) {
+      if partition.active.isEmpty && partition.earlier.isEmpty && partition.clearedCount > 0 { allClearRow(title) }
+      ForEach(visible.visible) { item in row(item, false) }
+      showAllButton(section: sectionKey, hiddenCount: visible.hiddenCount)
+      earlierButton(section: sectionKey, count: partition.earlier.count, clearedCount: partition.clearedCount)
+      if paneFlag("earlier", section: sectionKey) {
+        ForEach(partition.earlier) { item in row(item, true) }
+        restoreButton(section: sectionKey, count: partition.clearedCount)
+      }
+    }
+  }
+
   @ViewBuilder
   private func section<Content: View>(
     title: String,

From b207dcd2751d41567739c39ab6d55c3fb674c0b4 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Fri, 10 Jul 2026 06:22:36 -0400
Subject: [PATCH 8/9] =?UTF-8?q?test(chat):=20/test=20parity=20pass=20?=
 =?UTF-8?q?=E2=80=94=20docs,=20CLI=20--tag,=20TUI=20historyInvalidated=20+?=
 =?UTF-8?q?=20tag=20chip?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Docs: document the Set tag session action, iOS Chat Info caps/Earlier parity,
and drop a stale ChatSubagentStrip reference. CLI: --tag flag on personal chat
update (empty clears), with tests. TUI: refetch history on session_meta_updated
historyInvalidated (mirrors desktop's post-repair reload) and render a #tag
suffix in Drawer chat rows following the wake-chip convention. Mobile parity
audit: no Swift changes required (all contract deltas decode tolerantly).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 apps/ade-cli/src/cli.test.ts                  | 22 +++++++++++++++++++
 apps/ade-cli/src/cli.ts                       |  6 +++++
 apps/ade-cli/src/tuiClient/app.tsx            | 12 ++++++++++
 .../src/tuiClient/components/Drawer.tsx       |  8 ++++++-
 docs/features/chat/composer-and-ui.md         |  8 +++----
 .../sync-and-multi-device/ios-companion.md    |  6 ++++-
 .../terminals-and-sessions/ui-surfaces.md     | 11 ++++++++--
 7 files changed, 65 insertions(+), 8 deletions(-)

diff --git a/apps/ade-cli/src/cli.test.ts b/apps/ade-cli/src/cli.test.ts
index 541d3a7ec..1b010b0dd 100644
--- a/apps/ade-cli/src/cli.test.ts
+++ b/apps/ade-cli/src/cli.test.ts
@@ -2414,6 +2414,8 @@ describe("ADE CLI", () => {
       "--personal",
       "--title",
       "Trip planning",
+      "--tag",
+      "review-ready",
       "--reasoning-effort",
       "high",
       "--fast",
@@ -2424,12 +2426,32 @@ describe("ADE CLI", () => {
         args: {
           sessionId: "personal-1",
           title: "Trip planning",
+          tag: "review-ready",
           reasoningEffort: "high",
           fastMode: true,
         },
       },
     });
 
+    // `--tag ""` clears the Claude session tag (empty string is forwarded, not dropped).
+    const clearTag = expectExecutePlan(buildCliPlan([
+      "chat",
+      "update",
+      "personal-1",
+      "--personal",
+      "--tag",
+      "",
+    ]));
+    expect(clearTag.steps[0]).toMatchObject({
+      params: {
+        action: "updateSession",
+        args: {
+          sessionId: "personal-1",
+          tag: "",
+        },
+      },
+    });
+
     expect(() => buildCliPlan([
       "chat",
       "list",
diff --git a/apps/ade-cli/src/cli.ts b/apps/ade-cli/src/cli.ts
index b1af49791..322e2423c 100644
--- a/apps/ade-cli/src/cli.ts
+++ b/apps/ade-cli/src/cli.ts
@@ -1522,6 +1522,8 @@ const HELP_BY_COMMAND: Record<string, string> = {
     $ ade chat steer <session> --personal --text "focus on the tradeoffs"
     $ ade chat models --personal --provider codex
     $ ade chat update <session> --personal --title "Trip planning"
+    $ ade chat update <session> --personal --tag "review-ready"
+                                                    Claude-only; --tag "" clears it
     $ ade chat message <session> --kind auto --text "status"
                                                     Deliver via auto | queue | wake | interrupt-replace
     $ ade chat steer <session> --text "context"     Steer/queue context into an active turn
@@ -7295,6 +7297,9 @@ function buildPersonalChatPlan(sub: string, args: string[]): CliPlan {
   if (sub === "update" || sub === "configure") {
     const model = readValue(args, ["--model", "--model-id"]);
     const title = readValue(args, ["--title"]);
+    // Claude-only session tag mirrored to the SDK. Pass `--tag ""` to clear it.
+    // Rejected at runtime for non-Claude sessions or before a Claude turn exists.
+    const tag = readValue(args, ["--tag"]);
     const provider = readValue(args, ["--provider"]);
     const reasoningEffort = readValue(args, ["--reasoning-effort", "--effort"]);
     const permissionMode = readValue(args, ["--permission-mode", "--permissions"]);
@@ -7305,6 +7310,7 @@ function buildPersonalChatPlan(sub: string, args: string[]): CliPlan {
       steps: [personalChatStep("updateSession", collectGenericObjectArgs(args, {
         sessionId,
         ...(title !== null ? { title } : {}),
+        ...(tag !== null ? { tag } : {}),
         ...(provider ? { provider } : {}),
         ...(model ? { model, modelId: model } : {}),
         ...(reasoningEffort ? { reasoningEffort } : {}),
diff --git a/apps/ade-cli/src/tuiClient/app.tsx b/apps/ade-cli/src/tuiClient/app.tsx
index 71a6e6e23..8855c86d8 100644
--- a/apps/ade-cli/src/tuiClient/app.tsx
+++ b/apps/ade-cli/src/tuiClient/app.tsx
@@ -7613,6 +7613,18 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
           };
         });
       }
+      // A backend self-heal/splice-repair rewrote persisted envelope history for
+      // the active chat (session_meta_updated · historyInvalidated). Our in-memory
+      // event buffer is now stale relative to the repaired turns and stays that
+      // way until a reconnect/gap, so refetch history — mirroring desktop
+      // AgentChatPane's loadHistory(force) on the same signal.
+      if (
+        envelope.event.type === "session_meta_updated"
+        && envelope.event.historyInvalidated === true
+        && isActiveSessionEvent
+      ) {
+        void refreshStateRef.current({ hydrateHistory: true }).catch(() => undefined);
+      }
       // A cross-client mode change (iOS/desktop re-moding the session the TUI is
       // viewing) arrives as a transient session_meta_updated carrying the new
       // permission/interaction fields. The composer footer reads modelState, not
diff --git a/apps/ade-cli/src/tuiClient/components/Drawer.tsx b/apps/ade-cli/src/tuiClient/components/Drawer.tsx
index cbd7f0bb5..c220612ff 100644
--- a/apps/ade-cli/src/tuiClient/components/Drawer.tsx
+++ b/apps/ade-cli/src/tuiClient/components/Drawer.tsx
@@ -630,9 +630,14 @@ function ChatRow({
   // NextWakeChip parity); reserve its width so the title never collides with it.
   const wake = chatNextWakeLabel(session);
   const wakeReserve = wake ? wake.length + 3 : 0;
+  // A tagged Claude chat shows a compact trailing "#tag" marker (desktop
+  // SessionCard claudeTag pill parity); reserve its width like the wake chip so
+  // 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;
   // 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));
+  const label = truncate(formatSessionLabel(session), drawerChatLabelWidth(max, wakeReserve + tagReserve));
   // 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.
@@ -647,6 +652,7 @@ 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>
+        {tag ? <Text color={theme.color.t4}>{` ${tag}`}</Text> : null}
         {wake ? <Text color={theme.color.t4}>{` ⏰${wake}`}</Text> : null}
         {running ? <Text> <ActiveChatSpin /></Text> : null}
         {session.sessionId === activeSessionId ? (
diff --git a/docs/features/chat/composer-and-ui.md b/docs/features/chat/composer-and-ui.md
index 7b06d277f..4d4bfa847 100644
--- a/docs/features/chat/composer-and-ui.md
+++ b/docs/features/chat/composer-and-ui.md
@@ -30,7 +30,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. 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 uses `thread/rollback` for the latest user message and restores files through ADE's git plan. |
-| `ChatSubagentsPanel.tsx`, `ChatSubagentStrip.tsx` | Chat Info panels. They render the Codex goal card, latest plan, tasks, schedule, and subagent/background rosters. Large sections cap active rows and add Show all; terminal rows move into one Earlier 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 beside Clear. 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. Large sections cap active rows and add Show all; terminal rows move into one Earlier 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 beside Clear. 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). |
@@ -537,9 +537,9 @@ emits `subagent_started`, `subagent_progress`, and `subagent_result`
 events. `ChatSubagentsPanel` renders running/completed/failed/stopped
 subagents with usage metrics. The same panel also renders the current
 Codex goal, plan, `todo_update` task list, and the Schedule section
-derived from `scheduled_work_update` events. `ChatSubagentStrip` is the
-compact header strip showing running subagent count, while the Work tab
-actions badge also counts scheduled work when no subagents are present.
+derived from `scheduled_work_update` events. The Work tab actions badge
+shows the running subagent count and also counts scheduled work when no
+subagents are present.
 The same lifecycle events also render inline in the transcript as
 identity-anchored spawn/result cards (background shells collapse to a
 single finish chip) via `deriveSubagentTimelineRows()`
diff --git a/docs/features/sync-and-multi-device/ios-companion.md b/docs/features/sync-and-multi-device/ios-companion.md
index 6c01547b2..d791f4863 100644
--- a/docs/features/sync-and-multi-device/ios-companion.md
+++ b/docs/features/sync-and-multi-device/ios-companion.md
@@ -1457,7 +1457,11 @@ does not duplicate the full desktop Stats page.
   mirroring `deriveSubagentTimelineRows` in `chatSubagents.ts` so a
   subagent never repaints per tick. `WorkChatRichCardViews` renders those
   rows plus the unified Chat Info sheet, whose ordered Subagents /
-  Background / Schedule sections mirror the desktop Chat Info pane.
+  Background / Schedule sections mirror the desktop Chat Info pane —
+  including the same active caps (12 / 8 / 10), the single `Earlier`
+  disclosure that folds terminal rows without reordering survivors, and
+  the per-session Clear/Restore filter (persisted under
+  `ade.chat.paneCleared.v1:<sessionId>`).
 - **Long Work chats must keep row work and root polling cheap.** The
   Work chat detail keeps the full timeline snapshot preview-free, then
   attaches cached initial assistant-message previews only to the visible
diff --git a/docs/features/terminals-and-sessions/ui-surfaces.md b/docs/features/terminals-and-sessions/ui-surfaces.md
index b5b1c23eb..6cd335c97 100644
--- a/docs/features/terminals-and-sessions/ui-surfaces.md
+++ b/docs/features/terminals-and-sessions/ui-surfaces.md
@@ -620,8 +620,8 @@ Launch commands are built by `apps/desktop/src/shared/cliLaunch.ts`:
 
 Right-click menu with branches per session type:
 
-- Chat: Rename (inline text input, sets `manuallyNamed: true`), Delete,
-  archive/restore, Go to lane, Copy session ID.
+- Chat: Rename (inline text input, sets `manuallyNamed: true`), Set tag…
+  (Claude only), Delete, archive/restore, Go to lane, Copy session ID.
 - PTY: Stop runtime (dispatches `ptyDispose`), Go to lane, Copy
   session ID.
 
@@ -629,6 +629,13 @@ The rename input uses a local state and submits via
 `sessions.updateMeta({ title, manuallyNamed: true })`. Errors bubble
 up to `renameError` in `TerminalsPage`.
 
+`Set tag…` is a second inline editor that reuses the same input chrome.
+It appears only for running `claude-chat` sessions (writing a tag needs a
+live Claude SDK runtime — `updateSession` throws for ended sessions),
+submits `agentChat.updateSession({ sessionId, tag })` where an empty
+value clears the tag, and the resolved `claudeTag` renders as a small
+mono pill on the session card.
+
 ## Work view hook: `useWorkSessions.ts`
 
 A single hook that owns a lot of state:

From 431adbbe6d0cddc48236d62c4805f9f19f70a134 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Fri, 10 Jul 2026 06:48:44 -0400
Subject: [PATCH 9/9] =?UTF-8?q?ship:=20iteration=201=20=E2=80=94=20address?=
 =?UTF-8?q?=20CodeRabbit=20review?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Exact-match-only SDK rebuild in the envelope splice repair (superset SDK
text no longer splices unseen content into history; falls back to the
lossless local merge), fix the subprocess reaper's SIGKILL escalation
(child.killed only means signal-sent, gate on exit/signal codes), gate the
TUI roster hint on uncleared snapshots instead of visible rows, precompute
the roster key->index map, and extend the tag context-menu tests
(ended-session gate + non-empty submission).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/tuiClient/components/RightPane.tsx    |  7 ++++--
 .../chat/chatEnvelopeSpliceRepair.test.ts     | 13 ++++++++++
 .../services/chat/chatEnvelopeSpliceRepair.ts | 11 ++++----
 .../chat/claudeSubprocessReaper.test.ts       | 25 +++++++++++++++++++
 .../services/chat/claudeSubprocessReaper.ts   |  7 ++++--
 .../terminals/SessionContextMenu.test.tsx     | 19 ++++++++++++++
 6 files changed, 73 insertions(+), 9 deletions(-)

diff --git a/apps/ade-cli/src/tuiClient/components/RightPane.tsx b/apps/ade-cli/src/tuiClient/components/RightPane.tsx
index 953d4016e..cb34104cd 100644
--- a/apps/ade-cli/src/tuiClient/components/RightPane.tsx
+++ b/apps/ade-cli/src/tuiClient/components/RightPane.tsx
@@ -843,7 +843,9 @@ function ChatInfoRoster({
   const selected = Math.max(-1, Math.min(selectedIndex, totalSelectable - 1));
   const mainSelected = selected === 0;
   const showingMain = !info.inspectedSubagentId;
-  const hint = snapshotRows.length === 0
+  // Gate on the full uncleared snapshot list, not the visible rows — a
+  // collapsed section empties snapshotRows while agents are still running.
+  const hint = countedSnapshots.length === 0
     ? "0 live"
     : [
         `${runCount} live`,
@@ -868,6 +870,7 @@ function ChatInfoRoster({
     selected,
     SUBAGENT_PANE_ROSTER_CAPACITY,
   );
+  const rosterIndexByKey = new Map(snapshotRows.map((row, index) => [row.key, index]));
 
   return (
     <Box flexDirection="column">
@@ -906,7 +909,7 @@ function ChatInfoRoster({
             if (row.kind === "restore-cleared") {
               return <Text key={row.key} color={theme.color.t4} dimColor>{`  restore (${row.count})`}</Text>;
             }
-            const rosterIndex = snapshotRows.findIndex((candidate) => candidate.key === row.key);
+            const rosterIndex = rosterIndexByKey.get(row.key) ?? -1;
             const isSelected = !mainSelected && subagentSelectedIndex === rosterIndex;
             const kind = subagentAgentKind(row.snapshot.status);
             // Background rows get a cyan glyph tint so the eye can sort them out
diff --git a/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.test.ts b/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.test.ts
index b0d75091b..0df7c4e96 100644
--- a/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.test.ts
+++ b/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.test.ts
@@ -158,6 +158,19 @@ describe("repairSplicedEnvelopeLines", () => {
     expect(twice).toEqual({ lines: once.lines, changed: false, repairedTurns: 0 });
   });
 
+  it("falls back to a local merge when SDK text extends beyond the run", () => {
+    // The SDK message is a superset ("Hello from the SDK, and more") of the
+    // run's text. Rebuilding from it would splice content the ADE transcript
+    // never showed into history — the repair must keep the exact ADE text.
+    const input = splicedRun();
+    const result = repairSplicedEnvelopeLines(input, [assistantMessage("msg-super", "Hello from the SDK, and more")]);
+    expect(result.lines).toHaveLength(1);
+    expect(JSON.parse(result.lines[0]!).event).toMatchObject({
+      text: "Hello from the SDK",
+      messageId: "wire-1",
+    });
+  });
+
   it("falls back to a local merge when SDK messages cover only a prefix of the run", () => {
     // The SDK transcript is missing the run's tail (" the SDK"). A rebuild from
     // the partial SDK match would silently drop that tail — the repair must
diff --git a/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.ts b/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.ts
index 51aff43e0..474804747 100644
--- a/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.ts
+++ b/apps/desktop/src/main/services/chat/chatEnvelopeSpliceRepair.ts
@@ -88,13 +88,14 @@ function findSdkMatch(
     let combined = "";
     for (let end = start; end < messages.length; end += 1) {
       combined = normalizeText(`${combined}${messages[end]!.normalizedText}`);
-      if (combined === normalizedRun || combined.startsWith(normalizedRun)) {
+      // Only an EXACT match may rebuild. A superset match (SDK text merely
+      // starting with the run) could splice content the ADE transcript never
+      // showed into history; a partial match (SDK covering only a prefix of
+      // the run) would drop the run's uncovered tail. Both fall back to the
+      // caller's lossless local merge instead.
+      if (combined === normalizedRun) {
         return { messages: messages.slice(start, end + 1), nextIndex: end + 1 };
       }
-      // Partial coverage (SDK text is only a prefix of the run) must NOT win:
-      // rebuilding from it would drop the run's uncovered tail. Keep scanning
-      // while the SDK side could still complete the run, otherwise move on and
-      // let the caller fall back to the lossless local merge.
       if (normalizedRun.startsWith(combined)) continue;
       break;
     }
diff --git a/apps/desktop/src/main/services/chat/claudeSubprocessReaper.test.ts b/apps/desktop/src/main/services/chat/claudeSubprocessReaper.test.ts
index 7b960826f..1fb242940 100644
--- a/apps/desktop/src/main/services/chat/claudeSubprocessReaper.test.ts
+++ b/apps/desktop/src/main/services/chat/claudeSubprocessReaper.test.ts
@@ -179,6 +179,31 @@ describe("createClaudeSubprocessReaper", () => {
     expect(otherChild.killedWith).toEqual([]);
   });
 
+  it("escalates to SIGKILL for a hung child even though killed=true after SIGTERM", () => {
+    // Node sets child.killed as soon as ANY signal is delivered — it does NOT
+    // mean the process exited. A hung child must still get the escalation.
+    vi.useFakeTimers();
+    const logger = createLogger();
+    const child = createProcess(9911);
+    child.kill = vi.fn((signal: NodeJS.Signals) => {
+      child.killedWith.push(signal);
+      child.killed = true; // Node-faithful: true after the first delivered signal.
+      return true;
+    });
+    const reaper = createClaudeSubprocessReaper({ logger, killGraceMs: 25 });
+    reaper.register(child, {
+      sessionId: "chat-hung",
+      laneId: "lane-1",
+      cwd: "/tmp/lane-1",
+    }, "claude", []);
+
+    reaper.reapForSession("chat-hung", "ended_session");
+    expect(child.killedWith).toEqual(["SIGTERM"]);
+
+    vi.advanceTimersByTime(25);
+    expect(child.killedWith).toEqual(["SIGTERM", "SIGKILL"]);
+  });
+
   it("reaps subprocesses left behind by a crashed ADE owner", () => {
     vi.useFakeTimers();
     const logger = createLogger();
diff --git a/apps/desktop/src/main/services/chat/claudeSubprocessReaper.ts b/apps/desktop/src/main/services/chat/claudeSubprocessReaper.ts
index 55630b234..3e164a710 100644
--- a/apps/desktop/src/main/services/chat/claudeSubprocessReaper.ts
+++ b/apps/desktop/src/main/services/chat/claudeSubprocessReaper.ts
@@ -237,7 +237,10 @@ export function createClaudeSubprocessReaper(args: {
     reason: string,
   ): void => {
     const child = entry.process;
-    if (child.killed || child.exitCode !== null || entry.killTimer) return;
+    // `child.killed` only means "a signal was sent", not "the process exited" —
+    // gate on exit/signal codes so a hung child still gets the SIGKILL escalation.
+    const exited = () => child.exitCode !== null || (child as { signalCode?: string | null }).signalCode != null;
+    if (exited() || entry.killTimer) return;
     logger.warn("agent_chat.claude_subprocess_terminate", {
       pid,
       sessionId: entry.record.sessionId,
@@ -249,7 +252,7 @@ export function createClaudeSubprocessReaper(args: {
       // Best effort; the process may already be gone.
     }
     entry.killTimer = setTimer(() => {
-      if (!child.killed && child.exitCode === null) {
+      if (!exited()) {
         logger.warn("agent_chat.claude_subprocess_kill", {
           pid,
           sessionId: entry.record.sessionId,
diff --git a/apps/desktop/src/renderer/components/terminals/SessionContextMenu.test.tsx b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.test.tsx
index b121ec597..826d2eb7c 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionContextMenu.test.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionContextMenu.test.tsx
@@ -69,8 +69,27 @@ describe("SessionContextMenu Claude tags", () => {
     expect(onClose).toHaveBeenCalledTimes(1);
   });
 
+  it("submits a non-empty tag for the session", () => {
+    const session = makeSession();
+    const { onClose, onSetChatTag } = renderMenu(session);
+
+    fireEvent.click(screen.getByRole("button", { name: "Set tag…" }));
+    const input = screen.getByRole("textbox", { name: "Set Claude session tag" }) as HTMLInputElement;
+    fireEvent.change(input, { target: { value: "review-ready" } });
+    fireEvent.keyDown(input, { key: "Enter" });
+
+    expect(onSetChatTag).toHaveBeenCalledWith(session, "review-ready");
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
   it("does not offer SDK tags for non-Claude chat sessions", () => {
     renderMenu(makeSession({ toolType: "codex-chat" }));
     expect(screen.queryByRole("button", { name: "Set tag…" })).toBeNull();
   });
+
+  it("does not offer SDK tags for ended Claude sessions", () => {
+    // Tag writes need a live Claude SDK runtime; the menu gates on running.
+    renderMenu(makeSession({ status: "disposed", endedAt: "2026-07-10T13:00:00.000Z" }));
+    expect(screen.queryByRole("button", { name: "Set tag…" })).toBeNull();
+  });
 });