From 15c8d6c417387584839dc3a1e3e222590c7a2968 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Wed, 2 Sep 2026 15:26:44 -0400
Subject: [PATCH 1/3] feat(chat): wire Claude SDK tier 3 stop, context, and
 auto-continue

Default Stop now clears the queue without tearing down background Claude jobs, per-task stop is public, /context classifies by kind, and chats auto-continue at the plan limit unless the user opts out.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 apps/ade-cli/src/adeRpcServer.ts              |   1 +
 apps/ade-cli/src/cli.test.ts                  |  33 +-
 apps/ade-cli/src/cli.ts                       |  73 ++-
 .../personalChats/personalChatScope.ts        |   4 +
 .../sync/syncRemoteCommandService.test.ts     |   2 +-
 .../services/sync/syncRemoteCommandService.ts |  18 +-
 apps/ade-cli/src/tuiClient/app.tsx            |  33 +-
 apps/ade-cli/src/tuiClient/commands.ts        |   2 +-
 apps/desktop/src/main/main.ts                 |  17 +
 .../main/services/adeActions/registry.test.ts |   3 +-
 .../src/main/services/adeActions/registry.ts  |   1 +
 .../services/chat/agentChatService.test.ts    | 528 +++++++++++++++++-
 .../main/services/chat/agentChatService.ts    | 463 ++++++++++++---
 .../src/main/services/ipc/registerIpc.ts      |  21 +-
 .../sessions/chatSessionProjection.ts         |   1 +
 .../sessions/settleTeardownWiring.test.ts     |   5 +-
 .../services/sessions/settleTeardownWiring.ts |  15 +-
 apps/desktop/src/preload/global.d.ts          |   6 +
 apps/desktop/src/preload/preload.ts           |  18 +
 apps/desktop/src/renderer/browserMock.ts      |   1 +
 .../components/chat/AgentChatComposer.tsx     |  38 +-
 .../chat/AgentChatMessageList.test.tsx        |  28 +-
 .../components/chat/AgentChatMessageList.tsx  |  80 ++-
 .../components/chat/AgentChatPane.test.tsx    |  26 +-
 .../components/chat/AgentChatPane.tsx         | 103 +++-
 .../chat/ChatSubagentsPanel.test.tsx          |  39 ++
 .../components/chat/ChatSubagentsPanel.tsx    |  46 +-
 .../chat/ProviderFailureRecoveryCard.tsx      |  34 +-
 .../chat/SubagentActivityCards.test.tsx       |  24 +
 .../components/chat/SubagentActivityCards.tsx |  20 +-
 .../chat/chatTranscriptRows.test.ts           |   1 +
 .../components/chat/chatTranscriptRows.ts     |  12 +
 .../renderer/webclient/adapter/agentChat.ts   |   9 +
 .../desktop/src/shared/chatAutoResume.test.ts |  25 +
 apps/desktop/src/shared/chatAutoResume.ts     |  35 ++
 apps/desktop/src/shared/chatStopModes.test.ts |  84 +++
 apps/desktop/src/shared/chatStopModes.ts      | 136 +++++
 .../shared/claudeClassifierContext.test.ts    |  55 ++
 .../src/shared/claudeClassifierContext.ts     |  84 +++
 .../src/shared/claudeContextUsage.test.ts     |  73 +++
 apps/desktop/src/shared/claudeContextUsage.ts | 142 +++++
 .../src/shared/claudeModelSwitch.test.ts      |  38 ++
 apps/desktop/src/shared/claudeModelSwitch.ts  |  55 ++
 apps/desktop/src/shared/ipc.ts                |   1 +
 .../shared/sessionStatusPresentation.test.ts  |  23 +-
 .../src/shared/sessionStatusPresentation.ts   |  15 +
 .../src/shared/syncMobileCompatibility.ts     |   1 +
 apps/desktop/src/shared/types/chat.ts         |  32 +-
 .../desktop/src/shared/types/personalChats.ts |   3 +
 apps/desktop/src/shared/types/sessions.ts     |   5 +
 apps/desktop/src/shared/types/sync.ts         |   1 +
 apps/ios/ADE/Models/RemoteModels.swift        |  25 +-
 apps/ios/ADE/Services/SyncService.swift       |  18 +-
 .../Views/Work/WorkChatRichCardViews.swift    |  73 ++-
 .../Work/WorkChatSessionView+Timeline.swift   |   8 +-
 .../ADE/Views/Work/WorkChatSessionView.swift  | 140 ++++-
 .../Work/WorkErrorAndMessageHelpers.swift     |   2 +-
 apps/ios/ADE/Views/Work/WorkModels.swift      | 110 ++++
 .../Work/WorkSessionCanonicalState.swift      |  25 +-
 .../WorkSessionDestinationView+Actions.swift  |  31 +
 .../Work/WorkSessionDestinationView.swift     |  14 +-
 .../Work/WorkStatusAndFormattingHelpers.swift |  16 +
 apps/ios/ADETests/ADETests.swift              | 140 +++++
 docs/features/chat/README.md                  |  59 +-
 docs/features/chat/composer-and-ui.md         |  34 +-
 docs/features/chat/transcript-and-turns.md    |  12 +-
 .../sync-and-multi-device/ios-companion.md    |  15 +-
 .../sync-and-multi-device/remote-commands.md  |  18 +-
 68 files changed, 2944 insertions(+), 309 deletions(-)
 create mode 100644 apps/desktop/src/shared/chatStopModes.test.ts
 create mode 100644 apps/desktop/src/shared/chatStopModes.ts
 create mode 100644 apps/desktop/src/shared/claudeClassifierContext.test.ts
 create mode 100644 apps/desktop/src/shared/claudeClassifierContext.ts
 create mode 100644 apps/desktop/src/shared/claudeContextUsage.test.ts
 create mode 100644 apps/desktop/src/shared/claudeContextUsage.ts
 create mode 100644 apps/desktop/src/shared/claudeModelSwitch.test.ts
 create mode 100644 apps/desktop/src/shared/claudeModelSwitch.ts

diff --git a/apps/ade-cli/src/adeRpcServer.ts b/apps/ade-cli/src/adeRpcServer.ts
index 63ed6f230..c11cc8c21 100644
--- a/apps/ade-cli/src/adeRpcServer.ts
+++ b/apps/ade-cli/src/adeRpcServer.ts
@@ -2683,6 +2683,7 @@ const SCOPED_CHAT_ACTIONS = new Set([
   // all CTO-only and refuse a session-bound agent outright — no scoping needed.
   "interrupt",
   "interruptWithQueueMode",
+  "stopTask",
   "restoreCancelledQueue",
   "setSpawnKind",
   "dismissSubagentTakeoverPrompt",
diff --git a/apps/ade-cli/src/cli.test.ts b/apps/ade-cli/src/cli.test.ts
index 9db72c240..ac2eba937 100644
--- a/apps/ade-cli/src/cli.test.ts
+++ b/apps/ade-cli/src/cli.test.ts
@@ -4535,19 +4535,48 @@ describe("ADE CLI", () => {
       "chat-1",
       "--keep-queue",
       "--clear-queue",
-    ])).toThrow(/only one of --mode, --keep-queue, or --clear-queue/);
+    ])).toThrow(/Use only one of --keep-queue or --clear-queue/);
     expect(() => buildCliPlan([
       "chat",
       "interrupt",
       "chat-1",
       "--arg",
       "mode=discard_everything",
-    ])).toThrow(/stop_and_clear or stop_only/);
+    ])).toThrow(/stop_and_clear, stop_only, stop_and_background, or stop_and_clear_and_background/);
     expect(() => buildCliPlan([
       "chat",
       "restore-queue",
       "chat-1",
     ])).toThrow(/recoveryId/);
+
+    const stopTask = expectExecutePlan(buildCliPlan([
+      "chat",
+      "stop-task",
+      "chat-1",
+      "task-A",
+    ]));
+    expect(stopTask.label).toBe("chat stop task");
+    expect(stopTask.steps[0]?.params).toMatchObject({
+      arguments: {
+        domain: "chat",
+        action: "stopTask",
+        args: { sessionId: "chat-1", taskId: "task-A" },
+      },
+    });
+
+    const personalStopTask = expectExecutePlan(buildCliPlan([
+      "chat",
+      "stop-task",
+      "personal-1",
+      "--personal",
+      "--task",
+      "task-B",
+    ]));
+    expect(personalStopTask.machineOnly).toBe(true);
+    expect(personalStopTask.steps[0]?.params).toEqual({
+      action: "stopTask",
+      args: { sessionId: "personal-1", taskId: "task-B" },
+    });
   });
 
   it("routes chat demote, promote, and keep-reporting to spawn-kind actions", () => {
diff --git a/apps/ade-cli/src/cli.ts b/apps/ade-cli/src/cli.ts
index 85b70abb7..004b907a9 100644
--- a/apps/ade-cli/src/cli.ts
+++ b/apps/ade-cli/src/cli.ts
@@ -78,6 +78,10 @@ import {
   type AgentChatDroidPermissionMode,
 } from "../../desktop/src/shared/types/chat";
 import type { AgentChatDispatchSteerMode } from "../../desktop/src/shared/types/chat";
+import {
+  isAgentChatStopMode,
+  type AgentChatStopMode,
+} from "../../desktop/src/shared/chatStopModes";
 import {
   chatTurnStatusExitCode,
   formatChatTurnStatus,
@@ -2175,10 +2179,14 @@ const HELP_BY_COMMAND: Record<string, string> = {
                                                     Detach one issue (or all) from a session
     $ ade chat linear-issues <session> --text       List issues attached to a session
     $ ade chat interrupt <session>                  Stop an active turn and clear its queued messages
+    $ ade chat interrupt <session> --keep-queue     Stop the turn but preserve queued messages
+    $ ade chat interrupt <session> --stop-background
+                                                    Also stop background jobs; combine with --keep-queue
+    $ ade chat interrupt <session> --mode <mode>    stop_and_clear | stop_only | stop_and_background | stop_and_clear_and_background
+    $ ade chat stop-task <session> <taskId>         Stop one Claude background task; siblings keep running
     $ ade chat demote <session>                     Take over a subagent: it becomes a peer and reports stop
     $ ade chat promote <session>                    Restore a peer as a subagent so it reports to its parent again
     $ ade chat keep-reporting <session>             Dismiss the takeover prompt without changing the report channel
-    $ ade chat interrupt <session> --keep-queue     Stop the turn but preserve queued messages
     $ ade chat restore-queue <session> <recovery>   Restore a recently cleared queue during its undo window
     $ ade chat slash <session> --text               List slash commands for a session
     $ ade new chat --mode cli --lane <lane> --parent <session> --type subagent --prompt "fix"
@@ -3219,21 +3227,28 @@ function readLaneId(args: string[]): string | null {
   return readValue(args, ["--lane", "--lane-id"]) ?? null;
 }
 
-function normalizeChatStopMode(value: unknown): "stop_and_clear" | "stop_only" {
-  if (value === "stop_and_clear" || value === "stop_only") return value;
-  throw new CliUsageError("chat interrupt --mode must be stop_and_clear or stop_only.");
+function normalizeChatStopMode(value: unknown): AgentChatStopMode {
+  if (isAgentChatStopMode(value)) return value;
+  throw new CliUsageError("chat interrupt --mode must be stop_and_clear, stop_only, stop_and_background, or stop_and_clear_and_background.");
 }
 
-function readChatStopMode(args: string[]): "stop_and_clear" | "stop_only" {
+function readChatStopMode(args: string[]): AgentChatStopMode {
   const explicitMode = readValue(args, ["--mode"]);
   const keepQueue = readFlag(args, ["--keep-queue", "--stop-only"]);
   const clearQueue = readFlag(args, ["--clear-queue", "--stop-and-clear"]);
-  const selected = [explicitMode, keepQueue ? "stop_only" : null, clearQueue ? "stop_and_clear" : null]
-    .filter((value): value is string => value !== null);
-  if (selected.length > 1) {
-    throw new CliUsageError("Use only one of --mode, --keep-queue, or --clear-queue.");
+  const stopBackground = readFlag(args, ["--stop-background"]);
+  if (explicitMode && (keepQueue || clearQueue || stopBackground)) {
+    throw new CliUsageError("Use --mode or the queue/background flags, not both.");
+  }
+  if (keepQueue && clearQueue) {
+    throw new CliUsageError("Use only one of --keep-queue or --clear-queue.");
   }
-  return normalizeChatStopMode(selected[0] ?? "stop_and_clear");
+  if (explicitMode) return normalizeChatStopMode(explicitMode);
+  if (keepQueue && stopBackground) return "stop_and_background";
+  if (clearQueue && stopBackground) return "stop_and_clear_and_background";
+  if (stopBackground) return "stop_and_background";
+  if (keepQueue) return "stop_only";
+  return "stop_and_clear";
 }
 
 /**
@@ -8074,6 +8089,27 @@ function buildChatPlan(args: string[]): CliPlan {
       ],
     };
   }
+  if (sub === "stop-task") {
+    const taskId = requireValue(
+      readValue(args, ["--task", "--task-id"]) ?? firstStandalonePositional(args),
+      "taskId",
+    );
+    return {
+      kind: "execute",
+      label: "chat stop task",
+      steps: [
+        actionStep(
+          "result",
+          "chat",
+          "stopTask",
+          withSession({
+            sessionId: requireValue(sessionId, "sessionId"),
+            taskId,
+          }),
+        ),
+      ],
+    };
+  }
   if (
     sub === "restore-queue"
     || sub === "restore-cancelled-queue"
@@ -8664,6 +8700,7 @@ function buildPersonalChatPlan(sub: string, args: string[]): CliPlan {
     "configure",
     "interrupt",
     "stop",
+    "stop-task",
     "restore-queue",
     "restore-cancelled-queue",
     "undo-stop",
@@ -8680,7 +8717,7 @@ function buildPersonalChatPlan(sub: string, args: string[]): CliPlan {
     "status",
   ]);
   if (!sessionSubcommands.has(sub)) {
-    throw new CliUsageError(`Personal chats support actions, action, list, create, show, read, send, steer, update, models, model-catalog, interrupt, restore-queue, recover, resolve-unprocessed, archive, unarchive, or delete; got '${sub}'.`);
+    throw new CliUsageError(`Personal chats support actions, action, list, create, show, read, send, steer, update, models, model-catalog, interrupt, stop-task, restore-queue, recover, resolve-unprocessed, archive, unarchive, or delete; got '${sub}'.`);
   }
 
   const sessionId = requireValue(
@@ -8770,6 +8807,20 @@ function buildPersonalChatPlan(sub: string, args: string[]): CliPlan {
       steps: [personalChatStep("interrupt", interruptArgs)],
     };
   }
+  if (sub === "stop-task") {
+    const taskId = requireValue(
+      readValue(args, ["--task", "--task-id"]) ?? firstStandalonePositional(args),
+      "taskId",
+    );
+    return {
+      ...base,
+      label: "personal chat stop task",
+      steps: [personalChatStep("stopTask", collectGenericObjectArgs(args, {
+        sessionId,
+        taskId,
+      }))],
+    };
+  }
   if (
     sub === "restore-queue"
     || sub === "restore-cancelled-queue"
diff --git a/apps/ade-cli/src/services/personalChats/personalChatScope.ts b/apps/ade-cli/src/services/personalChats/personalChatScope.ts
index fceb5affe..24d158282 100644
--- a/apps/ade-cli/src/services/personalChats/personalChatScope.ts
+++ b/apps/ade-cli/src/services/personalChats/personalChatScope.ts
@@ -461,6 +461,10 @@ export class PersonalChatScope {
         await this.requirePersonalSession(service, readSessionId(args));
         result = await service.interrupt(args as never);
         break;
+      case "stopTask":
+        await this.requirePersonalSession(service, readSessionId(args));
+        result = await service.stopTask(args as never);
+        break;
       case "restoreCancelledQueue":
         await this.requirePersonalSession(service, readSessionId(args));
         result = await service.restoreCancelledQueue(args as never);
diff --git a/apps/ade-cli/src/services/sync/syncRemoteCommandService.test.ts b/apps/ade-cli/src/services/sync/syncRemoteCommandService.test.ts
index 52e9d3da5..74f9b1a17 100644
--- a/apps/ade-cli/src/services/sync/syncRemoteCommandService.test.ts
+++ b/apps/ade-cli/src/services/sync/syncRemoteCommandService.test.ts
@@ -1095,7 +1095,7 @@ describe("createSyncRemoteCommandService", () => {
     await expect(service.execute(makePayload("chat.interrupt", {
       sessionId: "chat-1",
       mode: "discard_everything",
-    }))).rejects.toThrow(/stop_and_clear.*stop_only/);
+    }))).rejects.toThrow(/known stop mode/);
     await expect(service.execute(makePayload("chat.restoreCancelledQueue", {
       sessionId: "chat-1",
     }))).rejects.toThrow(/requires recoveryId/);
diff --git a/apps/ade-cli/src/services/sync/syncRemoteCommandService.ts b/apps/ade-cli/src/services/sync/syncRemoteCommandService.ts
index 4f803d1d7..cb1f84506 100644
--- a/apps/ade-cli/src/services/sync/syncRemoteCommandService.ts
+++ b/apps/ade-cli/src/services/sync/syncRemoteCommandService.ts
@@ -9,6 +9,7 @@ import {
   isAgentChatTurnRecoveryAction,
   normalizeAgentChatSessionMetadataFields,
 } from "../../../../desktop/src/shared/types/chat";
+import { isAgentChatStopMode } from "../../../../desktop/src/shared/chatStopModes";
 import { runWithAbortSignal } from "./abortSignal";
 import { projectAttachmentsDir } from "../../../../desktop/src/shared/chatAttachmentStagingFs";
 import { assertCursorCloudRenameAllowed } from "../../../../desktop/src/shared/cursorCloudNaming";
@@ -66,6 +67,7 @@ import type {
   AgentChatDispatchSteerArgs,
   AgentChatCancelDispatchedSteerArgs,
   AgentChatInterruptArgs,
+  AgentChatStopTaskArgs,
   AgentChatRestoreCancelledQueueArgs,
   AgentChatRecoverCodexTurnArgs,
   AgentChatRecoverTurnArgs,
@@ -2605,8 +2607,8 @@ function parseAgentChatCancelDispatchedSteerArgs(value: Record<string, unknown>)
 
 function parseAgentChatInterruptArgs(value: Record<string, unknown>): AgentChatInterruptArgs {
   const mode = value.mode;
-  if (mode !== undefined && mode !== "stop_and_clear" && mode !== "stop_only") {
-    throw new Error("chat.interrupt mode must be 'stop_and_clear' or 'stop_only'.");
+  if (mode !== undefined && !isAgentChatStopMode(mode)) {
+    throw new Error("chat.interrupt mode must be a known stop mode.");
   }
   return {
     sessionId: requireString(value.sessionId, "chat.interrupt requires sessionId."),
@@ -2614,6 +2616,13 @@ function parseAgentChatInterruptArgs(value: Record<string, unknown>): AgentChatI
   };
 }
 
+function parseAgentChatStopTaskArgs(value: Record<string, unknown>): AgentChatStopTaskArgs {
+  return {
+    sessionId: requireString(value.sessionId, "chat.stopTask requires sessionId."),
+    taskId: requireString(value.taskId, "chat.stopTask requires taskId."),
+  };
+}
+
 function parseAgentChatRestoreCancelledQueueArgs(value: Record<string, unknown>): AgentChatRestoreCancelledQueueArgs {
   return {
     sessionId: requireString(value.sessionId, "chat.restoreCancelledQueue requires sessionId."),
@@ -4777,6 +4786,11 @@ function registerChatRemoteCommands({ args, register }: RemoteCommandRegistratio
     const result = await requireService(args.agentChatService, "Agent chat service not available.").interrupt(parseAgentChatInterruptArgs(payload));
     return { ...result, ok: true };
   });
+  register("chat.stopTask", { viewerAllowed: true, queueable: false }, async (payload) => {
+    const result = await requireService(args.agentChatService, "Agent chat service not available.")
+      .stopTask(parseAgentChatStopTaskArgs(payload));
+    return { ...result, ok: true };
+  });
   register("chat.restoreCancelledQueue", { viewerAllowed: true, queueable: false }, async (payload) => {
     const result = await requireService(args.agentChatService, "Agent chat service not available.")
       .restoreCancelledQueue(parseAgentChatRestoreCancelledQueueArgs(payload));
diff --git a/apps/ade-cli/src/tuiClient/app.tsx b/apps/ade-cli/src/tuiClient/app.tsx
index 20880a716..dfffe349d 100644
--- a/apps/ade-cli/src/tuiClient/app.tsx
+++ b/apps/ade-cli/src/tuiClient/app.tsx
@@ -20,6 +20,12 @@ import {
   unsupportedActiveTurnDispatchModeMessage,
 } from "../../../desktop/src/shared/types/chat";
 import { providerDisplayLabel } from "../../../desktop/src/shared/pendingInputLabels";
+import {
+  parseAgentChatStopMode,
+  resolveAgentChatStopModeAlias,
+  stopModeClearsQueue,
+  stopModeStopsBackground,
+} from "../../../desktop/src/shared/chatStopModes";
 import {
   composerFileSearchQuery,
   composerTriggerForSelection,
@@ -1329,14 +1335,16 @@ function formatTokenSummary(stats: ReturnType<typeof latestTokenStats>): string
 }
 
 function chatInterruptNotice(result: Awaited<ReturnType<typeof interruptChat>>): string {
-  if (result.mode === "stop_only") {
-    return "Stopped. Queued messages are preserved.";
+  const stoppedBackground = stopModeStopsBackground(parseAgentChatStopMode(result.mode));
+  const backgroundNote = stoppedBackground ? " Background jobs were stopped." : "";
+  if (!stopModeClearsQueue(parseAgentChatStopMode(result.mode))) {
+    return `Stopped. Queued messages are preserved.${backgroundNote}`;
   }
   if (result.cancelledQueuedCount > 0 && result.recoveryId) {
     const noun = result.cancelledQueuedCount === 1 ? "message" : "messages";
-    return `Stopped and cleared ${result.cancelledQueuedCount} queued ${noun}. Undo: /restore-queue ${result.recoveryId}`;
+    return `Stopped and cleared ${result.cancelledQueuedCount} queued ${noun}. Undo: /restore-queue ${result.recoveryId}${backgroundNote}`;
   }
-  return "Stopped.";
+  return `Stopped.${backgroundNote}`;
 }
 
 export function formatGoalBannerLine(goal: CodexThreadGoal | ClaudeActiveGoal | null): string | null {
@@ -12321,18 +12329,11 @@ export function AdeCodeApp({ project, forceEmbedded, requireSocket, socketPath,
         return;
       }
       const normalizedMode = args.trim().toLowerCase();
-      let mode: AgentChatStopMode;
-      if (!normalizedMode || normalizedMode === "clear-queue" || normalizedMode === "--clear-queue") {
-        mode = "stop_and_clear";
-      } else if (
-        normalizedMode === "keep-queue"
-        || normalizedMode === "--keep-queue"
-        || normalizedMode === "stop-only"
-        || normalizedMode === "--stop-only"
-      ) {
-        mode = "stop_only";
-      } else {
-        addNotice("Usage: /stop [keep-queue|clear-queue]", "error");
+      const mode = normalizedMode
+        ? resolveAgentChatStopModeAlias(normalizedMode)
+        : "stop_and_clear";
+      if (!mode) {
+        addNotice("Usage: /stop [keep-queue|clear-queue|background|clear-and-background]", "error");
         return;
       }
       setStreaming(false);
diff --git a/apps/ade-cli/src/tuiClient/commands.ts b/apps/ade-cli/src/tuiClient/commands.ts
index e633bedb5..f12b901b7 100644
--- a/apps/ade-cli/src/tuiClient/commands.ts
+++ b/apps/ade-cli/src/tuiClient/commands.ts
@@ -68,7 +68,7 @@ export const BUILTIN_COMMANDS: BuiltinCommand[] = [
   { name: "/redo", description: "Redo the most recently undone HEAD change on the active lane", placement: "inline", category: "Lanes" },
   { name: "/stage all", description: "Stage all changes in the active lane", placement: "inline", category: "Lanes" },
   { name: "/clear", description: "Clear the local terminal transcript view", placement: "inline", category: "Chats" },
-  { name: "/stop", description: "Stop the active turn and clear or preserve its queue", placement: "inline", argumentHint: "[keep-queue|clear-queue]", category: "Chats" },
+  { name: "/stop", description: "Stop the active turn; optionally keep the queue or stop background jobs", placement: "inline", argumentHint: "[keep-queue|clear-queue|background|clear-and-background]", category: "Chats" },
   { name: "/restore-queue", description: "Undo a recent Stop & clear queue", placement: "inline", argumentHint: "<recovery-id>", category: "Chats" },
   { name: "/login", description: "Sign in to the active CLI-backed provider from this terminal", placement: "inline", category: "Nav" },
   // The way back from an account-side machine removal — the same repair
diff --git a/apps/desktop/src/main/main.ts b/apps/desktop/src/main/main.ts
index e14f3fca2..dad5e02ed 100644
--- a/apps/desktop/src/main/main.ts
+++ b/apps/desktop/src/main/main.ts
@@ -3910,6 +3910,23 @@ app.whenReady().then(async () => {
         analytics: productAnalyticsService,
         properties,
       }),
+      onUsageLimitAutoResumed: ({ sessionId, title }) => {
+        if (!Notification.isSupported()) return;
+        try {
+          const notification = new Notification({
+            title: "Chat resumed",
+            body: title?.trim()
+              ? `"${title.trim()}" continued after its usage limit reset.`
+              : "A chat continued after its usage limit reset.",
+          });
+          notification.show();
+        } catch (error) {
+          logger.warn("agent_chat.usage_limit_resume_notification_failed", {
+            sessionId,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      },
       onSessionEnded: onTrackedSessionEnded,
       getDirtyFileTextForPath: async (absPath: string) => {
         const trimmed = absPath.trim();
diff --git a/apps/desktop/src/main/services/adeActions/registry.test.ts b/apps/desktop/src/main/services/adeActions/registry.test.ts
index 1805c16d6..fc8e0634f 100644
--- a/apps/desktop/src/main/services/adeActions/registry.test.ts
+++ b/apps/desktop/src/main/services/adeActions/registry.test.ts
@@ -154,6 +154,7 @@ describe("isAllowedAdeAction", () => {
     expect(isAllowedAdeAction("chat", "getCodexGoal")).toBe(true);
     expect(isAllowedAdeAction("chat", "resetCodexMemory")).toBe(true);
     expect(isAllowedAdeAction("chat", "terminateCodexBackgroundTerminal")).toBe(true);
+    expect(isAllowedAdeAction("chat", "stopTask")).toBe(true);
     expect(isAllowedAdeAction("git", "getCommit")).toBe(true);
   });
 
@@ -212,7 +213,7 @@ describe("isAllowedAdeAction", () => {
       "resolveSmartLinkPreview", "resolveUnprocessedMessage", "respondToInput",
       "restoreCancelledQueue", "rewindFiles", "saveTempAttachment", "sendMessage",
       "setClaudeOutputStyle", "setCodexGoal", "setCodexGoalStatus", "setParallelLaunchState",
-      "setScheduledWorkPaused", "steer", "suggestLaneNameFromPrompt",
+      "setScheduledWorkPaused", "steer", "stopTask", "suggestLaneNameFromPrompt",
       "terminateCodexBackgroundTerminal", "unarchiveSession", "updateSession",
       "validateCrossMachineSource", "warmupModel",
       // src/main/services/remoteRuntime/remoteConnectionService.ts
diff --git a/apps/desktop/src/main/services/adeActions/registry.ts b/apps/desktop/src/main/services/adeActions/registry.ts
index bdab4e958..05e8cca08 100644
--- a/apps/desktop/src/main/services/adeActions/registry.ts
+++ b/apps/desktop/src/main/services/adeActions/registry.ts
@@ -609,6 +609,7 @@ export const ADE_ACTION_ALLOWLIST: Partial<Record<AdeActionDomain, readonly stri
     "getParallelLaunchState",
     "interrupt",
     "interruptWithQueueMode",
+    "stopTask",
     "recoverTurn",
     "recoverCodexTurn",
     "resolveUnprocessedMessage",
diff --git a/apps/desktop/src/main/services/chat/agentChatService.test.ts b/apps/desktop/src/main/services/chat/agentChatService.test.ts
index 0ab5a3aaf..938463d40 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.test.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.test.ts
@@ -3736,6 +3736,8 @@ describe("createAgentChatService", () => {
       const opts = vi.mocked(claudeSdkCreateSessionCompat).mock.calls[0]?.[0] as {
         includeHookEvents?: boolean;
         promptSuggestions?: boolean;
+        perTaskStopAffordance?: boolean;
+        autoContinueAtUsageLimit?: boolean;
         settingSources?: string[];
         settings?: {
           enabledPlugins?: Record<string, boolean>;
@@ -3756,6 +3758,8 @@ describe("createAgentChatService", () => {
       ]));
       expect(opts?.includeHookEvents).toBe(true);
       expect(opts?.promptSuggestions).toBe(true);
+      expect(opts?.perTaskStopAffordance).toBe(true);
+      expect(opts?.autoContinueAtUsageLimit).toBe(true);
       // No settings file names a style here, so ADE must not name one either:
       // its settings land at flag tier, above every file the SDK reads, so an
       // "outputStyle" key would override the user's global selection.
@@ -10849,6 +10853,187 @@ describe("createAgentChatService", () => {
       expect(close.mock.calls.length).toBeGreaterThan(0);
     });
 
+    it("parks the session while Claude waits on a usage-limit reset and clears park on opt-out", async () => {
+      const resetsAt = Math.floor((Date.now() + 3_600_000) / 1000);
+      const send = vi.fn().mockResolvedValue(undefined);
+      const close = vi.fn();
+      let streamCall = 0;
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        yield {
+          type: "rate_limit_event",
+          session_id: "sdk-session-park",
+          rate_limit_info: {
+            status: "rejected",
+            utilization: 1,
+            resetsAt,
+          },
+        };
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send, stream, close, sessionId: "sdk-session-park",
+      } as any);
+      vi.mocked(claudeSdkResumeSessionCompat).mockReturnValue({
+        send, stream, close, sessionId: "sdk-session-park",
+      } as any);
+
+      const { service } = createService();
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await service.runSessionTurn({
+        sessionId: session.id,
+        text: "hit the limit",
+        timeoutMs: 15_000,
+      });
+      const parked = await service.getSessionSummary(session.id);
+      expect(parked?.usageLimitParkedUntil).toEqual(expect.any(String));
+      expect(Date.parse(parked!.usageLimitParkedUntil!)).toBeGreaterThan(Date.now());
+
+      await service.updateSession({
+        sessionId: session.id,
+        autoContinueAtUsageLimit: false,
+      });
+      const optedOut = await service.getSessionSummary(session.id);
+      expect(optedOut?.autoContinueAtUsageLimit).toBe(false);
+      expect(optedOut?.usageLimitParkedUntil ?? null).toBeNull();
+    });
+
+    it("Don't continue interrupts a busy Claude query without closing the session", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      let streamCall = 0;
+      let warmupComplete = false;
+      let hangResolve: (() => void) | null = null;
+      const hangPromise = new Promise<void>((resolve) => { hangResolve = resolve; });
+      const close = vi.fn();
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "system", subtype: "init", session_id: "sdk-opt-out-busy", slash_commands: [] };
+          warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        yield {
+          type: "stream_event",
+          event: {
+            type: "content_block_delta",
+            index: 0,
+            delta: { type: "text_delta", text: "still working" },
+          },
+        };
+        await hangPromise;
+        return;
+      })());
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send: vi.fn().mockResolvedValue(undefined),
+        stream,
+        close,
+        sessionId: "sdk-opt-out-busy",
+        setPermissionMode: vi.fn().mockResolvedValue(undefined),
+      } as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await vi.waitFor(() => {
+        expect(warmupComplete).toBe(true);
+      });
+      const sendPromise = service.sendMessage({
+        sessionId: session.id,
+        text: "Please keep working",
+      });
+      await waitForEvent(
+        events,
+        (event): event is AgentChatEventEnvelope => event.event.type === "text",
+      );
+
+      await service.updateSession({
+        sessionId: session.id,
+        autoContinueAtUsageLimit: false,
+      });
+
+      const optedOut = await service.getSessionSummary(session.id);
+      expect(optedOut?.autoContinueAtUsageLimit).toBe(false);
+      const interruptedStatuses = events.filter(
+        (event) => event.event.type === "status" && event.event.turnStatus === "interrupted",
+      );
+      const interruptedDone = events.filter(
+        (event) => event.event.type === "done" && event.event.status === "interrupted",
+      );
+      expect(interruptedStatuses.length).toBeGreaterThan(0);
+      expect(interruptedDone.length).toBeGreaterThan(0);
+      expect(close).not.toHaveBeenCalled();
+
+      hangResolve!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+
+    it("clears usage-limit park on a user send without notifying", async () => {
+      const onUsageLimitAutoResumed = vi.fn();
+      const resetsAt = Math.floor((Date.now() + 3_600_000) / 1000);
+      const send = vi.fn().mockResolvedValue(undefined);
+      const close = vi.fn();
+      let streamCall = 0;
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        yield {
+          type: "rate_limit_event",
+          session_id: "sdk-session-park-notify",
+          rate_limit_info: {
+            status: "rejected",
+            utilization: 1,
+            resetsAt,
+          },
+        };
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send, stream, close, sessionId: "sdk-session-park-notify",
+      } as any);
+      vi.mocked(claudeSdkResumeSessionCompat).mockReturnValue({
+        send, stream, close, sessionId: "sdk-session-park-notify",
+      } as any);
+
+      const { service } = createService({ onUsageLimitAutoResumed });
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await service.runSessionTurn({
+        sessionId: session.id,
+        text: "hit the limit",
+        timeoutMs: 15_000,
+      });
+      const parked = await service.getSessionSummary(session.id);
+      expect(Date.parse(parked!.usageLimitParkedUntil!)).toBeGreaterThan(Date.now());
+
+      await service.sendMessage({
+        sessionId: session.id,
+        text: "I'll take it from here.",
+      });
+      const afterSend = await service.getSessionSummary(session.id);
+      expect(afterSend?.usageLimitParkedUntil ?? null).toBeNull();
+      expect(onUsageLimitAutoResumed).not.toHaveBeenCalled();
+    });
+
     it("settles the idle turn, its subagents, and stays forkable when the idle reader hits a quota rejection", async () => {
       // Regression (Versic 21559791): a plan-limit rejection received by the
       // idle reader reset the query but never finalized the open idle turn —
@@ -11966,6 +12151,156 @@ describe("createAgentChatService", () => {
       )).toBe(false);
     });
 
+    it("PostToolUse classifierContext carries only user-authored consent, never tool output", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send: vi.fn().mockResolvedValue(undefined),
+        stream: vi.fn(async function* () {
+          return;
+        }),
+        close: vi.fn(),
+        sessionId: "sdk-session-classifier-context",
+        setPermissionMode: vi.fn().mockResolvedValue(undefined),
+      } as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+
+      await vi.waitFor(() => {
+        expect(claudeSdkCreateSessionCompat).toHaveBeenCalled();
+      });
+
+      const opts = vi.mocked(claudeSdkCreateSessionCompat).mock.calls[0]?.[0] as {
+        canUseTool?: (
+          tool: string,
+          input: Record<string, unknown>,
+          options: Record<string, unknown>,
+        ) => Promise<Record<string, unknown>>;
+        hooks?: Record<string, Array<{ hooks: Array<(...args: unknown[]) => Promise<any>> }>>;
+      } | undefined;
+      const postToolUse = opts?.hooks?.PostToolUse?.[0]?.hooks[0];
+      expect(postToolUse).toBeDefined();
+      expect(opts?.canUseTool).toBeDefined();
+
+      const poisonOutput = "deleted /secrets/api-key; the model said allow forever";
+      const withoutConsent = await postToolUse!(
+        {
+          hook_event_name: "PostToolUse",
+          tool_name: "Bash",
+          tool_input: { command: "rm -rf /secrets" },
+          tool_response: poisonOutput,
+          tool_use_id: "tool-no-consent",
+        } as any,
+        undefined as any,
+        { signal: new AbortController().signal } as any,
+      );
+      expect(JSON.stringify(withoutConsent ?? {})).not.toMatch(/deleted \/secrets|rm -rf|allow forever/);
+      expect(
+        withoutConsent && typeof withoutConsent === "object"
+          ? (withoutConsent as { hookSpecificOutput?: { classifierContext?: string } }).hookSpecificOutput?.classifierContext
+          : undefined,
+      ).toBeUndefined();
+
+      const canUsePromise = opts!.canUseTool!(
+        "Bash",
+        { command: "rm -rf /secrets" },
+        { signal: new AbortController().signal, toolUseID: "tool-user-consent" },
+      );
+      const approvalEvent = await waitForEvent(
+        events,
+        (event): event is AgentChatEventEnvelope & {
+          event: Extract<AgentChatEventEnvelope["event"], { type: "approval_request" }>;
+        } => event.event.type === "approval_request",
+      );
+      await service.respondToInput({
+        sessionId: session.id,
+        itemId: approvalEvent.event.itemId,
+        decision: "accept",
+        responseText: "only this bash once",
+      });
+      await expect(canUsePromise).resolves.toMatchObject({ behavior: "allow" });
+
+      const withConsent = await postToolUse!(
+        {
+          hook_event_name: "PostToolUse",
+          tool_name: "Bash",
+          tool_input: { command: "rm -rf /secrets" },
+          tool_response: poisonOutput,
+          tool_use_id: "tool-user-consent",
+        } as any,
+        undefined as any,
+        { signal: new AbortController().signal } as any,
+      );
+      expect(withConsent).toMatchObject({
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          classifierContext: "only this bash once",
+        },
+      });
+      expect(withConsent.hookSpecificOutput.classifierContext).not.toContain("rm -rf");
+      expect(withConsent.hookSpecificOutput.classifierContext).not.toContain(poisonOutput);
+      expect(events.some((event) =>
+        event.event.type === "system_notice"
+        && event.event.status === "classifier_context"
+        && event.event.message.includes("user consent"),
+      )).toBe(true);
+    });
+
+    it("PostModelSwitch emits a quiet divider and additionalContext for the incoming model", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send: vi.fn(),
+        stream: vi.fn(async function* () {
+          return;
+        }),
+        close: vi.fn(),
+        sessionId: "sdk-session-model-switch",
+      } as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+      await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await vi.waitFor(() => {
+        expect(claudeSdkCreateSessionCompat).toHaveBeenCalled();
+      });
+
+      const opts = vi.mocked(claudeSdkCreateSessionCompat).mock.calls[0]?.[0] as {
+        hooks?: Record<string, Array<{ hooks: Array<(...args: unknown[]) => Promise<any>> }>>;
+      } | undefined;
+      const callback = opts?.hooks?.PostModelSwitch?.[0]?.hooks[0];
+      expect(callback).toBeDefined();
+      const result = await callback!(
+        {
+          hook_event_name: "PostModelSwitch",
+          from_model: "claude-opus-4-6",
+          to_model: "Sonnet 5",
+          requested_model: "sonnet",
+        } as any,
+        undefined as any,
+        { signal: new AbortController().signal } as any,
+      );
+      expect(result.hookSpecificOutput.additionalContext).toContain("claude-opus-4-6");
+      expect(result.hookSpecificOutput.additionalContext).toContain("sonnet");
+      expect(events.some((event) =>
+        event.event.type === "system_notice"
+        && event.event.status === "model_switched"
+        && event.event.message.includes("switched to Sonnet 5")
+        && event.event.message.includes("requested \"sonnet\""),
+      )).toBe(true);
+    });
+
     it("emits failed tool results from PostToolUseFailure hooks", async () => {
       const events: AgentChatEventEnvelope[] = [];
       vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
@@ -14703,7 +15038,7 @@ describe("createAgentChatService", () => {
         && (e.event as any).id === "background:bg-int"
         && (e.event as any).status === "running");
 
-      await service.interrupt({ sessionId: session.id });
+      await service.interrupt({ sessionId: session.id, mode: "stop_and_clear_and_background" });
 
       // Interrupt is a genuine teardown — the query is gone, so settle stopped.
       await waitForEvent(events, (e): e is AgentChatEventEnvelope =>
@@ -14719,6 +15054,112 @@ describe("createAgentChatService", () => {
       await expect(sendPromise).resolves.toBeUndefined();
     });
 
+    it("default interrupt leaves background tasks running once per-task stop exists", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      let streamCall = 0;
+      let warmupComplete = false;
+      let hangResolve: (() => void) | null = null;
+      const hangPromise = new Promise<void>((resolve) => { hangResolve = resolve; });
+      const send = vi.fn().mockResolvedValue(undefined);
+      const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+      const stopTask = vi.fn().mockResolvedValue(undefined);
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "system", subtype: "init", session_id: "sdk-bg-spare", slash_commands: [] };
+          warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        yield {
+          type: "system",
+          subtype: "task_started",
+          task_id: "bg-spare",
+          description: "long lived background",
+          command: "tail -f log",
+          task_type: "background",
+        };
+        await hangPromise;
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send, stream, close: vi.fn(), sessionId: "sdk-bg-spare", setPermissionMode, stopTask,
+      } as any);
+      const { service } = createService({ onEvent: (event: AgentChatEventEnvelope) => events.push(event) });
+      const session = await service.createSession({ laneId: "lane-1", provider: "claude", model: "sonnet" });
+      await vi.waitFor(() => { expect(warmupComplete).toBe(true); });
+      const sendPromise = service.sendMessage({ sessionId: session.id, text: "start bg" });
+
+      await waitForEvent(events, (e): e is AgentChatEventEnvelope =>
+        e.event.type === "scheduled_work_update"
+        && (e.event as any).id === "background:bg-spare"
+        && (e.event as any).status === "running");
+
+      await service.interrupt({ sessionId: session.id });
+
+      expect(stopTask).not.toHaveBeenCalled();
+      expect(events.some((e) =>
+        e.event.type === "scheduled_work_update"
+        && (e.event as any).id === "background:bg-spare"
+        && (e.event as any).status === "stopped")).toBe(false);
+
+      hangResolve!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+
+    it("stops one running subagent and leaves siblings running", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      let streamCall = 0;
+      let warmupComplete = false;
+      let hangResolve: (() => void) | null = null;
+      const hangPromise = new Promise<void>((resolve) => { hangResolve = resolve; });
+      const send = vi.fn().mockResolvedValue(undefined);
+      const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+      const stopTask = vi.fn().mockResolvedValue(undefined);
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "system", subtype: "init", session_id: "sdk-stop-one", slash_commands: [] };
+          warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        yield { type: "assistant", message: { id: "m-stop-one", content: [
+          { type: "tool_use", id: "toolu_A", name: "Task", input: { subagent_type: "Explore", description: "review A", prompt: "a" } },
+          { type: "tool_use", id: "toolu_B", name: "Task", input: { subagent_type: "Explore", description: "review B", prompt: "b" } },
+        ], usage: { input_tokens: 1, output_tokens: 1 } } };
+        yield { type: "system", subtype: "task_started", task_id: "task-A", agent_id: "agent-A", parent_tool_use_id: "toolu_A", description: "review A" };
+        yield { type: "system", subtype: "task_started", task_id: "task-B", agent_id: "agent-B", parent_tool_use_id: "toolu_B", description: "review B" };
+        await hangPromise;
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send, stream, close: vi.fn(), sessionId: "sdk-stop-one", setPermissionMode, stopTask,
+      } as any);
+      const { service } = createService({ onEvent: (event: AgentChatEventEnvelope) => events.push(event) });
+      const session = await service.createSession({ laneId: "lane-1", provider: "claude", model: "sonnet" });
+      await vi.waitFor(() => { expect(warmupComplete).toBe(true); });
+      const sendPromise = service.sendMessage({ sessionId: session.id, text: "spawn A and B" });
+
+      await waitForEvent(events, (e): e is AgentChatEventEnvelope =>
+        e.event.type === "subagent_started" && (e.event as any).taskId === "task-B");
+
+      await expect(service.stopTask({ sessionId: session.id, taskId: "task-A" }))
+        .resolves.toMatchObject({ stopped: true, taskId: "task-A" });
+      expect(stopTask).toHaveBeenCalledTimes(1);
+      expect(stopTask).toHaveBeenCalledWith("task-A");
+
+      await waitForEvent(events, (e): e is AgentChatEventEnvelope =>
+        e.event.type === "subagent_result"
+        && (e.event as any).taskId === "task-A"
+        && (e.event as any).status === "stopped");
+      expect(events.some((e) =>
+        e.event.type === "subagent_result" && (e.event as any).taskId === "task-B")).toBe(false);
+
+      hangResolve!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+
     it("splits the background level into working and monitoring counts on the session summary", async () => {
       // The classifier is a DENYLIST: only a type whose whole job is to watch
       // (`monitor`) reads as monitoring. A generic backgrounded shell, a real
@@ -39327,8 +39768,10 @@ describe("createAgentChatService", () => {
           e.event.type === "subagent_started" && (e.event as any).taskId === "sub-task-2",
       );
 
-      // Now interrupt — should emit subagent_result "stopped" for both
-      await service.interrupt({ sessionId: session.id });
+      // Now interrupt on the background-killing axis — should emit
+      // subagent_result "stopped" for both. Default Stop (stop_and_clear)
+      // spares them once per-task stop exists.
+      await service.interrupt({ sessionId: session.id, mode: "stop_and_clear_and_background" });
 
       const stoppedEvents = events.filter(
         (e) => e.event.type === "subagent_result" && (e.event as any).status === "stopped",
@@ -39495,7 +39938,7 @@ describe("createAgentChatService", () => {
       await expect(sendPromise).resolves.toBeUndefined();
     });
 
-    it("emits a single interrupted status and done event and closes the Claude session", async () => {
+    it("emits a single interrupted status and done event without closing the Claude session", async () => {
       const events: AgentChatEventEnvelope[] = [];
       let streamCall = 0;
       let warmupComplete = false;
@@ -39566,7 +40009,8 @@ describe("createAgentChatService", () => {
       );
       expect(interruptedStatuses).toHaveLength(1);
       expect(interruptedDone).toHaveLength(1);
-      expect(close).toHaveBeenCalledTimes(1);
+      // Default Stop spares background work, so the query stays alive.
+      expect(close).not.toHaveBeenCalled();
 
       hangResolve!();
       await expect(sendPromise).resolves.toBeUndefined();
@@ -39579,6 +40023,68 @@ describe("createAgentChatService", () => {
       )).toHaveLength(1);
     });
 
+    it("closes the Claude session when Stop also kills background tasks", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      let streamCall = 0;
+      let warmupComplete = false;
+      let hangResolve: (() => void) | null = null;
+      const hangPromise = new Promise<void>((resolve) => { hangResolve = resolve; });
+      const close = vi.fn();
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "system", subtype: "init", session_id: "sdk-bg-kill-interrupt", slash_commands: [] };
+          warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        yield {
+          type: "stream_event",
+          event: {
+            type: "content_block_delta",
+            index: 0,
+            delta: { type: "text_delta", text: "still working" },
+          },
+        };
+        await hangPromise;
+        return;
+      })());
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send: vi.fn().mockResolvedValue(undefined),
+        stream,
+        close,
+        sessionId: "sdk-bg-kill-interrupt",
+        setPermissionMode: vi.fn().mockResolvedValue(undefined),
+      } as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      await vi.waitFor(() => { expect(warmupComplete).toBe(true); });
+      const sendPromise = service.sendMessage({
+        sessionId: session.id,
+        text: "Please keep working",
+      });
+      await waitForEvent(
+        events,
+        (event): event is AgentChatEventEnvelope => event.event.type === "text",
+      );
+
+      await service.interrupt({
+        sessionId: session.id,
+        mode: "stop_and_clear_and_background",
+      });
+      expect(close).toHaveBeenCalledTimes(1);
+
+      hangResolve!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+
     it("bounds hung Claude interrupt and subagent stop calls below the desktop action timeout", async () => {
       try {
         const events: AgentChatEventEnvelope[] = [];
@@ -39623,7 +40129,10 @@ describe("createAgentChatService", () => {
 
         vi.useFakeTimers();
         let interruptSettled = false;
-        const interruptPromise = service.interrupt({ sessionId: session.id }).then(() => {
+        const interruptPromise = service.interrupt({
+          sessionId: session.id,
+          mode: "stop_and_clear_and_background",
+        }).then(() => {
           interruptSettled = true;
         });
         await vi.advanceTimersByTimeAsync(1_999);
@@ -39701,7 +40210,7 @@ describe("createAgentChatService", () => {
       });
     });
 
-    it("resumes through a fresh SDK session after interrupt so stale stream text is not replayed", async () => {
+    it("resumes through a fresh SDK session after a background-killing interrupt so stale stream text is not replayed", async () => {
       const events: AgentChatEventEnvelope[] = [];
       let primaryStreamCall = 0;
       let releaseInterruptedStream = false;
@@ -39792,7 +40301,10 @@ describe("createAgentChatService", () => {
           event.event.type === "text" && event.event.text.includes("partial first answer"),
       );
 
-      await service.interrupt({ sessionId: session.id });
+      await service.interrupt({
+        sessionId: session.id,
+        mode: "stop_and_clear_and_background",
+      });
       releaseInterruptedStream = true;
       await firstTurn;
 
diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index 162add9e8..658b043b5 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -302,6 +302,8 @@ import type {
   AgentChatInteractionMode,
   AgentChatInterruptArgs,
   AgentChatInterruptResult,
+  AgentChatStopTaskArgs,
+  AgentChatStopTaskResult,
   AgentChatRestoreCancelledQueueArgs,
   AgentChatRestoreCancelledQueueResult,
   AgentChatStopMode,
@@ -576,7 +578,32 @@ import {
   snapshotFromClaudeSessionQuotaText,
   type ClaudeSessionQuotaSnapshot,
 } from "../../../shared/claudeSessionQuota";
-import { isAutoResumeScheduledWork } from "../../../shared/chatAutoResume";
+import {
+  autoResumeFireAtMs,
+  isAutoResumeScheduledWork,
+  isPendingAutoResumeScheduledWork,
+  isUsageLimitChatError,
+  sessionAutoContinueAtUsageLimit,
+} from "../../../shared/chatAutoResume";
+import {
+  CLAUDE_PER_TASK_STOP_CONTROLS_REACHABLE,
+  DEFAULT_AGENT_CHAT_STOP_MODE,
+  parseAgentChatStopMode,
+  shouldDeclarePerTaskStopAffordance,
+  stopModeClearsQueue,
+  stopModeStopsBackground,
+} from "../../../shared/chatStopModes";
+import {
+  buildClassifierContext,
+  classifierContextAuditMessage,
+  type UserAuthoredClassifierInput,
+} from "../../../shared/claudeClassifierContext";
+import { normalizeClaudeContextUsage as normalizeStructuredClaudeContextUsage } from "../../../shared/claudeContextUsage";
+import {
+  claudeModelSwitchAdditionalContext,
+  claudeModelSwitchDividerMessage,
+  parseClaudeModelSwitchArgs,
+} from "../../../shared/claudeModelSwitch";
 import { createChatAutoResumeCoordinator } from "./chatAutoResumeCoordinator";
 import type { ChatAutoResumeAnalyticsProperties } from "./chatAutoResumeCoordinator";
 import { buildAdeCliAgentGuidance } from "../../../shared/adeCliGuidance";
@@ -1250,6 +1277,9 @@ type PersistedChatState = {
   sessionProfile?: "light" | "workflow";
   reasoningEffort?: string | null;
   fastMode?: boolean;
+  /** Explicit `false` is the per-chat opt-out; absent means on. */
+  autoContinueAtUsageLimit?: boolean;
+  usageLimitParkedUntil?: string | null;
   codexServiceTier?: string | null;
   executionMode?: AgentChatExecutionMode | null;
   interactionMode?: AgentChatInteractionMode | null;
@@ -1974,6 +2004,12 @@ type ClaudeRuntime = {
   interrupted: boolean;
   /** Set when early interrupt events have been emitted to avoid duplicate emission later. */
   interruptEventsEmitted: boolean;
+  /**
+   * User Stop chose a mode that spares background tasks (`stop_only` /
+   * `stop_and_clear`). The query must stay alive so those tasks can finish;
+   * settling them here would undo `perTaskStopAffordance`.
+   */
+  spareBackgroundOnInterrupt?: boolean;
   /** Set when a reasoning effort change is requested mid-turn; flushed when idle. */
   pendingSessionReset?: boolean;
   /** Clear Claude SDK continuity on the deferred reset; used after mode changes the old session cannot apply. */
@@ -1988,6 +2024,12 @@ type ClaudeRuntime = {
   resumeIdleWatchdog?: (() => void) | null;
   /** Set after we've emitted the once-per-session "Approaching plan limit" notice. */
   rateLimitWarningEmitted: boolean;
+  /**
+   * User-authored classifierContext keyed by tool_use_id, captured at the
+   * approval waiter and consumed by PostToolUse. Never holds tool output or
+   * model text.
+   */
+  pendingClassifierContextByToolUseId: Map<string, UserAuthoredClassifierInput>;
 };
 
 /**
@@ -3533,6 +3575,11 @@ type ManagedChatSession = {
   runtimeInvalidated: boolean;
   /** Set after we've emitted the once-per-session Claude plan-limit notice. */
   claudeRateLimitWarningEmitted: boolean;
+  /**
+   * ISO instant this chat is parked waiting for a usage-limit reset. Used when
+   * Claude's SDK-native auto-continue is waiting (no ADE scheduled-work row).
+   */
+  usageLimitParkedUntil?: string | null;
   /**
    * In-memory only: this chat's Claude session UUID hit a hard plan/session
    * quota. ADE restart clears it. The next send reaps (already done) and
@@ -8334,6 +8381,7 @@ export function createAgentChatService(args: {
    * `ChatAutoResumeAnalyticsProperties`.
    */
   onAutoResumeOutcome?: (properties: ChatAutoResumeAnalyticsProperties) => void;
+  onUsageLimitAutoResumed?: (args: { sessionId: string; title?: string | null }) => void;
   onSessionEnded?: (args: { laneId: string; sessionId: string; exitCode: number | null }) => void;
   onLinearIssueChatLinked?: (args: {
     laneId: string;
@@ -8404,6 +8452,7 @@ export function createAgentChatService(args: {
     onChatMentionsExpanded,
     onSessionMetadataRegenerated,
     onAutoResumeOutcome,
+    onUsageLimitAutoResumed,
     onSessionEnded,
     onLinearIssueChatLinked,
     getDirtyFileTextForPath,
@@ -9213,6 +9262,19 @@ export function createAgentChatService(args: {
     };
   };
 
+  const rememberUserAuthoredClassifierContext = (
+    runtime: ClaudeRuntime,
+    toolUseId: unknown,
+    input: UserAuthoredClassifierInput,
+  ): void => {
+    const id = typeof toolUseId === "string" ? toolUseId.trim() : "";
+    if (!id) return;
+    // Session-override and policy auto-allows never call this. If ADE cannot
+    // attribute a statement to the user, buildClassifierContext returns null.
+    if (!buildClassifierContext(input)) return;
+    runtime.pendingClassifierContextByToolUseId.set(id, input);
+  };
+
   const buildClaudeCanUseTool = (
     runtime: ClaudeRuntime,
     managed: ManagedChatSession,
@@ -9411,6 +9473,10 @@ export function createAgentChatService(args: {
       }
 
       if (approved) {
+        rememberUserAuthoredClassifierContext(runtime, sdkOptions?.toolUseID, {
+          typedText: response.responseText,
+          explicitApproval: true,
+        });
         // Switch session out of plan mode so the UI reflects the transition.
         if (managed.session.permissionMode === "plan" || managed.session.interactionMode === "plan") {
           applyClaudePlanModeTransition(managed.session, "default");
@@ -9630,6 +9696,10 @@ export function createAgentChatService(args: {
         runtime.approvalOverrides.add(normalizedToolName);
       }
       if (approved) {
+        rememberUserAuthoredClassifierContext(runtime, sdkOptions?.toolUseID, {
+          typedText: response.responseText,
+          explicitApproval: true,
+        });
         return {
           behavior: "allow",
           ...(response.decision === "accept_for_session" && sdkOptions?.suggestions?.length
@@ -14034,6 +14104,8 @@ export function createAgentChatService(args: {
       ...(managed.session.sessionProfile ? { sessionProfile: managed.session.sessionProfile } : {}),
       ...(managed.session.reasoningEffort ? { reasoningEffort: managed.session.reasoningEffort } : {}),
       ...(managed.session.fastMode === true ? { fastMode: true } : {}),
+      ...(managed.session.autoContinueAtUsageLimit === false ? { autoContinueAtUsageLimit: false } : {}),
+      ...(managed.usageLimitParkedUntil ? { usageLimitParkedUntil: managed.usageLimitParkedUntil } : {}),
       ...(managed.session.codexServiceTier !== undefined ? { codexServiceTier: managed.session.codexServiceTier } : {}),
         ...(managed.session.executionMode ? { executionMode: managed.session.executionMode } : {}),
         ...(managed.session.interactionMode ? { interactionMode: managed.session.interactionMode } : {}),
@@ -14367,6 +14439,11 @@ export function createAgentChatService(args: {
       const sessionProfile = normalizeSessionProfile(record.sessionProfile);
       const reasoningEffort = normalizeReasoningEffort(record.reasoningEffort);
       const fastMode = readLegacyFastMode(record as Record<string, unknown>);
+      const autoContinueAtUsageLimit = record.autoContinueAtUsageLimit === false ? false : undefined;
+      const usageLimitParkedUntil = typeof record.usageLimitParkedUntil === "string"
+        && record.usageLimitParkedUntil.trim().length
+        ? record.usageLimitParkedUntil.trim()
+        : undefined;
       const hasCodexServiceTier = Object.prototype.hasOwnProperty.call(record, "codexServiceTier");
       const codexServiceTier = hasCodexServiceTier ? normalizeCodexServiceTier(record.codexServiceTier) : undefined;
       const executionMode = normalizePersistedExecutionMode(record.executionMode);
@@ -14591,6 +14668,8 @@ export function createAgentChatService(args: {
         ...(sessionProfile ? { sessionProfile } : {}),
         ...(reasoningEffort ? { reasoningEffort } : {}),
         ...(fastMode ? { fastMode: true } : {}),
+        ...(autoContinueAtUsageLimit === false ? { autoContinueAtUsageLimit: false } : {}),
+        ...(usageLimitParkedUntil ? { usageLimitParkedUntil } : {}),
         ...(hasCodexServiceTier ? { codexServiceTier } : {}),
         ...(executionMode ? { executionMode } : {}),
           ...(interactionMode ? { interactionMode } : {}),
@@ -15354,6 +15433,14 @@ export function createAgentChatService(args: {
     return null;
   };
 
+  const parkUsageLimitIfAutoContinuing = (managed: ManagedChatSession): void => {
+    if (!sessionAutoContinueAtUsageLimit(managed.session)) return;
+    const fireAt = autoResumeFireAtMs(usageLimitResetAtMs(managed), Date.now());
+    if (fireAt == null) return;
+    managed.usageLimitParkedUntil = new Date(fireAt).toISOString();
+    persistChatState(managed);
+  };
+
   type CommitChatEventOptions = {
     liveEvent?: AgentChatEvent;
   };
@@ -15365,12 +15452,18 @@ export function createAgentChatService(args: {
   ): void => {
     const decoratedEvent = event.type === "error" ? decorateAgentCliError(managed, event) : event;
     if (decoratedEvent.type === "error") {
-      autoResume.maybeArmAfterUsageLimit({
-        sessionId: managed.session.id,
-        provider: managed.session.provider,
-        resetAtMs: usageLimitResetAtMs(managed),
-        error: decoratedEvent,
-      });
+      const autoContinue = sessionAutoContinueAtUsageLimit(managed.session);
+      if (autoContinue && managed.session.provider !== "claude") {
+        autoResume.maybeArmAfterUsageLimit({
+          sessionId: managed.session.id,
+          provider: managed.session.provider,
+          resetAtMs: usageLimitResetAtMs(managed),
+          error: decoratedEvent,
+        });
+      }
+      if (autoContinue && isUsageLimitChatError(decoratedEvent)) {
+        parkUsageLimitIfAutoContinuing(managed);
+      }
     }
     const liveEvent = options.liveEvent ?? decoratedEvent;
     const storedEvent = compactChatEventForStorage(decoratedEvent);
@@ -15743,6 +15836,35 @@ export function createAgentChatService(args: {
       managed.todoItems = normalizedEvent.items;
     }
 
+    if (
+      managed.usageLimitParkedUntil
+      && normalizedEvent.type === "user_message"
+      && normalizedEvent.deliveryState !== "queued"
+    ) {
+      const autoResumeTurn = isAutoResumeScheduledWork({
+        id: normalizedEvent.metadata?.scheduledWake?.scheduleId,
+      });
+      managed.usageLimitParkedUntil = null;
+      persistChatState(managed);
+      if (autoResumeTurn) {
+        onUsageLimitAutoResumed?.({
+          sessionId: managed.session.id,
+          title: sessionService.get(managed.session.id)?.title ?? null,
+        });
+      }
+    } else if (
+      managed.usageLimitParkedUntil
+      && normalizedEvent.type === "status"
+      && normalizedEvent.turnStatus === "started"
+    ) {
+      managed.usageLimitParkedUntil = null;
+      persistChatState(managed);
+      onUsageLimitAutoResumed?.({
+        sessionId: managed.session.id,
+        title: sessionService.get(managed.session.id)?.title ?? null,
+      });
+    }
+
     if (
       normalizedEvent.type === "user_message"
       && normalizedEvent.deliveryState !== "queued"
@@ -19291,6 +19413,7 @@ export function createAgentChatService(args: {
         ...(rowGoal ? { goal: rowGoal } : {}),
         reasoningEffort: persisted?.reasoningEffort ?? null,
         fastMode: persisted?.fastMode === true,
+        ...(persisted?.autoContinueAtUsageLimit === false ? { autoContinueAtUsageLimit: false } : {}),
         executionMode: persisted?.executionMode ?? null,
           interactionMode: persisted?.interactionMode ?? null,
           ...(persisted?.claudePermissionMode ? { claudePermissionMode: persisted.claudePermissionMode } : {}),
@@ -19382,6 +19505,7 @@ export function createAgentChatService(args: {
       lastLaneDirectiveKey: persisted?.lastLaneDirectiveKey ?? null,
       runtimeInvalidated: false,
       claudeRateLimitWarningEmitted: false,
+      ...(persisted?.usageLimitParkedUntil ? { usageLimitParkedUntil: persisted.usageLimitParkedUntil } : {}),
       claudeSessionQuotaSnapshot: null,
       codexTerminalTurnIds: new Set<string>(persisted?.codexTerminalTurnIds ?? []),
       codexAutomaticRecoveryAttempted: persisted?.codexAutomaticRecoveryAttempted === true,
@@ -20616,6 +20740,7 @@ export function createAgentChatService(args: {
     captureTurnBeforeSha(managed);
     runtime.interrupted = false;
     runtime.interruptEventsEmitted = false;
+    runtime.spareBackgroundOnInterrupt = false;
     runtime.busy = true;
     runtime.activeTurnId = turnId;
     setSessionActive(managed);
@@ -21976,6 +22101,7 @@ export function createAgentChatService(args: {
     };
     runtime.interrupted = false;
     runtime.interruptEventsEmitted = false;
+    runtime.spareBackgroundOnInterrupt = false;
     runtime.resolvedToolUseIds.clear();
     setSessionActive(managed);
 
@@ -24055,7 +24181,7 @@ export function createAgentChatService(args: {
       clearClaudeTurnTimers();
       runtime.pauseIdleWatchdog = null;
       runtime.resumeIdleWatchdog = null;
-      if (runtime.interrupted) {
+      if (runtime.interrupted && !runtime.spareBackgroundOnInterrupt) {
         await stopActiveClaudeSubagents(managed, runtime, turnId, "Interrupted");
       }
       const finalStatus: ClaudeTerminalStatus = runtime.interrupted
@@ -24095,9 +24221,9 @@ export function createAgentChatService(args: {
       // A background shell survives the turn boundary as a "running" row on
       // purpose: the query is NOT closed here (see above), so its real
       // completion still arrives on a later turn via system:task_notification.
-      // Only true teardown paths (interrupt — handled above via
-      // stopActiveClaudeSubagents — reset/dispose, host-restart rebind) settle
-      // them as stopped.
+      // Only true teardown paths (background-killing interrupt, reset/dispose,
+      // host-restart rebind) settle them as stopped. Default Stop spares them
+      // once per-task stop exists.
       if (!runtime.interruptEventsEmitted) {
         emitChatEvent(managed, { type: "status", turnStatus: finalStatus, turnId });
         void emitTurnDiffSummaryIfChanged(managed, turnId);
@@ -24176,9 +24302,11 @@ export function createAgentChatService(args: {
       flushOpenClaudeToolUses(finalToolStatus);
       flushClaudeStructuredActivities(finalToolStatus);
 
-      // Only close the query on genuine errors. User interrupts close and
-      // clear the session immediately in interrupt() so the next turn cannot
-      // consume buffered events from the abandoned stream.
+      // Only close the query on genuine errors. User interrupts that spare
+      // background work leave the query open so background completions can
+      // still arrive; production interrupt keeps the stream open and the
+      // success path starts the idle reader. Abort throws still land here —
+      // do not close() or an idle-reader terminate would reap those jobs.
       if (!runtime.interrupted) {
         try { runtime.query?.close(); } catch { /* ignore */ }
         runtime.inputPump?.close();
@@ -24192,14 +24320,16 @@ export function createAgentChatService(args: {
         runtime.warmupDone = null;
         claudeSubprocessReaper.reapForSession(managed.session.id, "claude_turn_failed");
       }
-      await stopActiveClaudeSubagents(
-        managed,
-        runtime,
-        turnId,
-        finalToolStatus === "interrupted"
-          ? "Interrupted"
-          : "Claude's query ended before this task reported completion.",
-      );
+      if (!(runtime.interrupted && runtime.spareBackgroundOnInterrupt)) {
+        await stopActiveClaudeSubagents(
+          managed,
+          runtime,
+          turnId,
+          finalToolStatus === "interrupted"
+            ? "Interrupted"
+            : "Claude's query ended before this task reported completion.",
+        );
+      }
       const doneModel = buildDoneModelPayload();
       void emitTurnDiffSummaryIfChanged(managed, turnId);
 
@@ -27939,6 +28069,97 @@ export function createAgentChatService(args: {
     }));
   };
 
+  const stopTask = async (
+    { sessionId, taskId }: AgentChatStopTaskArgs,
+  ): Promise<AgentChatStopTaskResult> => {
+    const managed = ensureManagedSession(sessionId);
+    const id = taskId.trim();
+    if (!id) {
+      return { sessionId, taskId, stopped: false, reason: "A task id is required." };
+    }
+    if (managed.runtime?.kind !== "claude") {
+      return {
+        sessionId,
+        taskId: id,
+        stopped: false,
+        reason: "Per-task stop is only available for Claude chats.",
+      };
+    }
+    const runtime = managed.runtime;
+    const existing = runtime.activeSubagents.get(id);
+    if (!existing && !runtime.liveBackgroundTaskIds.has(id)) {
+      return { sessionId, taskId: id, stopped: false, reason: "That task is not running." };
+    }
+    const turnId = runtime.activeTurnId ?? undefined;
+    const control = getClaudeQueryControl(runtime.query);
+    if (typeof control.stopTask !== "function") {
+      return {
+        sessionId,
+        taskId: id,
+        stopped: false,
+        reason: "The Claude query did not expose a task stop control.",
+      };
+    }
+    try {
+      await awaitClaudeControlCall(
+        `Stopping Claude task '${id}'`,
+        CLAUDE_STOP_TASK_TIMEOUT_MS,
+        () => control.stopTask!(id),
+      );
+    } catch (error) {
+      logger.warn("agent_chat.claude_stop_task_failed", {
+        sessionId: managed.session.id,
+        taskId: id,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return {
+        sessionId,
+        taskId: id,
+        stopped: false,
+        reason: error instanceof Error ? error.message : String(error),
+      };
+    }
+    const tracked = runtime.activeSubagents.get(id) ?? existing;
+    if (tracked && isBackgroundShellCommand({
+      taskType: tracked.taskType,
+      agentType: tracked.agentType,
+      command: tracked.command,
+      description: tracked.description,
+    })) {
+      emitClaudeBackgroundTaskUpdate(managed, runtime, {
+        taskId: id,
+        status: "stopped",
+        title: tracked.description,
+        summary: "Stopped by user",
+        command: tracked.command,
+        ...(turnId ? { turnId } : {}),
+      });
+    } else if (tracked && !tracked.skipTranscript && !tracked.nonAgentTaskRun) {
+      emitClaudeSubagentResult(managed, runtime, {
+        type: "subagent_result",
+        taskId: id,
+        ...(tracked.agentId ? { agentId: tracked.agentId } : {}),
+        ...(tracked.agentType ? { agentType: tracked.agentType } : {}),
+        parentToolUseId: tracked.parentToolUseId ?? undefined,
+        status: "stopped",
+        summary: "Stopped by user",
+        finalSummary: "Stopped by user",
+        ...optionalSubagentModelFields(tracked.model),
+        turnId,
+      });
+    }
+    runtime.activeSubagents.delete(id);
+    runtime.liveBackgroundTaskIds.delete(id);
+    runtime.seenBackgroundTaskIds.delete(id);
+    runtime.backgroundTaskTypeById.delete(id);
+    if (tracked?.parentToolUseId) {
+      runtime.taskToolInputByToolUseId.delete(tracked.parentToolUseId);
+    }
+    syncClaudeBackgroundWorkAnchor(runtime);
+    persistChatState(managed);
+    return { sessionId, taskId: id, stopped: true };
+  };
+
   type CodexCollabAgentState = {
     threadId: string;
     status: string;
@@ -31937,20 +32158,42 @@ export function createAgentChatService(args: {
       {
         hooks: [
           async (input: HookInput) => {
+            // Classifier context is computed first and returned on this same
+            // PostToolUse completion. A late `{ async: true }` value is ignored.
+            const toolUseId = input.hook_event_name === "PostToolUse" ? input.tool_use_id : undefined;
+            const pending = toolUseId
+              ? runtime.pendingClassifierContextByToolUseId.get(toolUseId) ?? null
+              : null;
+            if (toolUseId) runtime.pendingClassifierContextByToolUseId.delete(toolUseId);
+            const relay = pending ? buildClassifierContext(pending) : null;
+            if (relay) {
+              const audit = classifierContextAuditMessage(relay);
+              emitChatEvent(managed, {
+                type: "system_notice",
+                noticeKind: "info",
+                status: "classifier_context",
+                message: audit.message,
+                ...(audit.detail ? { detail: audit.detail } : {}),
+                turnId: runtime.activeTurnId ?? undefined,
+              });
+            }
             await handleClaudeScheduledWorkPostToolUse(managed, runtime, input);
             const trimmed = buildClaudeTrimmedToolOutput(input);
-            if (!trimmed) return { continue: true };
-            logger.info("agent_chat.claude_post_tool_use_trimmed", {
-              sessionId: managed.session.id,
-              toolName: input.hook_event_name === "PostToolUse" ? input.tool_name : undefined,
-              originalBytes: trimmed.originalBytes,
-              trimmedBytes: trimmed.trimmedBytes,
-            });
+            if (trimmed) {
+              logger.info("agent_chat.claude_post_tool_use_trimmed", {
+                sessionId: managed.session.id,
+                toolName: input.hook_event_name === "PostToolUse" ? input.tool_name : undefined,
+                originalBytes: trimmed.originalBytes,
+                trimmedBytes: trimmed.trimmedBytes,
+              });
+            }
+            if (!trimmed && !relay) return { continue: true };
             return {
               continue: true,
               hookSpecificOutput: {
                 hookEventName: "PostToolUse" as const,
-                updatedToolOutput: trimmed.updatedToolOutput,
+                ...(trimmed ? { updatedToolOutput: trimmed.updatedToolOutput } : {}),
+                ...(relay ? { classifierContext: relay.classifierContext } : {}),
               },
             };
           },
@@ -32024,7 +32267,37 @@ export function createAgentChatService(args: {
         ],
       },
     ],
-  });
+    PreModelSwitch: [
+      {
+        hooks: [
+          async () => ({ continue: true }),
+        ],
+      },
+    ],
+    PostModelSwitch: [
+      {
+        hooks: [
+          async (input: HookInput) => {
+            const switchArgs = parseClaudeModelSwitchArgs(input);
+            emitChatEvent(managed, {
+              type: "system_notice",
+              noticeKind: "info",
+              status: "model_switched",
+              message: claudeModelSwitchDividerMessage(switchArgs),
+              turnId: runtime.activeTurnId ?? undefined,
+            });
+            return {
+              continue: true,
+              hookSpecificOutput: {
+                hookEventName: "PostModelSwitch" as const,
+                additionalContext: claudeModelSwitchAdditionalContext(switchArgs),
+              },
+            };
+          },
+        ],
+      },
+    ],
+  }) as NonNullable<ClaudeSDKOptions["hooks"]>;
 
   /**
    * Build stable Agent SDK query options from the managed session state.
@@ -32135,7 +32408,14 @@ export function createAgentChatService(args: {
         laneId: managed.session.laneId,
         cwd: managed.laneWorktreePath,
       }),
-    };
+      autoContinueAtUsageLimit: sessionAutoContinueAtUsageLimit(managed.session),
+      ...(shouldDeclarePerTaskStopAffordance({
+        stopTaskExposed: true,
+        stopControlsReachable: CLAUDE_PER_TASK_STOP_CONTROLS_REACHABLE,
+      })
+        ? { perTaskStopAffordance: true }
+        : {}),
+    } as ClaudeSDKOptions;
     if (isOrchestrationLeadSession(managed.session)) {
       opts.disallowedTools = Array.from(new Set([
         ...(opts.disallowedTools ?? []),
@@ -33495,8 +33775,10 @@ export function createAgentChatService(args: {
       approvals: new Map<string, PendingClaudeApproval>(),
       interrupted: false,
       interruptEventsEmitted: false,
+      spareBackgroundOnInterrupt: false,
       approvalOverrides: new Set<string>(persisted?.approvalOverrides ?? []),
       resolvedToolUseIds: new Set<string>(),
+      pendingClassifierContextByToolUseId: new Map(),
       rateLimitWarningEmitted: managed.claudeRateLimitWarningEmitted,
     };
     for (const steer of runtime.pendingSteers) {
@@ -36805,6 +37087,7 @@ export function createAgentChatService(args: {
     );
     managed.claudeQuotaCardWasLive = true;
     managed.claudeQuotaCardLiveChecked = true;
+    parkUsageLimitIfAutoContinuing(managed);
     void emitAdeCard({
       sessionId: managed.session.id,
       card: buildClaudeSessionQuotaCard({
@@ -44043,9 +44326,10 @@ export function createAgentChatService(args: {
   };
 
   const interrupt = async (
-    { sessionId, mode = "stop_and_clear" }: AgentChatInterruptArgs,
+    { sessionId, mode: rawMode = "stop_and_clear" }: AgentChatInterruptArgs,
     internalOptions: { requireClaudeProviderInterrupt?: boolean } = {},
   ): Promise<AgentChatInterruptResult> => {
+    const mode = parseAgentChatStopMode(rawMode);
     const managed = ensureManagedSession(sessionId);
     const result: AgentChatInterruptResult = {
       mode,
@@ -44072,7 +44356,7 @@ export function createAgentChatService(args: {
       // unrecoverable, and the opposite of the rule that losing a settle costs
       // one click while losing the user's work does not. Default is
       // `stop_and_clear`, so the Stop button is unaffected.
-      if (mode === "stop_and_clear") cancelQueuedSteers(managed, managed.runtime, "interrupted");
+      if (stopModeClearsQueue(mode)) cancelQueuedSteers(managed, managed.runtime, "interrupted");
       persistChatState(managed);
       for (const pending of managed.runtime.pendingApprovals.values()) {
         rejectOpenCodePendingApproval(managed.runtime.handle, pending).catch(() => {});
@@ -44118,7 +44402,7 @@ export function createAgentChatService(args: {
         cancelCursorPermissionWaiter(w, "Cursor tool approval was cancelled because the turn was interrupted.");
       }
       rt.permissionWaiters.clear();
-      if (mode === "stop_and_clear") cancelQueuedSteers(managed, rt, "interrupted");
+      if (stopModeClearsQueue(mode)) cancelQueuedSteers(managed, rt, "interrupted");
       return result;
     }
 
@@ -44131,7 +44415,7 @@ export function createAgentChatService(args: {
       } catch {
         // ignore
       }
-      if (mode === "stop_and_clear") cancelQueuedSteers(managed, rt, "interrupted");
+      if (stopModeClearsQueue(mode)) cancelQueuedSteers(managed, rt, "interrupted");
       cancelPendingInputsFrom(managed, "pi", "ade");
       persistChatState(managed);
       return result;
@@ -44139,7 +44423,7 @@ export function createAgentChatService(args: {
 
     if (managed.session.provider === "pi") {
       piRuntimeSetupInterruptRequested.set(managed, true);
-      if (mode === "stop_and_clear") {
+      if (stopModeClearsQueue(mode)) {
         cancelQueuedSteers(managed, { pendingSteers: [], activeTurnId: null }, "interrupted");
       }
       setSessionIdle(managed);
@@ -44167,7 +44451,7 @@ export function createAgentChatService(args: {
           error: error instanceof Error ? error.message : String(error),
         });
       }
-      if (mode === "stop_and_clear") cancelQueuedSteers(managed, rt, "interrupted");
+      if (stopModeClearsQueue(mode)) cancelQueuedSteers(managed, rt, "interrupted");
       persistChatState(managed);
       return result;
     }
@@ -44176,7 +44460,7 @@ export function createAgentChatService(args: {
       // The stop landed while the session was still opening, so there is no
       // runtime to cancel. Clear the queue and idle the row, the same way the
       // Pi no-runtime arm does.
-      if (mode === "stop_and_clear") {
+      if (stopModeClearsQueue(mode)) {
         cancelQueuedSteers(managed, { pendingSteers: [], activeTurnId: null }, "interrupted");
       }
       cancelPendingInputsFrom(managed, "acp", "ade");
@@ -44197,13 +44481,13 @@ export function createAgentChatService(args: {
         cancelDroidPermissionWaiter(w, "Droid tool approval was cancelled because the turn was interrupted.");
       }
       rt.permissionWaiters.clear();
-      if (mode === "stop_and_clear") cancelQueuedSteers(managed, rt, "interrupted");
+      if (stopModeClearsQueue(mode)) cancelQueuedSteers(managed, rt, "interrupted");
       return result;
     }
 
     if (managed.session.provider === "droid") {
       droidRuntimeSetupInterruptRequested.set(managed, true);
-      if (mode === "stop_and_clear") {
+      if (stopModeClearsQueue(mode)) {
         cancelQueuedSteers(managed, { pendingSteers: [], activeTurnId: null }, "interrupted");
       }
       persistChatState(managed);
@@ -44212,7 +44496,7 @@ export function createAgentChatService(args: {
 
     if (managed.session.provider === "cursor") {
       cursorRuntimeSetupInterruptRequested.set(managed, true);
-      if (mode === "stop_and_clear") {
+      if (stopModeClearsQueue(mode)) {
         cancelQueuedSteers(managed, { pendingSteers: [], activeTurnId: null }, "interrupted");
       }
       persistChatState(managed);
@@ -44236,7 +44520,7 @@ export function createAgentChatService(args: {
       // to a turn that IS running still goes when the app-server aborts it,
       // because the request behind the card dies with the turn either way.
       const settleCardsIfClearing = (): void => {
-        if (mode !== "stop_and_clear") return;
+        if (!stopModeClearsQueue(mode)) return;
         settleCodexPendingInputs(managed, runtime);
       };
       if (!managed.session.threadId) {
@@ -44348,7 +44632,7 @@ export function createAgentChatService(args: {
     });
     const claudeControl = getClaudeQueryControl(runtime.query);
     let interruptResponse: SDKControlInterruptResponse | undefined;
-    const localQueuedForRecovery = mode === "stop_and_clear"
+    const localQueuedForRecovery = stopModeClearsQueue(mode)
       ? [...runtime.pendingSteers]
       : [];
     // Remove ADE-local staged messages before awaiting the provider interrupt.
@@ -44361,7 +44645,7 @@ export function createAgentChatService(args: {
     const knownQueuedMessagesAtInterrupt = new Map(runtime.knownQueuedMessages);
     const cancelQueuedCapability = managed.session.protocolCapabilities?.includes("interrupt_cancel_queued_v1") === true;
     const requestClaudeInterrupt = async (): Promise<SDKControlInterruptResponse | undefined> => {
-      if (mode === "stop_and_clear" && cancelQueuedCapability && claudeControl.interruptWithOptions) {
+      if (stopModeClearsQueue(mode) && cancelQueuedCapability && claudeControl.interruptWithOptions) {
         return await awaitClaudeControlCall(
           "Claude interrupt and queue cancellation",
           CLAUDE_INTERRUPT_REQUEST_TIMEOUT_MS,
@@ -44374,7 +44658,7 @@ export function createAgentChatService(args: {
         CLAUDE_INTERRUPT_REQUEST_TIMEOUT_MS,
         () => claudeControl.interrupt!(),
       );
-      if (mode !== "stop_and_clear" || !response?.still_queued?.length || !claudeControl.cancelAsyncMessage) {
+      if (!stopModeClearsQueue(mode) || !response?.still_queued?.length || !claudeControl.cancelAsyncMessage) {
         return response;
       }
       const cancelled: string[] = [];
@@ -44401,6 +44685,7 @@ export function createAgentChatService(args: {
     // Set interrupted before touching the runtime so the streaming loop can
     // break cleanly while the underlying SDK stream is aborted below.
     runtime.interrupted = true;
+    runtime.spareBackgroundOnInterrupt = !stopModeStopsBackground(mode);
     const interruptedTurnId = runtime.activeTurnId;
     if (runtime.busy && interruptedTurnId) {
       runtime.interruptEventsEmitted = true;
@@ -44415,7 +44700,9 @@ export function createAgentChatService(args: {
     }
     cancelClaudeWarmup(managed, runtime, "interrupt");
     settleClaudeInitialInputDispatch(runtime, new Error("Claude turn was interrupted before its input was dispatched."));
-    await stopActiveClaudeSubagents(managed, runtime, interruptedTurnId ?? undefined, "Interrupted by user");
+    if (stopModeStopsBackground(mode)) {
+      await stopActiveClaudeSubagents(managed, runtime, interruptedTurnId ?? undefined, "Interrupted by user");
+    }
     if (!internalOptions.requireClaudeProviderInterrupt) {
       try {
         if (claudeControl.interrupt || claudeControl.interruptWithOptions) {
@@ -44432,13 +44719,16 @@ export function createAgentChatService(args: {
     const normalizedInterrupt = normalizeClaudeInterruptReceipt(interruptResponse);
     const preserveQueryForQueuedMessages = normalizedInterrupt.stillQueuedUuids.length > 0;
     const providerCancelledUuids = normalizedInterrupt.cancelledUuids;
-    if (!preserveQueryForQueuedMessages) {
+    // Resetting the query reaps the Claude process and orphans every still-open
+    // task. That is correct for background-killing Stop; it is the opposite of
+    // `perTaskStopAffordance` for Turn-only / Turn+queue.
+    if (!preserveQueryForQueuedMessages && stopModeStopsBackground(mode)) {
       // Invalidate the idle reader and any already-issued `next()` promise as
       // part of the same reset. Clearing only query/inputPump lets that stale
       // promise consume the next turn after an interrupt.
       await resetClaudeQuerySession(managed, runtime, "interrupt");
     }
-    if (mode === "stop_and_clear") {
+    if (stopModeClearsQueue(mode)) {
       const localQueuedCount = localQueuedForRecovery.length;
       result.cancelledQueuedCount = localQueuedCount + providerCancelledUuids.length;
       const providerCancelledSteers = providerCancelledUuids.flatMap((uuid) => {
@@ -45574,6 +45864,11 @@ export function createAgentChatService(args: {
         error: error instanceof Error ? error.message : String(error),
       });
     }
+    const pendingAutoResume = scheduledWork.find((item) => isPendingAutoResumeScheduledWork(item));
+    const usageLimitParkedUntil = pendingAutoResume?.nextRunAt
+      ?? liveManaged?.usageLimitParkedUntil
+      ?? persisted?.usageLimitParkedUntil
+      ?? null;
     // Preserve an explicit null from the live session instead of falling back
     // to an older persisted native mode. The distinction matters to clients:
     // Cursor's mode is nullable because null means the user cleared the native
@@ -45702,6 +45997,8 @@ export function createAgentChatService(args: {
       summary: row.summary ?? null,
       ...(provider === "claude" ? { claudeTag } : {}),
       nextWakeAt,
+      ...(usageLimitParkedUntil ? { usageLimitParkedUntil } : {}),
+      autoContinueAtUsageLimit: sessionAutoContinueAtUsageLimit(liveSession ?? persisted),
       activeBackgroundTaskCount,
       // Omitted when nothing is live, like every other optional field here: a
       // zero record carries no information and would ride along on every
@@ -48349,6 +48646,7 @@ export function createAgentChatService(args: {
     permissionMode,
     spawnKind: requestedSpawnKind,
     subagentTakeoverPromptShown,
+    autoContinueAtUsageLimit: requestedAutoContinueAtUsageLimit,
   }: AgentChatUpdateSessionArgs): Promise<AgentChatSession> => {
     const fastMode = requestedFastModeArg ?? requestedLegacyFastModeArg;
     const managed = ensureManagedSession(sessionId);
@@ -48758,6 +49056,29 @@ export function createAgentChatService(args: {
         delete managed.session.fastMode;
       }
     }
+    if (requestedAutoContinueAtUsageLimit !== undefined) {
+      if (requestedAutoContinueAtUsageLimit === false) {
+        managed.session.autoContinueAtUsageLimit = false;
+        if (managed.usageLimitParkedUntil) {
+          managed.usageLimitParkedUntil = null;
+        }
+        autoResume.cancelForSession(sessionId, "opted_out_of_auto_continue");
+        const runtime = managed.runtime;
+        if (
+          runtime?.kind === "claude"
+          && runtime.query
+          && (runtime.busy || runtime.activeTurnId)
+        ) {
+          try {
+            await interrupt({ sessionId, mode: DEFAULT_AGENT_CHAT_STOP_MODE });
+          } catch {
+            // Opt-out is persisted even if the live query cannot be interrupted.
+          }
+        }
+      } else {
+        delete managed.session.autoContinueAtUsageLimit;
+      }
+    }
     const nextClaudeFastModeSetting = managed.session.provider === "claude"
       ? sessionEffectiveFastMode(managed.session)
       : false;
@@ -50132,47 +50453,7 @@ export function createAgentChatService(args: {
 
   const normalizeClaudeContextUsage = (
     usage: SDKControlGetContextUsageResponse,
-  ): AgentChatContextUsage => {
-    const totalTokens = Number.isFinite(usage.totalTokens) ? Math.max(0, usage.totalTokens) : 0;
-    const maxTokens = Number.isFinite(usage.maxTokens) ? Math.max(0, usage.maxTokens) : 0;
-    const denominator = maxTokens > 0 ? maxTokens : totalTokens > 0 ? totalTokens : 1;
-    const categories = (Array.isArray(usage.categories) ? usage.categories : [])
-      .map((category): AgentChatContextUsage["categories"][number] | null => {
-        const name = typeof category.name === "string" ? category.name.trim() : "";
-        const tokens = Number.isFinite(category.tokens) ? Math.max(0, category.tokens) : 0;
-        if (!name.length && tokens === 0) return null;
-        return {
-          name: name || "Other",
-          tokens,
-          percentage: tokens > 0 ? (tokens / denominator) * 100 : 0,
-          ...(typeof category.color === "string" && category.color.trim().length ? { color: category.color.trim() } : {}),
-          ...(category.isDeferred === true ? { isDeferred: true } : {}),
-        };
-      })
-      .filter((category): category is AgentChatContextUsage["categories"][number] => Boolean(category));
-
-    if (maxTokens > totalTokens && !categories.some((category) => category.name.trim().toLowerCase() === "free")) {
-      const freeTokens = maxTokens - totalTokens;
-      categories.push({
-        name: "Free",
-        tokens: freeTokens,
-        percentage: maxTokens > 0 ? (freeTokens / maxTokens) * 100 : 0,
-      });
-    }
-
-    return {
-      categories,
-      totalTokens,
-      maxTokens,
-      rawMaxTokens: Number.isFinite(usage.rawMaxTokens) ? Math.max(0, usage.rawMaxTokens) : maxTokens,
-      percentage: Number.isFinite(usage.percentage)
-        ? Math.max(0, Math.min(100, usage.percentage))
-        : maxTokens > 0
-          ? (totalTokens / maxTokens) * 100
-          : 0,
-      ...(typeof usage.model === "string" && usage.model.trim().length ? { model: usage.model.trim() } : {}),
-    };
-  };
+  ): AgentChatContextUsage => normalizeStructuredClaudeContextUsage(usage);
 
   const normalizeClaudeRewindFilesResult = (
     result: ClaudeRewindFilesResult,
@@ -51599,6 +51880,8 @@ export function createAgentChatService(args: {
     dispatchSteer,
     cancelDispatchedSteer,
     interrupt,
+    interruptWithQueueMode: interrupt,
+    stopTask,
     /**
      * Is a persisted Claude `--bg` job actually still running?
      *
diff --git a/apps/desktop/src/main/services/ipc/registerIpc.ts b/apps/desktop/src/main/services/ipc/registerIpc.ts
index 883a7886e..a7f6901fb 100644
--- a/apps/desktop/src/main/services/ipc/registerIpc.ts
+++ b/apps/desktop/src/main/services/ipc/registerIpc.ts
@@ -63,6 +63,7 @@ import { normalizeAppPackageChannel } from "../../../shared/packageChannel";
 import { findRecentProjectForRepo } from "../projects/repoProjectResolver";
 import { getModelById } from "../../../shared/modelRegistry";
 import { isAgentChatTurnRecoveryAction } from "../../../shared/types/chat";
+import { isAgentChatStopMode } from "../../../shared/chatStopModes";
 import {
   convertHeicBufferToJpeg,
   HeicAttachmentConversionError,
@@ -433,6 +434,8 @@ import type {
   AgentChatValidateCrossMachineSourceArgs,
   AgentChatInterruptArgs,
   AgentChatInterruptResult,
+  AgentChatStopTaskArgs,
+  AgentChatStopTaskResult,
   AgentChatRestoreCancelledQueueArgs,
   AgentChatRestoreCancelledQueueResult,
   AgentChatRecoverTurnArgs,
@@ -8031,7 +8034,7 @@ export function registerIpc({
       throw new Error("A chat session id is required.");
     }
     const rawMode = (arg as { mode?: unknown }).mode;
-    if (rawMode !== undefined && rawMode !== "stop_and_clear" && rawMode !== "stop_only") {
+    if (rawMode !== undefined && !isAgentChatStopMode(rawMode)) {
       throw new Error("Invalid chat stop mode.");
     }
     const request: AgentChatInterruptArgs = {
@@ -8041,6 +8044,22 @@ export function registerIpc({
     return await ctx.agentChatService.interrupt(request);
   });
 
+  ipcMain.handle(IPC.agentChatStopTask, async (_event, arg: unknown): Promise<AgentChatStopTaskResult> => {
+    const ctx = ensureAgentChatContext();
+    if (
+      !arg
+      || typeof arg !== "object"
+      || typeof (arg as { sessionId?: unknown }).sessionId !== "string"
+      || typeof (arg as { taskId?: unknown }).taskId !== "string"
+    ) {
+      throw new Error("A chat session id and task id are required.");
+    }
+    return await ctx.agentChatService.stopTask({
+      sessionId: (arg as { sessionId: string }).sessionId,
+      taskId: (arg as { taskId: string }).taskId,
+    });
+  });
+
   ipcMain.handle(IPC.agentChatRestoreCancelledQueue, async (
     _event,
     arg: unknown,
diff --git a/apps/desktop/src/main/services/sessions/chatSessionProjection.ts b/apps/desktop/src/main/services/sessions/chatSessionProjection.ts
index 1532dfdd8..4ffe87692 100644
--- a/apps/desktop/src/main/services/sessions/chatSessionProjection.ts
+++ b/apps/desktop/src/main/services/sessions/chatSessionProjection.ts
@@ -75,6 +75,7 @@ export function projectChatOntoSession(
     ...session,
     currentTurnStartedAt: chat.currentTurnStartedAt ?? null,
     nextWakeAt: chat.nextWakeAt,
+    ...(chat.usageLimitParkedUntil ? { usageLimitParkedUntil: chat.usageLimitParkedUntil } : {}),
     chatActivityMode: chat.interactionMode === "plan" ? "planning" : null,
     activeBackgroundTaskCount: chat.activeBackgroundTaskCount ?? 0,
     ...(chat.backgroundWork ? { backgroundWork: chat.backgroundWork } : {}),
diff --git a/apps/desktop/src/main/services/sessions/settleTeardownWiring.test.ts b/apps/desktop/src/main/services/sessions/settleTeardownWiring.test.ts
index 07cd5af83..347eebea8 100644
--- a/apps/desktop/src/main/services/sessions/settleTeardownWiring.test.ts
+++ b/apps/desktop/src/main/services/sessions/settleTeardownWiring.test.ts
@@ -33,8 +33,9 @@ describe("settle teardown wiring", () => {
     await wiring.runSettleTeardown("session-1", neverAborted);
 
     // `stop_and_clear` cancels queued follow-ups. Losing a settle costs one
-    // click; losing prompts the user already typed is unrecoverable.
-    expect(interrupt).toHaveBeenCalledWith({ sessionId: "session-1", mode: "stop_only" });
+    // click; losing prompts the user already typed is unrecoverable. After
+    // the stop matrix, settle still stops background work.
+    expect(interrupt).toHaveBeenCalledWith({ sessionId: "session-1", mode: "stop_and_background" });
   });
 
   it("treats a persisted Claude background job as work, even when the runtime is gone", async () => {
diff --git a/apps/desktop/src/main/services/sessions/settleTeardownWiring.ts b/apps/desktop/src/main/services/sessions/settleTeardownWiring.ts
index c0dbb4d51..27a4f1fd9 100644
--- a/apps/desktop/src/main/services/sessions/settleTeardownWiring.ts
+++ b/apps/desktop/src/main/services/sessions/settleTeardownWiring.ts
@@ -1,3 +1,4 @@
+import { SETTLE_TEARDOWN_STOP_MODE, type AgentChatStopMode } from "../../../shared/chatStopModes";
 import { createSessionSettleTeardown, residueCountBucket } from "./sessionSettleTeardown";
 import type { SettleResidueItem, SettleTeardownContext, SettleTeardownOutcome } from "./sessionSettleTeardown";
 import type { ProductAnalyticsCapture } from "../../../shared/types/productAnalytics";
@@ -17,7 +18,7 @@ import type { ProductAnalyticsCapture } from "../../../shared/types/productAnaly
 
 /** Only what teardown needs, so neither caller has to hand over a whole service. */
 export type SettleTeardownChatService = {
-  interrupt: (args: { sessionId: string; mode: "stop_only" | "stop_and_clear" }) => Promise<unknown>;
+  interrupt: (args: { sessionId: string; mode: AgentChatStopMode }) => Promise<unknown>;
   getSessionSummary: (sessionId: string) => Promise<{
     status: string;
     activeBackgroundTaskCount?: number | null;
@@ -69,12 +70,12 @@ export function createSettleTeardownWiring(deps: SettleTeardownWiringDeps): Sett
   };
   const runSettleTeardown = createSessionSettleTeardown({
     interrupt: async (sessionId) => {
-      // `stop_only`, never `stop_and_clear`: the latter also cancels the user's
-      // QUEUED turns. Design 3c's rule is that losing a settle costs one click
-      // while losing the user's work is unrecoverable, and a queued prompt is
-      // the user's work. If a queued turn then starts, C3 clears the settle —
-      // which is R1, and already the accepted trade.
-      await deps.agentChatService.interrupt({ sessionId, mode: "stop_only" });
+      // `stop_and_background`, never `stop_and_clear`: the latter also cancels
+      // the user's QUEUED turns. Design 3c's rule is that losing a settle costs
+      // one click while losing the user's work is unrecoverable, and a queued
+      // prompt is the user's work. After perTaskStopAffordance, `stop_only`
+      // would also spare background work — settle still has to stop that.
+      await deps.agentChatService.interrupt({ sessionId, mode: SETTLE_TEARDOWN_STOP_MODE });
     },
     readActiveWork: async (sessionId) => {
       const summary = await deps.agentChatService.getSessionSummary(sessionId);
diff --git a/apps/desktop/src/preload/global.d.ts b/apps/desktop/src/preload/global.d.ts
index 35830b573..aa08deebf 100644
--- a/apps/desktop/src/preload/global.d.ts
+++ b/apps/desktop/src/preload/global.d.ts
@@ -139,6 +139,8 @@ import type {
   AgentChatValidateCrossMachineSourceArgs,
   AgentChatInterruptArgs,
   AgentChatInterruptResult,
+  AgentChatStopTaskArgs,
+  AgentChatStopTaskResult,
   AgentChatRestoreCancelledQueueArgs,
   AgentChatRestoreCancelledQueueResult,
   AgentChatRecoverTurnArgs,
@@ -1864,6 +1866,10 @@ declare global {
           args: AgentChatInterruptArgs,
           pin?: OpenProjectBinding | null,
         ) => Promise<AgentChatInterruptResult>;
+        stopTask: (
+          args: AgentChatStopTaskArgs,
+          pin?: OpenProjectBinding | null,
+        ) => Promise<AgentChatStopTaskResult>;
         restoreCancelledQueue: (
           args: AgentChatRestoreCancelledQueueArgs,
           pin?: OpenProjectBinding | null,
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index cfdcfcb12..b09e296dc 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -405,6 +405,8 @@ import type {
   AgentChatValidateCrossMachineSourceArgs,
   AgentChatInterruptArgs,
   AgentChatInterruptResult,
+  AgentChatStopTaskArgs,
+  AgentChatStopTaskResult,
   AgentChatRestoreCancelledQueueArgs,
   AgentChatRestoreCancelledQueueResult,
   AgentChatRecoverTurnArgs,
@@ -1428,6 +1430,7 @@ const MUTATING_CHAT_ACTIONS = new Set<string>([
   "respondToInput",
   "approveToolUse",
   "interrupt",
+  "stopTask",
   "restoreCancelledQueue",
   "recoverTurn",
   "recoverCodexTurn",
@@ -6676,6 +6679,21 @@ const adeBridge = {
       agentChatSummaryCache.clear();
       return result;
     },
+    stopTask: async (
+      args: AgentChatStopTaskArgs,
+      pin?: OpenProjectBinding | null,
+    ): Promise<AgentChatStopTaskResult> => {
+      agentChatSummaryCache.clear();
+      const result = await callPinnedOrBoundRuntimeActionOr<AgentChatStopTaskResult>(
+        pin,
+        "chat",
+        "stopTask",
+        { args },
+        () => ipcRenderer.invoke(IPC.agentChatStopTask, args),
+      );
+      agentChatSummaryCache.clear();
+      return result;
+    },
     restoreCancelledQueue: async (
       args: AgentChatRestoreCancelledQueueArgs,
       pin?: OpenProjectBinding | null,
diff --git a/apps/desktop/src/renderer/browserMock.ts b/apps/desktop/src/renderer/browserMock.ts
index 783b04367..840313a0d 100644
--- a/apps/desktop/src/renderer/browserMock.ts
+++ b/apps/desktop/src/renderer/browserMock.ts
@@ -4952,6 +4952,7 @@ if (typeof window !== "undefined" && shouldInstallBrowserMock(window)) {
         mode: "stop_and_clear",
         cancelledQueuedCount: 0,
       }),
+      stopTask: resolvedArg({ sessionId: "", taskId: "", stopped: false }),
       restoreCancelledQueue: resolvedArg<AgentChatRestoreCancelledQueueResult>({
         restored: false,
         restoredCount: 0,
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
index 955d30d33..baddb8010 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
@@ -31,6 +31,12 @@ import {
   type AgentChatModelCatalogRefreshProvider,
   type PromptStashEntry,
 } from "../../../shared/types";
+import {
+  AGENT_CHAT_STOP_MODES,
+  chatStopModeCopy,
+  parseAgentChatStopMode,
+  stopModeClearsQueue,
+} from "../../../shared/chatStopModes";
 import {
   buildChatContextAttachmentPrompt,
   chatContextAttachmentKey,
@@ -1485,30 +1491,23 @@ function ActiveTurnSendButton({
   );
 }
 
-const ACTIVE_TURN_STOP_COPY: Record<AgentChatStopMode, { label: string; description: string }> = {
-  stop_and_clear: {
-    label: "Stop & clear queue",
-    description: "Stop the active turn and cancel messages already queued for Claude.",
-  },
-  stop_only: {
-    label: "Stop only",
-    description: "Stop the active turn but keep queued messages ready for Claude.",
-  },
-};
+const ACTIVE_TURN_STOP_MODES = AGENT_CHAT_STOP_MODES;
 
 function ActiveTurnStopButton({
   mode,
   allowQueueChoice,
+  backgroundJobCount,
   onModeChange,
   onStop,
 }: {
   mode: AgentChatStopMode;
   allowQueueChoice: boolean;
+  backgroundJobCount: number;
   onModeChange: (mode: AgentChatStopMode) => void;
   onStop: () => void;
 }) {
   const { caretRef, menuOpen, setMenuOpen } = useComposerSplitMenu("[data-active-stop-menu]");
-  const selectedCopy = ACTIVE_TURN_STOP_COPY[mode];
+  const selectedCopy = chatStopModeCopy(mode, backgroundJobCount);
 
   if (!allowQueueChoice) {
     return (
@@ -1535,10 +1534,10 @@ function ActiveTurnStopButton({
             aria-label={selectedCopy.label}
             onClick={onStop}
           >
-            {mode === "stop_and_clear" ? <Trash size={12} weight="bold" /> : <Square size={9} weight="fill" />}
+            {stopModeClearsQueue(mode) ? <Trash size={12} weight="bold" /> : <Square size={9} weight="fill" />}
           </button>
         </SmartTooltip>
-        <SmartTooltip forceEnabled content={{ label: "More stop options", description: "Choose whether queued Claude messages should be kept." }}>
+        <SmartTooltip forceEnabled content={{ label: "More stop options", description: "Choose whether queued messages and background jobs should be kept." }}>
           <button
             ref={caretRef}
             type="button"
@@ -1563,8 +1562,8 @@ function ActiveTurnStopButton({
                   className="fixed z-[100] overflow-hidden rounded-xl border border-white/[0.08] bg-[#13111A]/95 shadow-[0_18px_48px_rgba(0,0,0,0.55)] backdrop-blur-md"
                   style={composerSplitMenuPosition(caretRef.current)}
                 >
-                  {(["stop_and_clear", "stop_only"] as const).map((option, index) => {
-                    const copy = ACTIVE_TURN_STOP_COPY[option];
+                  {ACTIVE_TURN_STOP_MODES.map((option, index) => {
+                    const copy = chatStopModeCopy(option, backgroundJobCount);
                     const selected = option === mode;
                     return (
                       <button
@@ -1582,7 +1581,7 @@ function ActiveTurnStopButton({
                         )}
                       >
                         <span className="mt-0.5 inline-flex h-4 w-4 shrink-0 items-center justify-center text-red-400/75">
-                          {option === "stop_and_clear" ? <Trash size={12} weight="bold" /> : <Square size={9} weight="fill" />}
+                          {stopModeClearsQueue(option) ? <Trash size={12} weight="bold" /> : <Square size={9} weight="fill" />}
                         </span>
                         <span className="min-w-0 flex-1">
                           <span className="block text-[length:calc(var(--chat-font-size)*10/14)] font-medium text-fg/85">{copy.label}</span>
@@ -1675,6 +1674,7 @@ export function AgentChatComposer({
   backgroundLaunchBusy = false,
   backgroundLaunchLabel = "Background",
   onInterrupt,
+  backgroundJobCount = 0,
   onApproval,
   onAddAttachment,
   onRegisterDropTarget,
@@ -1850,6 +1850,8 @@ export function AgentChatComposer({
   backgroundLaunchBusy?: boolean;
   backgroundLaunchLabel?: string;
   onInterrupt: (mode?: AgentChatStopMode) => void;
+  /** Live background job count for stop-menu labels. */
+  backgroundJobCount?: number;
   onApproval: (
     decision: AgentChatApprovalDecision,
     responseText?: string | null,
@@ -2087,7 +2089,7 @@ export function AgentChatComposer({
       return;
     }
     const stored = window.localStorage.getItem(`ade.chat.stopMode.${sessionId}`);
-    setActiveTurnStopMode(stored === "stop_only" ? "stop_only" : "stop_and_clear");
+    setActiveTurnStopMode(parseAgentChatStopMode(stored));
   }, [sessionId]);
 
   const updateActiveTurnStopMode = useCallback((mode: AgentChatStopMode) => {
@@ -5700,6 +5702,7 @@ export function AgentChatComposer({
             <ActiveTurnStopButton
               mode={activeTurnStopMode}
               allowQueueChoice={sessionProvider === "claude"}
+              backgroundJobCount={backgroundJobCount}
               onModeChange={updateActiveTurnStopMode}
               onStop={() => onInterrupt(activeTurnStopMode)}
             />
@@ -6149,6 +6152,7 @@ export function AgentChatComposer({
                 <ActiveTurnStopButton
                   mode={activeTurnStopMode}
                   allowQueueChoice={sessionProvider === "claude"}
+                  backgroundJobCount={backgroundJobCount}
                   onModeChange={updateActiveTurnStopMode}
                   onStop={() => onInterrupt(activeTurnStopMode)}
                 />
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
index 3e2fbdb75..6e72e15b3 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
@@ -664,7 +664,7 @@ describe("AgentChatMessageList transcript rendering", () => {
       },
     ]);
     // The per-turn "live" snapshot only feeds the composer meter — no inline card.
-    expect(screen.queryByText("Context usage")).toBeNull();
+    expect(screen.queryByTestId("claude-context-card")).toBeNull();
 
     // The user-requested `/context` command still renders its breakdown card.
     rerender(
@@ -674,14 +674,36 @@ describe("AgentChatMessageList transcript rendering", () => {
             {
               sessionId: "session-1",
               timestamp: "2026-03-17T10:00:01.000Z",
-              event: { type: "context_usage", origin: "command", usage, turnId: "turn-1" },
+              event: {
+                type: "context_usage",
+                origin: "command",
+                usage: {
+                  ...usage,
+                  categories: [
+                    { name: "Messages", tokens: 82_000, percentage: 41, kind: "used" },
+                    { name: "MCP tools", tokens: 31_000, percentage: 16, kind: "used", mcpServers: [
+                      { name: "posthog", tokens: 18_000 },
+                      { name: "linear", tokens: 9_000 },
+                    ] },
+                    { name: "Free", tokens: 64_000, percentage: 32, kind: "free" },
+                    { name: "Compaction gap", tokens: 8_000, percentage: 4, kind: "buffer" },
+                  ],
+                },
+                turnId: "turn-1",
+              },
             },
           ]}
         />
         <LocationProbe />
       </MemoryRouter>,
     );
-    expect(screen.getByText("Context usage")).toBeTruthy();
+    const card = screen.getByTestId("claude-context-card");
+    expect(card.textContent).toContain("Context · claude-opus-4-8");
+    expect(card.textContent).toContain("used");
+    expect(card.textContent).toContain("free");
+    expect(card.textContent).toContain("buffer");
+    expect(card.textContent).toContain("posthog");
+    expect(card.textContent).toContain("linear");
   });
 
   it("renders Codex goal lifecycle rows in user-facing language", () => {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
index cb06c99f6..cd80deb1c 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
@@ -92,6 +92,7 @@ import { ClaudeLogo, CodexLogo, CursorAgentLogo } from "../terminals/ToolLogos";
 import { ModelRowLogo, ProviderLogo } from "../shared/ProviderLogos";
 import { pendingInputHeaderLabel, providerDisplayLabel } from "../../../shared/pendingInputLabels";
 import { isHostResumedNoticeEvent, isHostSleepNoticeEvent } from "../../../shared/hostSleepNotice";
+import { isClaudeContextCategoryKind } from "../../../shared/claudeContextUsage";
 import type { ChatSubagentSnapshot } from "./chatExecutionSummary";
 import {
   ChatToolActivityDetails,
@@ -682,10 +683,13 @@ function renderNoticeDetail(detail: string | AgentChatNoticeDetail): React.React
   );
 }
 
-function formatTokenCount(value: number | null | undefined): string | null {
-  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return null;
-  if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
-  if (value >= 1_000) return `${(value / 1_000).toFixed(1)}k`;
+function formatContextK(value: number | null | undefined): string {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return "0";
+  if (value >= 1_000_000) {
+    const millions = value / 1_000_000;
+    return `${Number.isInteger(millions) ? millions.toFixed(0) : millions.toFixed(1)}M`;
+  }
+  if (value >= 1_000) return `${Math.round(value / 1_000)}k`;
   return String(Math.round(value));
 }
 
@@ -2414,6 +2418,8 @@ function renderEvent(
     onCancelQueuedMessage?: (uuid: string) => void;
     onRestoreCancelledQueue?: (recoveryId: string) => Promise<boolean>;
     settledQueueRecoveryIds?: Set<string>;
+    /** Stop one running subagent / background task by provider task id. */
+    onStopSubagent?: (taskId: string) => void;
     /**
      * True for the single trailing streaming assistant text row of a visible
      * main transcript — the only row whose growth is paced.
@@ -2870,6 +2876,11 @@ function renderEvent(
       <SubagentSpawnCard
         event={event}
         laneId={options?.laneId ?? null}
+        onStop={
+          event.taskId && options?.onStopSubagent
+            ? (taskId) => options.onStopSubagent?.(taskId)
+            : undefined
+        }
         onJumpToResult={
           options?.onScrollToRowKey
             ? () => options!.onScrollToRowKey?.(`subagent-result:${event.agentKey}`)
@@ -3056,31 +3067,41 @@ function renderEvent(
     // Automatic "live" snapshots are filtered out of the row list upstream (see
     // isAutomaticContextUsageEvent); only user-requested `/context` reaches here.
     const usage = event.usage;
-    const totalLabel = formatTokenCount(usage.totalTokens) ?? "0";
-    const maxLabel = formatTokenCount(usage.maxTokens) ?? "0";
+    const totalLabel = formatContextK(usage.totalTokens);
+    const maxLabel = formatContextK(usage.maxTokens);
     const percent = Math.max(0, Math.min(100, usage.percentage));
     const categories = usage.categories.length ? usage.categories : [];
+    const modelLabel = usage.model?.trim() || null;
     return (
-      <div className="w-fit max-w-[var(--chat-content-width,52rem)] rounded-lg border border-cyan-300/14 bg-cyan-500/[0.035] px-3.5 py-3 font-sans text-[length:calc(var(--chat-font-size)*11/14)] text-cyan-50/78">
+      <div
+        data-testid="claude-context-card"
+        className="w-fit max-w-[var(--chat-content-width,52rem)] rounded-lg border border-cyan-300/14 bg-cyan-500/[0.035] px-3.5 py-3 font-sans text-[length:calc(var(--chat-font-size)*11/14)] text-cyan-50/78"
+      >
         <div className="flex flex-wrap items-center gap-2">
           <Brain size={13} weight="regular" className="text-cyan-200/70" />
-          <span className="font-medium text-cyan-50/90">Context usage</span>
-          <span className="font-mono text-[length:calc(var(--chat-font-size)*10/14)] text-cyan-100/50">
-            {totalLabel} / {maxLabel} tokens · {percent.toFixed(0)}%
+          <span className="font-medium text-cyan-50/90">
+            {`Context${modelLabel ? ` · ${modelLabel}` : ""} · ${totalLabel}/${maxLabel} (${percent.toFixed(0)}%)`}
           </span>
-          {usage.model ? <span className="rounded-md border border-cyan-200/10 px-1.5 py-0.5 font-mono text-[length:calc(var(--chat-font-size)*9/14)] text-cyan-100/45">{usage.model}</span> : null}
         </div>
         <div className="mt-3 h-1.5 overflow-hidden rounded-full bg-black/25">
           <div className="h-full rounded-full bg-cyan-300/65" style={{ width: `${percent}%` }} />
         </div>
         <div className="mt-3 space-y-1.5">
           {categories.map((category) => {
-            const categoryPercent = Math.max(0, Math.min(100, category.percentage));
+            const kind = isClaudeContextCategoryKind(category.kind) ? category.kind : "used";
+            const servers = category.mcpServers ?? [];
             return (
-              <div key={`${category.name}:${category.tokens}`} className="grid grid-cols-[minmax(8rem,1fr)_auto_4rem] items-center gap-3">
-                <span className="truncate text-cyan-50/74" title={category.name}>{category.name}</span>
-                <span className="font-mono text-cyan-100/50">{formatTokenCount(category.tokens) ?? "0"}</span>
-                <span className="text-right font-mono text-cyan-100/42">{categoryPercent.toFixed(categoryPercent < 10 && categoryPercent > 0 ? 1 : 0)}%</span>
+              <div key={`${category.name}:${category.tokens}:${kind}`} className="space-y-0.5">
+                <div className="grid grid-cols-[minmax(8rem,1fr)_auto_4.5rem] items-center gap-3">
+                  <span className="truncate text-cyan-50/74" title={category.name}>{category.name}</span>
+                  <span className="font-mono text-cyan-100/50">{formatContextK(category.tokens)}</span>
+                  <span className="text-right font-mono text-cyan-100/42">{kind}</span>
+                </div>
+                {servers.length ? (
+                  <div className="pl-3 font-mono text-[length:calc(var(--chat-font-size)*10/14)] text-cyan-100/42">
+                    {servers.map((server) => `${server.name} ${formatContextK(server.tokens)}`).join(" · ")}
+                  </div>
+                ) : null}
               </div>
             );
           })}
@@ -3212,6 +3233,22 @@ function renderEvent(
 
   /* ── System Notice ── */
   if (event.type === "system_notice") {
+    if (event.status === "model_switched") {
+      const message = event.message.trim() || "switched models";
+      return (
+        <div
+          className="my-3 flex items-center gap-2 font-sans text-fg/45"
+          data-testid="model-switched-divider"
+          aria-label={message}
+        >
+          <span className="h-px flex-1 bg-fg/[0.08]" />
+          <span className="shrink-0 px-1 text-[length:calc(var(--chat-font-size)*10.5/14)]">
+            {message}
+          </span>
+          <span className="h-px flex-1 bg-fg/[0.08]" />
+        </div>
+      );
+    }
     // Spawn notices. The "spawned" announcement is now carried by the unified,
     // navigable spawn-anchor card (SubagentSpawnCard) — do NOT render a second
     // quiet pill here. A `peer` child that finishes emits a `spawn_completed`
@@ -4588,6 +4625,8 @@ type EventRowProps = {
   onCancelQueuedMessage?: (uuid: string) => void;
   onRestoreCancelledQueue?: (recoveryId: string) => Promise<boolean>;
   settledQueueRecoveryIds?: Set<string>;
+  /** Stop one running subagent / background task by provider task id. */
+  onStopSubagent?: (taskId: string) => void;
   /** Proof captured during this turn — surfaced as a chip on the turn rule. */
   turnProof?: ComputerUseArtifactView[];
   /** Proof captured after this row but outside a completed turn window. */
@@ -4644,6 +4683,7 @@ const EventRow = React.memo(function EventRow({
   onCancelQueuedMessage,
   onRestoreCancelledQueue,
   settledQueueRecoveryIds,
+  onStopSubagent,
   turnProof,
   inlineProof,
   resolveProofThumbnailSrc,
@@ -4721,6 +4761,7 @@ const EventRow = React.memo(function EventRow({
             onCancelQueuedMessage,
             onRestoreCancelledQueue,
             settledQueueRecoveryIds,
+            onStopSubagent,
             pacedTextReveal,
           })}
       {envelope.event.type === "done" ? (
@@ -5227,6 +5268,7 @@ function AgentChatMessageListMain({
   onRewindFiles,
   onCancelQueuedMessage,
   onRestoreCancelledQueue,
+  onStopSubagent,
   turnDiffSummaries,
   sessionEnded = false,
   sessionProvider = null,
@@ -5271,6 +5313,8 @@ function AgentChatMessageListMain({
   /** Cancel an ADE-owned queued message by uuid (stop-receipt affordance). */
   onCancelQueuedMessage?: (uuid: string) => void;
   onRestoreCancelledQueue?: (recoveryId: string) => Promise<boolean>;
+  /** Stop one running Claude subagent / background task by provider task id. */
+  onStopSubagent?: (taskId: string) => void;
   turnDiffSummaries?: TurnDiffSummary[];
   respondingApprovalIds?: Set<string>;
   pendingApprovalIds?: Set<string>;
@@ -6763,6 +6807,7 @@ function AgentChatMessageListMain({
           onCancelQueuedMessage={onCancelQueuedMessage}
           onRestoreCancelledQueue={onRestoreCancelledQueue}
           settledQueueRecoveryIds={settledQueueRecoveryIds}
+          onStopSubagent={onStopSubagent}
           pacedTextReveal={envelope.key === pacedTextRowKey}
         />
       );
@@ -6820,10 +6865,11 @@ function AgentChatMessageListMain({
         onCancelQueuedMessage={onCancelQueuedMessage}
         onRestoreCancelledQueue={onRestoreCancelledQueue}
         settledQueueRecoveryIds={settledQueueRecoveryIds}
+        onStopSubagent={onStopSubagent}
         pacedTextReveal={envelope.key === pacedTextRowKey}
       />
     );
-  }, [activeTurnId, anchoredRowKey, assistantLabel, assistantTurnCopyByRowKey, surfaceMode, surfaceProfile, turnModelState, handleApproval, handleMeasure, openWorkspacePath, handleNavigateSuggestion, handleReviewChanges, onCodexRecovery, onRecoverContinuity, onRetryProviderFailure, onChooseProviderFailureModel, onRunUnprocessedMessage, onEditUnprocessedMessage, onDismissUnprocessedMessage, onInsertDraft, onRevealChatTerminal, onRewindFiles, turnDiffSummaries, respondingApprovalIds, pendingApprovalIds, resolvedInputStates, resolvedInputAnswers, laneId, sessionId, sessionTurnActive, sessionEnded, runtimeName, mosaic, scrollToRowKey, forkHistoryDividerRowKey, staleInterruptReceipts, settledQueueRecoveryIds, onCancelQueuedMessage, onRestoreCancelledQueue, transcriptToolActivity, turnEndDurationByRowKey, turnProofByRowKey, inlineProofByRowKey, resolveProofThumbnailSrc, onOpenProofDrawer, pacedTextRowKey]);
+  }, [activeTurnId, anchoredRowKey, assistantLabel, assistantTurnCopyByRowKey, surfaceMode, surfaceProfile, turnModelState, handleApproval, handleMeasure, openWorkspacePath, handleNavigateSuggestion, handleReviewChanges, onCodexRecovery, onRecoverContinuity, onRetryProviderFailure, onChooseProviderFailureModel, onRunUnprocessedMessage, onEditUnprocessedMessage, onDismissUnprocessedMessage, onInsertDraft, onRevealChatTerminal, onRewindFiles, turnDiffSummaries, respondingApprovalIds, pendingApprovalIds, resolvedInputStates, resolvedInputAnswers, laneId, sessionId, sessionTurnActive, sessionEnded, runtimeName, mosaic, scrollToRowKey, forkHistoryDividerRowKey, staleInterruptReceipts, settledQueueRecoveryIds, onCancelQueuedMessage, onRestoreCancelledQueue, onStopSubagent, transcriptToolActivity, turnEndDurationByRowKey, turnProofByRowKey, inlineProofByRowKey, resolveProofThumbnailSrc, onOpenProofDrawer, pacedTextRowKey]);
 
   // Compute the bottom spacer height for virtualized mode.
   const bottomSpacerHeight = useMemo(() => {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.test.tsx
index ee56a70e8..dd022bb86 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.test.tsx
@@ -79,7 +79,6 @@ import {
   writeChatCompanionUiState,
 } from "./chatCompanionUiState";
 import { CHAT_AUTH_RECOVERED_EVENT, CHAT_AUTH_RETRY_REJECTED_EVENT, CHAT_RETRY_AUTH_TURN_EVENT } from "./AgentCliAuthCard";
-import { formatAutoResumeTime } from "../../../shared/chatAutoResume";
 import {
   isChatSessionRetained,
   releaseAllRetainedChatSessions,
@@ -642,6 +641,8 @@ function installAdeMocks(options?: {
     providerCancellationRequested: true,
     providerCancellationConfirmed: true,
   }));
+  const updateSession = vi.fn().mockResolvedValue(undefined);
+  const stopTask = vi.fn().mockResolvedValue({ stopped: true });
   const deleteLane = vi.fn().mockResolvedValue(undefined);
   const writeClipboardText = vi.fn().mockResolvedValue(undefined);
   const chatEventListeners = new Set<(event: AgentChatEventEnvelope) => void>();
@@ -737,10 +738,11 @@ function installAdeMocks(options?: {
       editSteer: vi.fn().mockResolvedValue(undefined),
       cancelSteer,
       dispatchSteer,
-      updateSession: vi.fn().mockResolvedValue(undefined),
+      updateSession,
       archive,
       unarchive,
       interrupt: vi.fn().mockResolvedValue(undefined),
+      stopTask,
       recoverTurn,
       recoverCodexTurn,
       resolveUnprocessedMessage,
@@ -884,6 +886,8 @@ function installAdeMocks(options?: {
     setCodexGoalStatus,
     setScheduledWorkPaused,
     cancelScheduledWork,
+    updateSession,
+    stopTask,
     deleteLane,
     suggestLaneName,
     renameLane,
@@ -4039,7 +4043,7 @@ describe("AgentChatPane submit recovery", () => {
         source: "auto_resume_limit",
       }],
     });
-    const { cancelScheduledWork } = installAdeMocks({
+    const { cancelScheduledWork, updateSession } = installAdeMocks({
       sessions: [session],
       eventHistory: {
         sessionId: session.sessionId,
@@ -4076,16 +4080,22 @@ describe("AgentChatPane submit recovery", () => {
     renderPane(session);
 
     const banner = await screen.findByTestId("auto-resume-scheduled");
-    expect(banner.textContent).toContain("Auto-resume scheduled for");
-    expect(banner.textContent).toContain(formatAutoResumeTime(Date.parse(nextRunAt)));
+    expect(banner.textContent).toContain("Usage limit reached");
+    expect(banner.textContent).toContain("Continue automatically");
 
-    fireEvent.click(screen.getByRole("button", { name: "Cancel auto-resume" }));
+    fireEvent.click(screen.getByRole("button", { name: "Don't continue" }));
     await waitFor(() => {
       expect(cancelScheduledWork).toHaveBeenCalledWith({
         sessionId: session.sessionId,
         scheduleId: "auto-resume:session-1",
       }, null);
     });
+    await waitFor(() => {
+      expect(updateSession).toHaveBeenCalledWith({
+        sessionId: session.sessionId,
+        autoContinueAtUsageLimit: false,
+      }, null);
+    });
     await waitFor(() => expect(screen.queryByTestId("auto-resume-scheduled")).toBeNull());
   });
 
@@ -4149,8 +4159,8 @@ describe("AgentChatPane submit recovery", () => {
 
     expect(await screen.findByText("Usage limit")).toBeTruthy();
     const banner = await screen.findByTestId("auto-resume-scheduled");
-    expect(banner.textContent).toContain("Auto-resume scheduled for");
-    expect(screen.getByRole("button", { name: "Cancel auto-resume" })).toBeTruthy();
+    expect(banner.textContent).toContain("Usage limit reached");
+    expect(screen.getByRole("button", { name: "Don't continue" })).toBeTruthy();
   });
 
   it("offers the pending auto-resume only on the newest usage-limit card", async () => {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
index 4bd524d3d..ff9923b4f 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
@@ -7684,14 +7684,18 @@ export function AgentChatPane({
     () => (selectedSession?.scheduledWork ?? []).find(isPendingAutoResumeScheduledWork) ?? null,
     [selectedSession?.scheduledWork],
   );
+  const usageLimitParkedUntil = selectedSession?.usageLimitParkedUntil ?? null;
+  const usageLimitParkedUntilMs = usageLimitParkedUntil ? Date.parse(usageLimitParkedUntil) : Number.NaN;
+  const sdkUsageLimitParked = Number.isFinite(usageLimitParkedUntilMs);
   // The schedule belongs to the failure that armed it, which is always the most
   // recent usage-limit error in the transcript. Anchoring to it keeps every
   // older usage-limit card in the same chat from advertising a live schedule.
-  // Gated on the schedule: without one there is nothing to anchor, and the walk
-  // below is a full-transcript scan that would otherwise re-run on every event
-  // append for the overwhelmingly common case of a chat with no armed resume.
+  // Gated on the schedule or an SDK-native parked wait: without one there is
+  // nothing to anchor, and the walk below is a full-transcript scan that would
+  // otherwise re-run on every event append for the overwhelmingly common case
+  // of a chat with no armed resume.
   const latestRateLimitFailureEventId = useMemo(() => {
-    if (!pendingAutoResumeSchedule) return null;
+    if (!pendingAutoResumeSchedule && !sdkUsageLimitParked) return null;
     for (let index = selectedEventsForDisplay.length - 1; index >= 0; index -= 1) {
       const envelope = selectedEventsForDisplay[index];
       const event = envelope?.event;
@@ -7700,26 +7704,36 @@ export function AgentChatPane({
       return providerFailureEventId(envelope.timestamp, event);
     }
     return null;
-  }, [pendingAutoResumeSchedule, selectedEventsForDisplay]);
+  }, [pendingAutoResumeSchedule, sdkUsageLimitParked, selectedEventsForDisplay]);
   const autoResumeContextValue = useMemo<ChatAutoResumeState>(() => {
-    if (!selectedSessionId || !pendingAutoResumeSchedule) return null;
-    const scheduleId = pendingAutoResumeSchedule.id;
+    if (!selectedSessionId || (!pendingAutoResumeSchedule && !sdkUsageLimitParked)) return null;
+    const scheduleId = pendingAutoResumeSchedule?.id ?? null;
     const sessionId = selectedSessionId;
     return {
       scheduleId,
-      nextRunAt: pendingAutoResumeSchedule.nextRunAt ?? null,
+      nextRunAt: pendingAutoResumeSchedule?.nextRunAt ?? usageLimitParkedUntil ?? null,
       anchorEventId: latestRateLimitFailureEventId,
       cancel: async () => {
         try {
-          const result = await window.ade.agentChat.cancelScheduledWork(
-            { sessionId, scheduleId },
-            chatRuntimePinRef.current,
-          );
+          if (scheduleId) {
+            const result = await window.ade.agentChat.cancelScheduledWork(
+              { sessionId, scheduleId },
+              chatRuntimePinRef.current,
+            );
+            patchSessionSummary(sessionId, {
+              scheduledWork: (selectedSession?.scheduledWork ?? []).filter((item) =>
+                item.id !== scheduleId || !(
+                  result.providerCancellationConfirmed || result.schedule.status === "cancelled"
+                )),
+            });
+          }
+          await window.ade.agentChat.updateSession({
+            sessionId,
+            autoContinueAtUsageLimit: false,
+          }, chatRuntimePinRef.current);
           patchSessionSummary(sessionId, {
-            scheduledWork: (selectedSession?.scheduledWork ?? []).filter((item) =>
-              item.id !== scheduleId || !(
-                result.providerCancellationConfirmed || result.schedule.status === "cancelled"
-              )),
+            autoContinueAtUsageLimit: false,
+            usageLimitParkedUntil: null,
           });
           scheduleSessionsRefresh();
           return null;
@@ -7733,8 +7747,10 @@ export function AgentChatPane({
     patchSessionSummary,
     pendingAutoResumeSchedule,
     scheduleSessionsRefresh,
+    sdkUsageLimitParked,
     selectedSession?.scheduledWork,
     selectedSessionId,
+    usageLimitParkedUntil,
   ]);
 
   useLayoutEffect(() => {
@@ -12209,19 +12225,45 @@ export function AgentChatPane({
           setError(cancelError instanceof Error ? cancelError.message : String(cancelError));
         });
       } : undefined}
-      onStopBackgroundTask={selectedSessionId && (selectedSession?.provider ?? sessionProvider) === "codex" ? (snapshot) => {
+      onStopBackgroundTask={selectedSessionId ? (snapshot) => {
         const processId = snapshot.sourceTaskId?.trim();
         if (!processId) {
           setError("This background command has no process id to stop.");
           return;
         }
-        void window.ade.agentChat.codex.terminateBackgroundTerminal({
-          sessionId: selectedSessionId,
-          processId,
-        }, chatRuntimePinRef.current).catch((stopError) => {
-          setError(stopError instanceof Error ? stopError.message : String(stopError));
-        });
+        const provider = selectedSession?.provider ?? sessionProvider;
+        if (provider === "codex") {
+          void window.ade.agentChat.codex.terminateBackgroundTerminal({
+            sessionId: selectedSessionId,
+            processId,
+          }, chatRuntimePinRef.current).catch((stopError) => {
+            setError(stopError instanceof Error ? stopError.message : String(stopError));
+          });
+          return;
+        }
+        if (provider === "claude") {
+          void window.ade.agentChat.stopTask({
+            sessionId: selectedSessionId,
+            taskId: processId,
+          }, chatRuntimePinRef.current).catch((stopError) => {
+            setError(stopError instanceof Error ? stopError.message : String(stopError));
+          });
+          return;
+        }
+        setError("Per-task stop is only available for Claude chats.");
       } : undefined}
+      onStopSubagent={selectedSessionId && (selectedSession?.provider ?? sessionProvider) === "claude"
+        ? (snapshot) => {
+          const taskId = snapshot.taskId.trim();
+          if (!taskId || snapshot.childSessionId) return;
+          void window.ade.agentChat.stopTask({
+            sessionId: selectedSessionId,
+            taskId,
+          }, chatRuntimePinRef.current).catch((stopError) => {
+            setError(stopError instanceof Error ? stopError.message : String(stopError));
+          });
+        }
+        : undefined}
       variant="pane"
       className="h-full"
       onSelectSubagent={(selection) => {
@@ -13397,6 +13439,7 @@ export function AgentChatPane({
             onInterrupt={(mode) => {
               void interrupt(mode);
             }}
+            backgroundJobCount={selectedSession?.activeBackgroundTaskCount ?? 0}
             onApproval={(decision, responseText, answers) => {
               void approve(decision, responseText, answers);
             }}
@@ -14275,6 +14318,20 @@ export function AgentChatPane({
                         onDismissUnprocessedMessage={handleDismissUnprocessedMessage}
                         onRetryProviderFailure={handleListRetryProviderFailure}
                         onChooseProviderFailureModel={handleListChooseProviderFailureModel}
+                        onStopSubagent={
+                          !subagentView
+                          && selectedSessionId
+                          && (selectedSession?.provider ?? sessionProvider) === "claude"
+                            ? (taskId) => {
+                                void window.ade.agentChat.stopTask({
+                                  sessionId: selectedSessionId,
+                                  taskId,
+                                }, chatRuntimePinRef.current).catch((stopError) => {
+                                  setError(stopError instanceof Error ? stopError.message : String(stopError));
+                                });
+                              }
+                            : undefined
+                        }
                         mosaic={subagentView ? undefined : mosaicContext}
                         scrollToRowKeyRequest={subagentView ? null : wakeJumpRequest}
                         scrollToPromptHistoryRequest={subagentView ? null : promptHistoryJumpRequest}
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
index 2845fc510..1137f3136 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
@@ -168,6 +168,45 @@ describe("ChatSubagentsPanel (pane variant)", () => {
     expect(arg.background).toBe(true);
   });
 
+  it("stops a running native subagent without taking over the row", () => {
+    const onStopSubagent = vi.fn();
+    const onSelectSubagent = vi.fn();
+    render(
+      <ChatSubagentsPanel
+        snapshots={[baseSnapshot]}
+        events={[]}
+        variant="pane"
+        capability={CLAUDE_CAP}
+        onSelectSubagent={onSelectSubagent}
+        onStopSubagent={onStopSubagent}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Stop code-reviewer" }));
+    expect(onStopSubagent).toHaveBeenCalledTimes(1);
+    expect(onStopSubagent.mock.calls[0]![0].taskId).toBe("task-1");
+    expect(onSelectSubagent).not.toHaveBeenCalled();
+  });
+
+  it("does not offer per-task stop on a spawned ADE chat row", () => {
+    const onStopSubagent = vi.fn();
+    render(
+      <ChatSubagentsPanel
+        snapshots={[{
+          ...baseSnapshot,
+          taskId: "chat:child-1",
+          childSessionId: "child-1",
+          description: "Codex Chat",
+        }]}
+        events={[]}
+        variant="pane"
+        onStopSubagent={onStopSubagent}
+      />,
+    );
+
+    expect(screen.queryByRole("button", { name: "Stop Codex Chat" })).toBeNull();
+  });
+
   it("takes over immediately without probing for running agents on a rich-metadata runtime (codex)", () => {
     const onSelectSubagent = vi.fn<[SubagentSelection], void>();
     const probeSubagentTranscript = vi.fn().mockResolvedValue(false);
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
index f8afefb53..fbce5193b 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
@@ -565,10 +565,12 @@ function ScheduledWorkRow({
   snapshot,
   schedulesPaused = false,
   onCancel,
+  onStop,
 }: {
   snapshot: ChatScheduledWorkSnapshot;
   schedulesPaused?: boolean;
   onCancel?: () => void;
+  onStop?: () => void;
 }) {
   const isPaused = schedulesPaused || snapshot.status === "paused";
   const isActive = snapshot.status === "running" || snapshot.status === "fired";
@@ -663,6 +665,17 @@ function ScheduledWorkRow({
             <X aria-hidden size={11} weight="bold" />
           </button>
         ) : null}
+        {onStop && isActive && snapshot.sourceTaskId ? (
+          <button
+            type="button"
+            onClick={onStop}
+            aria-label={`Stop ${snapshot.title}`}
+            title="Stop this background task"
+            className="flex h-5 w-5 items-center justify-center rounded-sm text-fg/25 opacity-0 transition-all hover:bg-rose-500/10 hover:text-rose-200/80 group-hover:opacity-100 focus-visible:opacity-100"
+          >
+            <Square aria-hidden size={10} weight="fill" />
+          </button>
+        ) : null}
       </div>
     </div>
   );
@@ -814,6 +827,7 @@ function SubagentRow({
   onToggleCollapsedSubtree,
   spawnedChatTitle = null,
   sessionModelLabel = null,
+  onStop,
 }: {
   snapshot: ChatSubagentSnapshot;
   selected: boolean;
@@ -836,6 +850,7 @@ function SubagentRow({
   /** Parent session model label used only when the envelope has no model. */
   sessionModelLabel?: string | null;
   onClick: () => void;
+  onStop?: (snapshot: ChatSubagentSnapshot) => void;
 }) {
   const isSpawnedChat = snapshot.childSessionId != null;
   // Spawned-chat rows read as the chat they open: prefer the resolved live
@@ -988,6 +1003,21 @@ function SubagentRow({
           {time ? <span className="text-fg/35 group-hover:text-fg/50">{time}</span> : null}
         </span>
       </button>
+      {isRunning && onStop && !isSpawnedChat ? (
+        <button
+          type="button"
+          aria-label={`Stop ${name}`}
+          title="Stop this subagent"
+          onClick={(event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            onStop(snapshot);
+          }}
+          className="mr-1 flex h-7 w-7 shrink-0 items-center justify-center self-center rounded-md text-fg/45 transition-colors hover:bg-rose-500/10 hover:text-rose-200/90"
+        >
+          <Square aria-hidden size={10} weight="fill" />
+        </button>
+      ) : null}
       </div>
 
       {filePaths.length > 0 ? (
@@ -1102,6 +1132,7 @@ export function ChatSubagentsPanel({
   onToggleSchedulesPaused,
   onCancelScheduledWork,
   onStopBackgroundTask,
+  onStopSubagent,
   sessionModelLabel = null,
 }: {
   sessionId?: string | null;
@@ -1145,6 +1176,7 @@ export function ChatSubagentsPanel({
   onCancelScheduledWork?: (snapshot: ChatScheduledWorkSnapshot) => void;
   /** Stop a running Codex background terminal via `thread/backgroundTerminals/terminate`. */
   onStopBackgroundTask?: (snapshot: ChatScheduledWorkSnapshot) => void;
+  onStopSubagent?: (snapshot: ChatSubagentSnapshot) => void;
   sessionModelLabel?: string | null;
 }) {
   const [expanded, setExpanded] = useState(false);
@@ -1532,6 +1564,7 @@ export function ChatSubagentsPanel({
           : null
       }
       sessionModelLabel={sessionModelLabel}
+      onStop={onStopSubagent}
       onClick={() => handleRowClick(snap)}
     />
   );
@@ -1674,7 +1707,18 @@ export function ChatSubagentsPanel({
             </button>
           ) : null}</>}
           idOf={(item) => item.id}
-          renderActiveRow={(item) => <ScheduledWorkRow snapshot={item} schedulesPaused={schedulesPaused} onCancel={onCancelScheduledWork ? () => onCancelScheduledWork(item) : undefined} />}
+          renderActiveRow={(item) => (
+            <ScheduledWorkRow
+              snapshot={item}
+              schedulesPaused={schedulesPaused}
+              onCancel={onCancelScheduledWork ? () => onCancelScheduledWork(item) : undefined}
+              onStop={
+                item.sourceTaskId && onStopBackgroundTask
+                  ? () => onStopBackgroundTask(item)
+                  : undefined
+              }
+            />
+          )}
           renderEarlierRow={(item) => isFiredOneShotWakeup(item)
             ? <ScheduleHistoryRow snapshot={item} />
             : <ScheduledWorkRow snapshot={item} schedulesPaused={schedulesPaused} />}
diff --git a/apps/desktop/src/renderer/components/chat/ProviderFailureRecoveryCard.tsx b/apps/desktop/src/renderer/components/chat/ProviderFailureRecoveryCard.tsx
index 1a8db28a1..bfaee0f3d 100644
--- a/apps/desktop/src/renderer/components/chat/ProviderFailureRecoveryCard.tsx
+++ b/apps/desktop/src/renderer/components/chat/ProviderFailureRecoveryCard.tsx
@@ -1,6 +1,6 @@
 import React, { useState } from "react";
 import type { AgentChatEvent } from "../../../shared/types";
-import { formatAutoResumeTime, isUsageLimitChatError } from "../../../shared/chatAutoResume";
+import { formatUsageLimitResetLabel, isUsageLimitChatError } from "../../../shared/chatAutoResume";
 
 export type ProviderFailureRecovery = {
   kind: "capacity" | "rate_limit";
@@ -14,8 +14,9 @@ export type ProviderFailureRecovery = {
  * only this card re-renders when the schedule appears or is cancelled.
  */
 export type ChatAutoResumeState = {
-  scheduleId: string;
-  /** ISO fire time of the durable scheduled-work row. */
+  /** ADE scheduled-work id, or null when the SDK is waiting natively. */
+  scheduleId: string | null;
+  /** ISO fire time of the durable scheduled-work row or SDK parked-until instant. */
   nextRunAt: string | null;
   /**
    * {@link providerFailureEventId} of the newest usage-limit failure in this
@@ -131,19 +132,23 @@ export function ProviderFailureRecoveryCard({
       {showAutoResume ? (
         <div
           data-testid="auto-resume-scheduled"
-          className="mt-2 flex flex-wrap items-center gap-2 text-[length:calc(var(--chat-font-size)*10.5/14)] leading-relaxed text-amber-50/72"
+          className="mt-2 space-y-2 text-[length:calc(var(--chat-font-size)*10.5/14)] leading-relaxed text-amber-50/72"
         >
-          <span>{`Auto-resume scheduled for ${formatAutoResumeTime(autoResumeAt)}`}</span>
-          <button
-            type="button"
-            disabled={cancelPending}
-            className="rounded-md border border-amber-200/16 bg-amber-300/[0.07] px-2 py-0.5 font-mono text-[length:calc(var(--chat-font-size)*9/14)] font-semibold text-amber-50/80 transition-colors hover:border-amber-200/30 hover:bg-amber-300/[0.13] disabled:pointer-events-none disabled:opacity-40"
-            onClick={() => { void cancelAutoResume(); }}
-          >
-            Cancel auto-resume
-          </button>
+          <div className="font-medium text-amber-50/90">Usage limit reached</div>
+          <div>{formatUsageLimitResetLabel(autoResumeAt)}</div>
+          <div>Continue automatically</div>
+          <div className="flex justify-end">
+            <button
+              type="button"
+              disabled={cancelPending}
+              className="rounded-md border border-amber-200/16 bg-amber-300/[0.07] px-2.5 py-1 font-mono text-[length:calc(var(--chat-font-size)*9/14)] font-semibold text-amber-50/80 transition-colors hover:border-amber-200/30 hover:bg-amber-300/[0.13] disabled:pointer-events-none disabled:opacity-40"
+              onClick={() => { void cancelAutoResume(); }}
+            >
+              Don&apos;t continue
+            </button>
+          </div>
         </div>
-      ) : null}
+      ) : (
       <div className="mt-2 flex flex-wrap gap-1.5">
         <button
           type="button"
@@ -165,6 +170,7 @@ export function ProviderFailureRecoveryCard({
           Choose model
         </button>
       </div>
+      )}
       {retryError ? (
         <div role="alert" className="mt-2 text-[length:calc(var(--chat-font-size)*10/14)] leading-relaxed text-red-200/75">
           {retryError}
diff --git a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.test.tsx b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.test.tsx
index c55c666f0..21c4438f8 100644
--- a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.test.tsx
@@ -24,6 +24,7 @@ function spawnEvent(overrides: Partial<SubagentSpawnAnchorRenderEvent> = {}): Su
     childSessionId: "child-abc",
     spawnKind: "subagent",
     resultSummary: null,
+    taskId: null,
     ...overrides,
   };
 }
@@ -74,6 +75,29 @@ describe("SubagentSpawnCard", () => {
     expect(navEvent).toBeUndefined();
     expect(screen.queryByText("SUBAGENT")).toBeNull();
   });
+
+  it("stops a running native subagent without navigating", () => {
+    const onStop = vi.fn();
+    const dispatchSpy = vi.spyOn(window, "dispatchEvent");
+    render(
+      <SubagentSpawnCard
+        event={spawnEvent({
+          childSessionId: null,
+          spawnKind: null,
+          agentType: "Explore",
+          taskId: "task-explore-1",
+        })}
+        onStop={onStop}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Stop Wave 2 UI" }));
+    expect(onStop).toHaveBeenCalledWith("task-explore-1");
+    const navEvent = dispatchSpy.mock.calls
+      .map(([evt]) => evt)
+      .find((evt): evt is CustomEvent => evt instanceof CustomEvent && evt.type === "ade:work:select-session");
+    expect(navEvent).toBeUndefined();
+  });
 });
 
 describe("BackgroundJobLine", () => {
diff --git a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx
index dbb12715e..8f90b3682 100644
--- a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx
+++ b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx
@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react";
-import { ArrowDown, ArrowUp, CaretDown, CaretRight, Check, Gear, Stop, X } from "@phosphor-icons/react";
+import { ArrowDown, ArrowUp, CaretDown, CaretRight, Check, Gear, Square, Stop, X } from "@phosphor-icons/react";
 import { cn } from "../ui/cn";
 import { formatSubagentDurationMs } from "../../lib/format";
 import { ChatSubagentGlyph, chatSubagentColor } from "./chatSubagentIdentity";
@@ -102,10 +102,12 @@ function glyphStatusFor(status: SubagentSpawnAnchorRenderEvent["status"]): ChatS
 export function SubagentSpawnCard({
   event,
   onJumpToResult,
+  onStop,
   laneId,
 }: {
   event: SubagentSpawnAnchorRenderEvent;
   onJumpToResult?: () => void;
+  onStop?: (taskId: string) => void;
   /** Lane of the spawner, forwarded to the navigation event when known. */
   laneId?: string | null;
 }) {
@@ -219,6 +221,22 @@ export function SubagentSpawnCard({
           open
           <CaretRight size={11} weight="bold" aria-hidden />
         </span>
+      ) : isRunning && onStop && event.taskId ? (
+        <button
+          type="button"
+          aria-label={`Stop ${event.description || "subagent"}`}
+          title="Stop this subagent"
+          onClick={(clickEvent) => {
+            clickEvent.preventDefault();
+            clickEvent.stopPropagation();
+            const taskId = event.taskId;
+            if (!taskId) return;
+            onStop(taskId);
+          }}
+          className="inline-flex h-7 w-7 shrink-0 items-center justify-center self-center rounded-md text-fg/40 transition-colors hover:bg-rose-500/10 hover:text-rose-200/90"
+        >
+          <Square size={10} weight="fill" aria-hidden />
+        </button>
       ) : !isRunning && onJumpToResult ? (
         <button
           type="button"
diff --git a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
index c39379648..edc5ddd2e 100644
--- a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
+++ b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
@@ -2967,6 +2967,7 @@ describe("subagent two-row rendering", () => {
       status: "completed",
       statusLine: "Reading transcript rows",
       toolCount: 2,
+      taskId: "agent-a",
     });
     expect(remainingText?.event).toMatchObject({
       type: "text",
diff --git a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
index 5899a9f4f..60701c590 100644
--- a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
+++ b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
@@ -158,6 +158,8 @@ export type SubagentSpawnAnchorRenderEvent = {
    * subagent). The whole card becomes a button that navigates to this session.
    */
   childSessionId: string | null;
+  /** Provider task id for the per-task stop control; null when this card navigates. */
+  taskId: string | null;
   /** Cosmetic relationship + completion-report policy; null for runtime-native subagents. */
   spawnKind: AgentChatSpawnKind | null;
   /** Final result summary, surfaced on the card once the agent settles. */
@@ -397,6 +399,11 @@ type SubagentAnchorState = {
   error: string | null;
   /** Child session id for a spawned ADE chat (`chat:<id>` taskId); null otherwise. */
   childSessionId: string | null;
+  /**
+   * Provider task id for per-task stop. Null for spawned ADE chats (`chat:<id>`)
+   * — those navigate rather than stop in-place.
+   */
+  taskId: string | null;
   /** Spawn-kind carried on the `subagent_started` event; null for runtime-native subagents. */
   spawnKind: AgentChatSpawnKind | null;
   /** Result-only usage/worktree metadata surfaced on the result card. */
@@ -1421,6 +1428,7 @@ function spawnAnchorEvent(
     startedAt: state.startedAt,
     endedAt: state.endedAt,
     childSessionId: state.childSessionId,
+    taskId: state.taskId,
     spawnKind: state.spawnKind,
     resultSummary: state.resultSummary,
     parentLabel: anchors ? resolveParentLabel(state, anchors) : null,
@@ -1457,6 +1465,9 @@ function enrichSubagentStateFromEvent(
   if (taskId && taskId.startsWith("chat:") && !state.childSessionId) {
     state.childSessionId = subagentText(event.agentId) ?? (taskId.slice("chat:".length) || null);
   }
+  if (taskId && !taskId.startsWith("chat:") && !state.taskId) {
+    state.taskId = taskId;
+  }
   if (record.spawnKind === "subagent" || record.spawnKind === "peer") {
     state.spawnKind = record.spawnKind;
   }
@@ -1531,6 +1542,7 @@ function handleSubagentLifecycleEvent(
       resultSummary: null,
       error: null,
       childSessionId: null,
+      taskId: taskId && !taskId.startsWith("chat:") ? taskId : null,
       spawnKind: null,
       totalTokens: null,
       toolUseCount: null,
diff --git a/apps/desktop/src/renderer/webclient/adapter/agentChat.ts b/apps/desktop/src/renderer/webclient/adapter/agentChat.ts
index 5bf18d0bb..6b62251fd 100644
--- a/apps/desktop/src/renderer/webclient/adapter/agentChat.ts
+++ b/apps/desktop/src/renderer/webclient/adapter/agentChat.ts
@@ -327,6 +327,15 @@ export function createAgentChatNamespace(infra: AdapterInfra): AdeNamespace<"age
         false,
       );
     },
+    stopTask: async (args: unknown, pin?: RuntimePinArg) => {
+      guardPin("stopTask", pin);
+      return await call(
+        "chat.stopTask",
+        args,
+        { sessionId: "", taskId: "", stopped: false },
+        false,
+      );
+    },
     restoreCancelledQueue: async (args: unknown, pin?: RuntimePinArg) => {
       guardPin("restoreCancelledQueue", pin);
       return await call<AgentChatRestoreCancelledQueueResult>(
diff --git a/apps/desktop/src/shared/chatAutoResume.test.ts b/apps/desktop/src/shared/chatAutoResume.test.ts
index 86a8859e2..d1e90f2fe 100644
--- a/apps/desktop/src/shared/chatAutoResume.test.ts
+++ b/apps/desktop/src/shared/chatAutoResume.test.ts
@@ -6,9 +6,11 @@ import {
   autoResumeFireAtMs,
   autoResumeScheduleId,
   formatAutoResumeTime,
+  formatUsageLimitResetLabel,
   isAutoResumeScheduledWork,
   isPendingAutoResumeScheduledWork,
   isUsageLimitChatError,
+  sessionAutoContinueAtUsageLimit,
 } from "./chatAutoResume";
 
 describe("isUsageLimitChatError", () => {
@@ -133,3 +135,26 @@ describe("formatAutoResumeTime", () => {
     expect(formatAutoResumeTime(Number.NaN)).toBe("");
   });
 });
+
+describe("formatUsageLimitResetLabel", () => {
+  it("names the reset clock and remaining window", () => {
+    const resetAt = Date.parse("2026-08-29T15:40:00.000Z");
+    const now = resetAt - 47 * 60_000;
+    expect(formatUsageLimitResetLabel(resetAt, now)).toMatch(/^Reset at .+\(47 min\)$/);
+  });
+
+  it("omits the remaining window once the reset instant has passed", () => {
+    const resetAt = Date.parse("2026-08-29T15:40:00.000Z");
+    expect(formatUsageLimitResetLabel(resetAt, resetAt + 60_000)).toMatch(/^Reset at /);
+    expect(formatUsageLimitResetLabel(resetAt, resetAt + 60_000)).not.toMatch(/min\)|hr\)$/);
+  });
+});
+
+describe("sessionAutoContinueAtUsageLimit", () => {
+  it("defaults auto-continue on, with explicit false as the per-chat opt-out", () => {
+    expect(sessionAutoContinueAtUsageLimit(undefined)).toBe(true);
+    expect(sessionAutoContinueAtUsageLimit({})).toBe(true);
+    expect(sessionAutoContinueAtUsageLimit({ autoContinueAtUsageLimit: true })).toBe(true);
+    expect(sessionAutoContinueAtUsageLimit({ autoContinueAtUsageLimit: false })).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/shared/chatAutoResume.ts b/apps/desktop/src/shared/chatAutoResume.ts
index 3ca947400..0b892a664 100644
--- a/apps/desktop/src/shared/chatAutoResume.ts
+++ b/apps/desktop/src/shared/chatAutoResume.ts
@@ -146,6 +146,34 @@ export function formatAutoResumeTime(fireAtMs: number): string {
   }
 }
 
+/** Clock-only label for the usage-limit dialog ("3:40 PM"). */
+export function formatAutoResumeClock(fireAtMs: number): string {
+  const date = new Date(fireAtMs);
+  if (Number.isNaN(date.getTime())) return "";
+  try {
+    return new Intl.DateTimeFormat(undefined, {
+      hour: "numeric",
+      minute: "2-digit",
+    }).format(date);
+  } catch {
+    return date.toLocaleTimeString();
+  }
+}
+
+/**
+ * Wireframe copy: "Reset at 3:40 PM (47 min)". Omits the remaining window
+ * when the reset instant has already passed.
+ */
+export function formatUsageLimitResetLabel(resetAtMs: number, nowMs: number = Date.now()): string {
+  const clock = formatAutoResumeClock(resetAtMs);
+  if (!clock) return "";
+  const remainingMs = resetAtMs - nowMs;
+  if (!Number.isFinite(remainingMs) || remainingMs <= 0) return `Reset at ${clock}`;
+  const minutes = Math.max(1, Math.round(remainingMs / 60_000));
+  const remaining = minutes < 60 ? `${minutes} min` : `${Math.round(minutes / 60)} hr`;
+  return `Reset at ${clock} (${remaining})`;
+}
+
 /**
  * The one "auto-resume is armed" sentence. The host writes it into the chat as
  * a system notice; the renderer's recovery card shows it live next to Cancel.
@@ -154,3 +182,10 @@ export function formatAutoResumeTime(fireAtMs: number): string {
 export function autoResumeScheduledMessage(fireAtMs: number): string {
   return `Auto-resume scheduled for ${formatAutoResumeTime(fireAtMs)}`;
 }
+
+/** Default on; explicit `false` is the per-chat opt-out. */
+export function sessionAutoContinueAtUsageLimit(
+  session: { autoContinueAtUsageLimit?: boolean | null } | null | undefined,
+): boolean {
+  return session?.autoContinueAtUsageLimit !== false;
+}
diff --git a/apps/desktop/src/shared/chatStopModes.test.ts b/apps/desktop/src/shared/chatStopModes.test.ts
new file mode 100644
index 000000000..96e910dac
--- /dev/null
+++ b/apps/desktop/src/shared/chatStopModes.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vitest";
+import {
+  AGENT_CHAT_STOP_MODES,
+  CLAUDE_PER_TASK_STOP_CONTROLS_REACHABLE,
+  DEFAULT_AGENT_CHAT_STOP_MODE,
+  SETTLE_TEARDOWN_STOP_MODE,
+  chatStopModeCopy,
+  formatBackgroundJobCount,
+  isAgentChatStopMode,
+  parseAgentChatStopMode,
+  resolveAgentChatStopModeAlias,
+  shouldDeclarePerTaskStopAffordance,
+  stopModeClearsQueue,
+  stopModeStopsBackground,
+} from "./chatStopModes";
+
+describe("chat stop matrix", () => {
+  it("names all four queue × background combinations", () => {
+    expect(AGENT_CHAT_STOP_MODES).toEqual([
+      "stop_only",
+      "stop_and_clear",
+      "stop_and_background",
+      "stop_and_clear_and_background",
+    ]);
+  });
+
+  it("keeps stop_and_clear as the default so existing Stop-means-stop callers stay on the queue axis", () => {
+    expect(DEFAULT_AGENT_CHAT_STOP_MODE).toBe("stop_and_clear");
+    expect(stopModeClearsQueue("stop_and_clear")).toBe(true);
+    expect(stopModeStopsBackground("stop_and_clear")).toBe(false);
+  });
+
+  it("keeps the user's queue on settle while still stopping background work", () => {
+    expect(SETTLE_TEARDOWN_STOP_MODE).toBe("stop_and_background");
+    expect(stopModeClearsQueue(SETTLE_TEARDOWN_STOP_MODE)).toBe(false);
+    expect(stopModeStopsBackground(SETTLE_TEARDOWN_STOP_MODE)).toBe(true);
+  });
+
+  it("parses unknown stored modes back to the default instead of inventing a fifth axis", () => {
+    expect(parseAgentChatStopMode("stop_only")).toBe("stop_only");
+    expect(parseAgentChatStopMode("stop_and_clear_and_background")).toBe("stop_and_clear_and_background");
+    expect(parseAgentChatStopMode("nope")).toBe("stop_and_clear");
+    expect(parseAgentChatStopMode(undefined)).toBe("stop_and_clear");
+    expect(isAgentChatStopMode("stop_and_background")).toBe(true);
+    expect(isAgentChatStopMode("stop")).toBe(false);
+  });
+
+  it("spells live job count into the wireframe labels", () => {
+    expect(formatBackgroundJobCount(0)).toBe("0 jobs");
+    expect(formatBackgroundJobCount(1)).toBe("1 job");
+    expect(formatBackgroundJobCount(3)).toBe("3 jobs");
+    expect(chatStopModeCopy("stop_only", 3).label).toBe("Turn only");
+    expect(chatStopModeCopy("stop_and_clear", 3).label).toBe("Turn + queue");
+    expect(chatStopModeCopy("stop_and_background", 3).label).toBe("Turn + background (3 jobs)");
+    expect(chatStopModeCopy("stop_and_clear_and_background", 1).label).toBe(
+      "Turn + queue + background (1 job)",
+    );
+  });
+
+  it("declares perTaskStopAffordance only when stopTask is exposed and the UI can reach it", () => {
+    expect(shouldDeclarePerTaskStopAffordance({
+      stopTaskExposed: false,
+      stopControlsReachable: true,
+    })).toBe(false);
+    expect(shouldDeclarePerTaskStopAffordance({
+      stopTaskExposed: true,
+      stopControlsReachable: false,
+    })).toBe(false);
+    expect(shouldDeclarePerTaskStopAffordance({
+      stopTaskExposed: true,
+      stopControlsReachable: true,
+    })).toBe(true);
+    expect(CLAUDE_PER_TASK_STOP_CONTROLS_REACHABLE).toBe(true);
+  });
+
+  it("resolves hyphen, underscore, and flag aliases to the four-mode matrix", () => {
+    expect(resolveAgentChatStopModeAlias("keep-queue")).toBe("stop_only");
+    expect(resolveAgentChatStopModeAlias("clear-queue")).toBe("stop_and_clear");
+    expect(resolveAgentChatStopModeAlias("background")).toBe("stop_and_background");
+    expect(resolveAgentChatStopModeAlias("clear-and-background")).toBe("stop_and_clear_and_background");
+    expect(resolveAgentChatStopModeAlias("stop_and_clear")).toBe("stop_and_clear");
+    expect(resolveAgentChatStopModeAlias("nope")).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/shared/chatStopModes.ts b/apps/desktop/src/shared/chatStopModes.ts
new file mode 100644
index 000000000..54d8325dd
--- /dev/null
+++ b/apps/desktop/src/shared/chatStopModes.ts
@@ -0,0 +1,136 @@
+/**
+ * Canonical chat stop matrix: queue axis × background axis.
+ *
+ * `AgentChatStopMode` used to be queue-only (`stop_and_clear` | `stop_only`).
+ * After Claude Agent SDK `perTaskStopAffordance`, an interrupt can spare
+ * running background tasks — so the mode must name both axes, and the
+ * composer / iOS menus must spell them out. iOS hand-mirrors this table in
+ * `WorkChatStopCapability` because it cannot import TS.
+ *
+ * Default remains `stop_and_clear` (stop the turn and cancel queued messages;
+ * background jobs keep running once the per-task stop controls exist).
+ */
+
+export const AGENT_CHAT_STOP_MODES = [
+  "stop_only",
+  "stop_and_clear",
+  "stop_and_background",
+  "stop_and_clear_and_background",
+] as const;
+
+export type AgentChatStopMode = (typeof AGENT_CHAT_STOP_MODES)[number];
+
+export const DEFAULT_AGENT_CHAT_STOP_MODE: AgentChatStopMode = "stop_and_clear";
+
+/**
+ * Settle teardown keeps the user's queued prompts (those are unrecoverable)
+ * and still stops background work (the reason settle exists). After the
+ * matrix, that combination is `stop_and_background`, not `stop_only`.
+ */
+export const SETTLE_TEARDOWN_STOP_MODE: AgentChatStopMode = "stop_and_background";
+
+export function isAgentChatStopMode(value: unknown): value is AgentChatStopMode {
+  return typeof value === "string"
+    && (AGENT_CHAT_STOP_MODES as readonly string[]).includes(value);
+}
+
+export function parseAgentChatStopMode(
+  value: unknown,
+  fallback: AgentChatStopMode = DEFAULT_AGENT_CHAT_STOP_MODE,
+): AgentChatStopMode {
+  return isAgentChatStopMode(value) ? value : fallback;
+}
+
+const AGENT_CHAT_STOP_MODE_ALIASES: Record<string, AgentChatStopMode> = {
+  stop_only: "stop_only",
+  "stop-only": "stop_only",
+  "--stop-only": "stop_only",
+  "keep-queue": "stop_only",
+  "--keep-queue": "stop_only",
+  stop_and_clear: "stop_and_clear",
+  "stop-and-clear": "stop_and_clear",
+  "clear-queue": "stop_and_clear",
+  "--clear-queue": "stop_and_clear",
+  stop_and_background: "stop_and_background",
+  "stop-and-background": "stop_and_background",
+  background: "stop_and_background",
+  "turn-and-background": "stop_and_background",
+  stop_and_clear_and_background: "stop_and_clear_and_background",
+  "stop-and-clear-and-background": "stop_and_clear_and_background",
+  "clear-and-background": "stop_and_clear_and_background",
+};
+
+/** Hyphen, underscore, and composer-flag aliases for the four-mode matrix. */
+export function resolveAgentChatStopModeAlias(value: string): AgentChatStopMode | null {
+  const key = value.trim().toLowerCase();
+  return AGENT_CHAT_STOP_MODE_ALIASES[key] ?? null;
+}
+
+export function stopModeClearsQueue(mode: AgentChatStopMode): boolean {
+  return mode === "stop_and_clear" || mode === "stop_and_clear_and_background";
+}
+
+export function stopModeStopsBackground(mode: AgentChatStopMode): boolean {
+  return mode === "stop_and_background" || mode === "stop_and_clear_and_background";
+}
+
+export function formatBackgroundJobCount(count: number): string {
+  const n = Number.isFinite(count) ? Math.max(0, Math.floor(count)) : 0;
+  return n === 1 ? "1 job" : `${n} jobs`;
+}
+
+export type AgentChatStopModeCopy = {
+  label: string;
+  description: string;
+};
+
+/**
+ * Wireframe labels. Job count is live: "Turn + background (3 jobs)".
+ */
+export function chatStopModeCopy(
+  mode: AgentChatStopMode,
+  jobCount: number,
+): AgentChatStopModeCopy {
+  const jobs = formatBackgroundJobCount(jobCount);
+  switch (mode) {
+    case "stop_only":
+      return {
+        label: "Turn only",
+        description: "Stop the active turn. Keep queued messages and background jobs.",
+      };
+    case "stop_and_clear":
+      return {
+        label: "Turn + queue",
+        description: "Stop the active turn and cancel queued messages. Background jobs keep running.",
+      };
+    case "stop_and_background":
+      return {
+        label: `Turn + background (${jobs})`,
+        description: `Stop the active turn and stop ${jobs}. Keep queued messages.`,
+      };
+    case "stop_and_clear_and_background":
+      return {
+        label: `Turn + queue + background (${jobs})`,
+        description: `Stop the active turn, cancel queued messages, and stop ${jobs}.`,
+      };
+    default: {
+      const exhaustive: never = mode;
+      return exhaustive;
+    }
+  }
+}
+
+/**
+ * `perTaskStopAffordance` makes interrupt spare background tasks. Declaring it
+ * before the user can stop those tasks individually is strictly worse than
+ * today. Both gates must be true.
+ */
+export function shouldDeclarePerTaskStopAffordance(args: {
+  stopTaskExposed: boolean;
+  stopControlsReachable: boolean;
+}): boolean {
+  return args.stopTaskExposed === true && args.stopControlsReachable === true;
+}
+
+/** True once this branch exposes `chat.stopTask` and the subagent/job stop UI. */
+export const CLAUDE_PER_TASK_STOP_CONTROLS_REACHABLE = true;
diff --git a/apps/desktop/src/shared/claudeClassifierContext.test.ts b/apps/desktop/src/shared/claudeClassifierContext.test.ts
new file mode 100644
index 000000000..c73d82f44
--- /dev/null
+++ b/apps/desktop/src/shared/claudeClassifierContext.test.ts
@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import {
+  CLASSIFIER_APPROVAL_WITHOUT_TEXT,
+  CLASSIFIER_CONTEXT_MAX_UTF16,
+  buildClassifierContext,
+  classifierContextAuditMessage,
+} from "./claudeClassifierContext";
+
+describe("classifierContext user-authorship", () => {
+  it("relays the user's exact typed words and nothing else", () => {
+    const relay = buildClassifierContext({
+      typedText: "  only this bash once  ",
+      explicitApproval: true,
+    });
+    expect(relay).toEqual({
+      classifierContext: "only this bash once",
+      source: "typed_consent",
+      truncated: false,
+    });
+  });
+
+  it("relays a fixed approval sentence when the user accepted without typing, never the command", () => {
+    const relay = buildClassifierContext({
+      typedText: "   ",
+      explicitApproval: true,
+    });
+    expect(relay?.classifierContext).toBe(CLASSIFIER_APPROVAL_WITHOUT_TEXT);
+    expect(relay?.source).toBe("explicit_approval");
+    expect(relay?.classifierContext.includes("rm -rf")).toBe(false);
+    expect(relay?.classifierContext.toLowerCase().includes("tool output")).toBe(false);
+  });
+
+  it("relays nothing when ADE cannot attribute a statement to the user", () => {
+    expect(buildClassifierContext({ explicitApproval: false })).toBeNull();
+    expect(buildClassifierContext({ typedText: null, explicitApproval: false })).toBeNull();
+    expect(buildClassifierContext({ typedText: "", explicitApproval: false })).toBeNull();
+  });
+
+  it("clips to the SDK 2000 UTF-16 cap without summarizing", () => {
+    const typed = "yes ".repeat(600);
+    const relay = buildClassifierContext({ typedText: typed, explicitApproval: true });
+    expect(relay?.truncated).toBe(true);
+    expect(relay?.classifierContext.length).toBe(CLASSIFIER_CONTEXT_MAX_UTF16);
+    expect(relay?.classifierContext.startsWith("yes yes")).toBe(true);
+    expect(classifierContextAuditMessage(relay!).detail).toBe("Truncated to 2000 characters.");
+  });
+
+  it("cannot be given tool output or model text as a first-class field — only typedText", () => {
+    const keys = Object.keys(buildClassifierContext({
+      typedText: "allow",
+      explicitApproval: true,
+    }) ?? {});
+    expect(keys).toEqual(["classifierContext", "source", "truncated"]);
+  });
+});
diff --git a/apps/desktop/src/shared/claudeClassifierContext.ts b/apps/desktop/src/shared/claudeClassifierContext.ts
new file mode 100644
index 000000000..3af19ff7a
--- /dev/null
+++ b/apps/desktop/src/shared/claudeClassifierContext.ts
@@ -0,0 +1,84 @@
+/**
+ * User-authored classifierContext for Claude auto permission mode.
+ *
+ * Security: only user-authored content may occupy an intent-bearing position.
+ * Never tool output, never model or subagent text, never a summary of either.
+ * If ADE cannot attribute a statement to the user, it does not relay it.
+ *
+ * The SDK caps classifierContext at 2000 UTF-16 code units (`string.length`
+ * in JS). Hook responses that carry it must be returned on the same
+ * PostToolUse completion — a late async value is silently ignored.
+ */
+
+export const CLASSIFIER_CONTEXT_MAX_UTF16 = 2000;
+
+/**
+ * Approval-without-text. Do not include the proposed command: that would
+ * launder model-authored text as user consent.
+ */
+export const CLASSIFIER_APPROVAL_WITHOUT_TEXT = "The user approved this tool call.";
+
+export type ClassifierContextSource = "typed_consent" | "explicit_approval";
+
+export type UserAuthoredClassifierInput = {
+  /**
+   * Exact user-typed text. Callers must pass only what the user typed into
+   * the approval card — never a tool argument, never a model summary.
+   */
+  typedText?: string | null;
+  /** True when the user explicitly accepted (once or for the session). */
+  explicitApproval: boolean;
+};
+
+export type ClassifierContextRelay = {
+  classifierContext: string;
+  source: ClassifierContextSource;
+  truncated: boolean;
+};
+
+export function clipUtf16(text: string, max: number = CLASSIFIER_CONTEXT_MAX_UTF16): {
+  text: string;
+  truncated: boolean;
+} {
+  if (text.length <= max) return { text, truncated: false };
+  return { text: text.slice(0, Math.max(0, max)), truncated: true };
+}
+
+/**
+ * Build the string ADE will put in an intent-bearing classifierContext slot.
+ * Returns null when there is nothing attributable to the user.
+ */
+export function buildClassifierContext(
+  input: UserAuthoredClassifierInput,
+): ClassifierContextRelay | null {
+  const typed = typeof input.typedText === "string" ? input.typedText.trim() : "";
+  if (typed.length > 0) {
+    const clipped = clipUtf16(typed);
+    return {
+      classifierContext: clipped.text,
+      source: "typed_consent",
+      truncated: clipped.truncated,
+    };
+  }
+  if (input.explicitApproval) {
+    return {
+      classifierContext: CLASSIFIER_APPROVAL_WITHOUT_TEXT,
+      source: "explicit_approval",
+      truncated: false,
+    };
+  }
+  return null;
+}
+
+export function classifierContextAuditMessage(relay: ClassifierContextRelay): {
+  message: string;
+  detail?: string;
+} {
+  const message = relay.source === "typed_consent"
+    ? "Relayed user consent to the auto-mode classifier."
+    : "Relayed an explicit approval to the auto-mode classifier.";
+  const detail = relay.truncated
+    ? "Truncated to 2000 characters."
+    : undefined;
+  return detail ? { message, detail } : { message };
+}
diff --git a/apps/desktop/src/shared/claudeContextUsage.test.ts b/apps/desktop/src/shared/claudeContextUsage.test.ts
new file mode 100644
index 000000000..dbc4a2ecd
--- /dev/null
+++ b/apps/desktop/src/shared/claudeContextUsage.test.ts
@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import {
+  classifyClaudeContextCategory,
+  normalizeClaudeContextUsage,
+} from "./claudeContextUsage";
+
+describe("Claude context usage kind classification", () => {
+  it("classifies by kind, never by the name string free", () => {
+    expect(classifyClaudeContextCategory({ kind: "free" })).toBe("free");
+    expect(classifyClaudeContextCategory({ kind: "buffer" })).toBe("buffer");
+    expect(classifyClaudeContextCategory({ kind: "deferred" })).toBe("deferred");
+    expect(classifyClaudeContextCategory({ kind: "used" })).toBe("used");
+    expect(classifyClaudeContextCategory({ kind: "used", isDeferred: true })).toBe("used");
+    expect(classifyClaudeContextCategory({ isDeferred: true })).toBe("deferred");
+    expect(classifyClaudeContextCategory({})).toBe("used");
+  });
+
+  it("does not invent a free row from a category named Free that is actually used", () => {
+    const usage = normalizeClaudeContextUsage({
+      totalTokens: 136_000,
+      maxTokens: 200_000,
+      percentage: 68,
+      model: "Opus 5",
+      categories: [
+        { name: "Messages", tokens: 82_000, kind: "used" },
+        { name: "MCP tools", tokens: 31_000, kind: "used", mcpServers: [
+          { name: "posthog", tokens: 18_000 },
+          { name: "linear", tokens: 9_000 },
+          { name: "ade", tokens: 4_000 },
+        ] },
+        { name: "Memory files", tokens: 9_000, kind: "used" },
+        { name: "Free", tokens: 64_000, kind: "free" },
+        { name: "Compaction gap", tokens: 8_000, kind: "buffer" },
+      ],
+    });
+    expect(usage.categories.map((row) => ({ name: row.name, kind: row.kind }))).toEqual([
+      { name: "Messages", kind: "used" },
+      { name: "MCP tools", kind: "used" },
+      { name: "Memory files", kind: "used" },
+      { name: "Free", kind: "free" },
+      { name: "Compaction gap", kind: "buffer" },
+    ]);
+    expect(usage.categories.find((row) => row.name === "MCP tools")?.mcpServers).toEqual([
+      { name: "posthog", tokens: 18_000 },
+      { name: "linear", tokens: 9_000 },
+      { name: "ade", tokens: 4_000 },
+    ]);
+  });
+
+  it("does not treat a used row named free as remaining capacity", () => {
+    const usage = normalizeClaudeContextUsage({
+      totalTokens: 50,
+      maxTokens: 100,
+      categories: [
+        { name: "free", tokens: 50, kind: "used" },
+      ],
+    });
+    expect(usage.categories.filter((row) => row.kind === "used").map((row) => row.name)).toEqual(["free"]);
+    expect(usage.categories.filter((row) => row.kind === "free")).toEqual([
+      { name: "Free", tokens: 50, percentage: 50, kind: "free" },
+    ]);
+  });
+
+  it("synthesizes remaining capacity as kind free when the SDK omitted that row", () => {
+    const usage = normalizeClaudeContextUsage({
+      totalTokens: 40,
+      maxTokens: 100,
+      categories: [{ name: "Messages", tokens: 40, kind: "used" }],
+    });
+    expect(usage.categories.some((row) => row.kind === "free" && row.tokens === 60)).toBe(true);
+    expect(usage.categories.some((row) => row.name.trim().toLowerCase() === "free" && row.kind !== "free")).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/shared/claudeContextUsage.ts b/apps/desktop/src/shared/claudeContextUsage.ts
new file mode 100644
index 000000000..036539491
--- /dev/null
+++ b/apps/desktop/src/shared/claudeContextUsage.ts
@@ -0,0 +1,142 @@
+/**
+ * Structured Claude `/context` occupancy. Classify rows by `categories[].kind`
+ * (`used` / `free` / `buffer` / `deferred`), never by matching the name string
+ * `"free"` — the SDK docs say so, and a name match is a latent bug.
+ */
+
+export const CLAUDE_CONTEXT_CATEGORY_KINDS = ["used", "free", "buffer", "deferred"] as const;
+export type ClaudeContextCategoryKind = (typeof CLAUDE_CONTEXT_CATEGORY_KINDS)[number];
+
+export type ClaudeContextMcpServerUsage = {
+  name: string;
+  tokens: number;
+};
+
+export type ClaudeContextUsageCategory = {
+  name: string;
+  tokens: number;
+  percentage: number;
+  kind: ClaudeContextCategoryKind;
+  color?: string;
+  mcpServers?: ClaudeContextMcpServerUsage[];
+};
+
+export type ClaudeContextUsage = {
+  categories: ClaudeContextUsageCategory[];
+  totalTokens: number;
+  maxTokens: number;
+  rawMaxTokens?: number;
+  percentage: number;
+  model?: string;
+};
+
+export function isClaudeContextCategoryKind(value: unknown): value is ClaudeContextCategoryKind {
+  return typeof value === "string"
+    && (CLAUDE_CONTEXT_CATEGORY_KINDS as readonly string[]).includes(value);
+}
+
+/**
+ * Kind is authoritative. `isDeferred` is a fallback for older payloads that
+ * never set `kind`. The category *name* is never consulted — a row named
+ * "Free" with `kind: "used"` stays used.
+ */
+export function classifyClaudeContextCategory(category: {
+  kind?: unknown;
+  isDeferred?: unknown;
+}): ClaudeContextCategoryKind {
+  if (isClaudeContextCategoryKind(category.kind)) return category.kind;
+  if (category.isDeferred === true) return "deferred";
+  return "used";
+}
+
+function nonNegativeInt(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+
+function readMcpServers(category: Record<string, unknown>): ClaudeContextMcpServerUsage[] {
+  const fromArray = (raw: unknown): ClaudeContextMcpServerUsage[] => {
+    if (!Array.isArray(raw)) return [];
+    return raw.flatMap((entry) => {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
+      const record = entry as Record<string, unknown>;
+      const name = typeof record.name === "string" && record.name.trim()
+        ? record.name.trim()
+        : typeof record.serverName === "string" && record.serverName.trim()
+          ? record.serverName.trim()
+          : typeof record.server === "string" && record.server.trim()
+            ? record.server.trim()
+            : "";
+      const tokens = nonNegativeInt(record.tokens ?? record.tokenCount);
+      if (!name && tokens === 0) return [];
+      return [{ name: name || "MCP", tokens }];
+    });
+  };
+  const listed = fromArray(category.mcpServers ?? category.servers ?? category.mcp_servers);
+  if (listed.length) return listed;
+  const map = category.mcpServers ?? category.servers;
+  if (!map || typeof map !== "object" || Array.isArray(map)) return [];
+  return Object.entries(map as Record<string, unknown>).flatMap(([name, tokens]) => {
+    const count = nonNegativeInt(tokens);
+    if (!name.trim() && count === 0) return [];
+    return [{ name: name.trim() || "MCP", tokens: count }];
+  });
+}
+
+export function normalizeClaudeContextUsage(usage: {
+  categories?: unknown;
+  totalTokens?: unknown;
+  maxTokens?: unknown;
+  rawMaxTokens?: unknown;
+  percentage?: unknown;
+  model?: unknown;
+} | null | undefined): ClaudeContextUsage {
+  const totalTokens = nonNegativeInt(usage?.totalTokens);
+  const maxTokens = nonNegativeInt(usage?.maxTokens);
+  const denominator = maxTokens > 0 ? maxTokens : totalTokens > 0 ? totalTokens : 1;
+  const rawCategories = Array.isArray(usage?.categories) ? usage.categories : [];
+  const categories: ClaudeContextUsageCategory[] = rawCategories.flatMap((raw) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return [];
+    const category = raw as Record<string, unknown>;
+    const name = typeof category.name === "string" ? category.name.trim() : "";
+    const tokens = nonNegativeInt(category.tokens);
+    if (!name.length && tokens === 0) return [];
+    const kind = classifyClaudeContextCategory(category);
+    const mcpServers = readMcpServers(category);
+    return [{
+      name: name || "Other",
+      tokens,
+      percentage: tokens > 0 ? (tokens / denominator) * 100 : 0,
+      kind,
+      ...(typeof category.color === "string" && category.color.trim().length
+        ? { color: category.color.trim() }
+        : {}),
+      ...(mcpServers.length ? { mcpServers } : {}),
+    }];
+  });
+
+  if (maxTokens > totalTokens && !categories.some((category) => category.kind === "free")) {
+    const freeTokens = maxTokens - totalTokens;
+    categories.push({
+      name: "Free",
+      tokens: freeTokens,
+      percentage: maxTokens > 0 ? (freeTokens / maxTokens) * 100 : 0,
+      kind: "free",
+    });
+  }
+
+  const rawMaxTokens = nonNegativeInt(usage?.rawMaxTokens);
+  return {
+    categories,
+    totalTokens,
+    maxTokens,
+    rawMaxTokens: rawMaxTokens > 0 ? rawMaxTokens : maxTokens,
+    percentage: typeof usage?.percentage === "number" && Number.isFinite(usage.percentage)
+      ? Math.max(0, Math.min(100, usage.percentage))
+      : maxTokens > 0
+        ? (totalTokens / maxTokens) * 100
+        : 0,
+    ...(typeof usage?.model === "string" && usage.model.trim().length
+      ? { model: usage.model.trim() }
+      : {}),
+  };
+}
diff --git a/apps/desktop/src/shared/claudeModelSwitch.test.ts b/apps/desktop/src/shared/claudeModelSwitch.test.ts
new file mode 100644
index 000000000..4923f0d86
--- /dev/null
+++ b/apps/desktop/src/shared/claudeModelSwitch.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import {
+  claudeModelSwitchAdditionalContext,
+  claudeModelSwitchDividerMessage,
+  parseClaudeModelSwitchArgs,
+} from "./claudeModelSwitch";
+
+describe("Claude model-switch copy", () => {
+  it("carries from, to, and requested model on the quiet divider", () => {
+    expect(claudeModelSwitchDividerMessage({
+      fromModel: "claude-opus-4-7",
+      toModel: "Sonnet 5",
+      requestedModel: "sonnet",
+    })).toBe('switched to Sonnet 5 · requested "sonnet"');
+  });
+
+  it("tells the incoming model what it inherited without dumping transcript", () => {
+    expect(claudeModelSwitchAdditionalContext({
+      fromModel: "Opus 4.7",
+      toModel: "Sonnet 5",
+      requestedModel: "sonnet",
+    })).toBe(
+      "You inherited this conversation from Opus 4.7. The user requested sonnet. Continue from the existing thread; do not restart completed work.",
+    );
+  });
+
+  it("reads snake_case and camelCase PostModelSwitch fields", () => {
+    expect(parseClaudeModelSwitchArgs({
+      from_model: "Opus",
+      toModel: "Sonnet",
+      requested_model: "sonnet",
+    })).toEqual({
+      fromModel: "Opus",
+      toModel: "Sonnet",
+      requestedModel: "sonnet",
+    });
+  });
+});
diff --git a/apps/desktop/src/shared/claudeModelSwitch.ts b/apps/desktop/src/shared/claudeModelSwitch.ts
new file mode 100644
index 000000000..5615bfdf6
--- /dev/null
+++ b/apps/desktop/src/shared/claudeModelSwitch.ts
@@ -0,0 +1,55 @@
+/**
+ * Quiet model-switch divider copy and PostModelSwitch additionalContext.
+ * Replaces the inference that PR #1197 fought (alias forwarding clobbering
+ * the session model).
+ */
+
+export type ClaudeModelSwitchArgs = {
+  fromModel?: string | null;
+  toModel?: string | null;
+  requestedModel?: string | null;
+};
+
+function compact(value: string | null | undefined): string | null {
+  const text = typeof value === "string" ? value.trim() : "";
+  return text.length ? text : null;
+}
+
+export function claudeModelSwitchDividerMessage(args: ClaudeModelSwitchArgs): string {
+  const toModel = compact(args.toModel) ?? "the incoming model";
+  const requested = compact(args.requestedModel);
+  return requested
+    ? `switched to ${toModel} · requested "${requested}"`
+    : `switched to ${toModel}`;
+}
+
+export function claudeModelSwitchAdditionalContext(args: ClaudeModelSwitchArgs): string {
+  const fromModel = compact(args.fromModel);
+  const requested = compact(args.requestedModel);
+  const inherited = fromModel
+    ? `You inherited this conversation from ${fromModel}.`
+    : "You inherited this conversation.";
+  const request = requested
+    ? ` The user requested ${requested}.`
+    : "";
+  return `${inherited}${request} Continue from the existing thread; do not restart completed work.`;
+}
+
+function stringField(record: Record<string, unknown>, ...keys: string[]): string | null {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+
+/** Reads snake_case or camelCase PostModelSwitch payload fields. */
+export function parseClaudeModelSwitchArgs(input: unknown): ClaudeModelSwitchArgs {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return {};
+  const record = input as Record<string, unknown>;
+  return {
+    fromModel: stringField(record, "from_model", "fromModel"),
+    toModel: stringField(record, "to_model", "toModel"),
+    requestedModel: stringField(record, "requested_model", "requestedModel"),
+  };
+}
diff --git a/apps/desktop/src/shared/ipc.ts b/apps/desktop/src/shared/ipc.ts
index 043f7835d..16a943429 100644
--- a/apps/desktop/src/shared/ipc.ts
+++ b/apps/desktop/src/shared/ipc.ts
@@ -300,6 +300,7 @@ export const IPC = {
   agentChatDispatchSteer: "ade.agentChat.dispatchSteer",
   agentChatCancelDispatchedSteer: "ade.agentChat.cancelDispatchedSteer",
   agentChatInterrupt: "ade.agentChat.interrupt",
+  agentChatStopTask: "ade.agentChat.stopTask",
   agentChatRestoreCancelledQueue: "ade.agentChat.restoreCancelledQueue",
   agentChatRecoverTurn: "ade.agentChat.recoverTurn",
   agentChatRecoverCodexTurn: "ade.agentChat.recoverCodexTurn",
diff --git a/apps/desktop/src/shared/sessionStatusPresentation.test.ts b/apps/desktop/src/shared/sessionStatusPresentation.test.ts
index 64b0d757e..9a375eb7a 100644
--- a/apps/desktop/src/shared/sessionStatusPresentation.test.ts
+++ b/apps/desktop/src/shared/sessionStatusPresentation.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { sessionElapsedAnchor, sessionElapsedLabel } from "./sessionStatusPresentation";
+import { sessionElapsedAnchor, sessionElapsedLabel, sessionStatusPresentation } from "./sessionStatusPresentation";
 
 /**
  * `sessionElapsedAnchor` is the shared answer to "how long", read by the
@@ -66,3 +66,24 @@ describe("sessionElapsedAnchor", () => {
     expect(sessionElapsedAnchor(fresh, "ready", null)).toBe(base.startedAt);
   });
 });
+
+describe("sessionStatusPresentation usage-limit park", () => {
+  it("reads Parked instead of Waiting or Done while a usage-limit reset is in the future", () => {
+    const nowMs = Date.parse("2026-08-17T12:00:00.000Z");
+    const parked = sessionStatusPresentation("idle", {}, {
+      usageLimitParkedUntil: "2026-08-17T12:47:00.000Z",
+      nextWakeAt: "2026-08-17T12:10:00.000Z",
+      nowMs,
+    });
+    expect(parked).toMatchObject({ label: "Parked", tone: "neutral" });
+  });
+
+  it("does not park after the reset instant has passed", () => {
+    const nowMs = Date.parse("2026-08-17T13:00:00.000Z");
+    const done = sessionStatusPresentation("idle", {}, {
+      usageLimitParkedUntil: "2026-08-17T12:47:00.000Z",
+      nowMs,
+    });
+    expect(done?.label).not.toBe("Parked");
+  });
+});
diff --git a/apps/desktop/src/shared/sessionStatusPresentation.ts b/apps/desktop/src/shared/sessionStatusPresentation.ts
index 16d9781f4..af52b3ee3 100644
--- a/apps/desktop/src/shared/sessionStatusPresentation.ts
+++ b/apps/desktop/src/shared/sessionStatusPresentation.ts
@@ -144,6 +144,8 @@ export type SessionStatusActivityContext = {
   backgroundWork?: SessionBackgroundWork | null;
   nextWakeAt?: string | null;
   nowMs?: number;
+  /** ISO instant a usage-limit auto-resume is parked until. */
+  usageLimitParkedUntil?: string | null;
 };
 
 function countSuffix(count: number): string {
@@ -226,6 +228,19 @@ export function sessionStatusPresentation(
     };
   }
 
+  if ((phase === "ready" || phase === "idle") && activity.usageLimitParkedUntil) {
+    const parkedUntil = Date.parse(activity.usageLimitParkedUntil);
+    if (Number.isFinite(parkedUntil) && parkedUntil > (activity.nowMs ?? Date.now())) {
+      return {
+        label: "Parked",
+        tone: "neutral",
+        glyph: "waiting",
+        showsElapsed: false,
+        prominent: false,
+      };
+    }
+  }
+
   if ((phase === "ready" || phase === "idle") && activity.nextWakeAt) {
     const wakeAt = Date.parse(activity.nextWakeAt);
     if (Number.isFinite(wakeAt) && wakeAt > (activity.nowMs ?? Date.now())) {
diff --git a/apps/desktop/src/shared/syncMobileCompatibility.ts b/apps/desktop/src/shared/syncMobileCompatibility.ts
index cc343e7cf..2b4de9459 100644
--- a/apps/desktop/src/shared/syncMobileCompatibility.ts
+++ b/apps/desktop/src/shared/syncMobileCompatibility.ts
@@ -148,6 +148,7 @@ export const MOBILE_SYNC_REQUIRED_REMOTE_COMMAND_ACTIONS = [
   "chat.getChatEventHistory",
   "chat.send",
   "chat.interrupt",
+  "chat.stopTask",
   "chat.steer",
   "chat.cancelSteer",
   "chat.editSteer",
diff --git a/apps/desktop/src/shared/types/chat.ts b/apps/desktop/src/shared/types/chat.ts
index aaebeebc6..0c5a703b9 100644
--- a/apps/desktop/src/shared/types/chat.ts
+++ b/apps/desktop/src/shared/types/chat.ts
@@ -13,6 +13,8 @@ import type { SessionBackgroundWork } from "../sessionCanonicalState";
 import type { RuntimeProcessSummary } from "./sessions";
 import type { SubagentCapability } from "../subagentCapabilities";
 import { providerDisplayLabel } from "../pendingInputLabels";
+import type { AgentChatStopMode as CanonicalAgentChatStopMode } from "../chatStopModes";
+import type { ClaudeContextCategoryKind } from "../claudeContextUsage";
 
 export type AgentChatProvider =
   | "codex"
@@ -1954,6 +1956,11 @@ export type AgentChatSession = {
   mcpCapability?: AgentChatMcpCapability;
   acpPermissionMode?: AgentChatAcpPermissionMode;
   acpConfigSnapshot?: AgentChatAcpConfigSnapshot | null;
+  /**
+   * Wait out a claude.ai usage-limit reset and continue. Default on; explicit
+   * `false` is the per-chat opt-out. Subscription limits only, not API billing.
+   */
+  autoContinueAtUsageLimit?: boolean;
   /** Durable Cursor Cloud agent id once this session has been promoted to cloud. */
   cursorCloudAgentId?: string;
   /** Default runtime for new turns in this session (set on promotion). */
@@ -2028,6 +2035,13 @@ export type AgentChatSessionSummary = {
   mcpCapability?: AgentChatMcpCapability;
   acpPermissionMode?: AgentChatAcpPermissionMode;
   acpConfigSnapshot?: AgentChatAcpConfigSnapshot | null;
+  autoContinueAtUsageLimit?: boolean;
+  /**
+   * ISO instant this chat is parked waiting for a usage-limit reset. Distinct
+   * from `nextWakeAt` (any scheduled wake) so the session list can read Parked
+   * instead of Waiting / Done.
+   */
+  usageLimitParkedUntil?: string | null;
   cursorCloudAgentId?: string;
   cursorRuntime?: AgentChatRuntime;
   cursorPromotedTurnId?: string;
@@ -2214,6 +2228,9 @@ export type AgentChatContextUsageCategory = {
   percentage: number;
   color?: string;
   isDeferred?: boolean;
+  /** SDK `categories[].kind`. Classify by this, never by matching the name "free". */
+  kind?: ClaudeContextCategoryKind;
+  mcpServers?: Array<{ name: string; tokens: number }>;
 };
 
 export type AgentChatContextUsage = {
@@ -3519,7 +3536,7 @@ export type AgentChatCancelDispatchedSteerResult = {
   cancelled: boolean;
 };
 
-export type AgentChatStopMode = "stop_and_clear" | "stop_only";
+export type AgentChatStopMode = CanonicalAgentChatStopMode;
 
 export type AgentChatInterruptArgs = {
   sessionId: string;
@@ -3534,6 +3551,18 @@ export type AgentChatInterruptResult = {
   recoveryExpiresAt?: string;
 };
 
+export type AgentChatStopTaskArgs = {
+  sessionId: string;
+  taskId: string;
+};
+
+export type AgentChatStopTaskResult = {
+  sessionId: string;
+  taskId: string;
+  stopped: boolean;
+  reason?: string;
+};
+
 export type AgentChatRestoreCancelledQueueArgs = {
   sessionId: string;
   recoveryId: string;
@@ -3708,6 +3737,7 @@ export type AgentChatUpdateSessionArgs = {
   cursorConfigValues?: Record<string, AgentChatCursorConfigValue> | null;
   acpPermissionMode?: AgentChatAcpPermissionMode;
   acpConfigSnapshot?: AgentChatAcpConfigSnapshot | null;
+  autoContinueAtUsageLimit?: boolean;
 };
 
 export const AGENT_CHAT_SESSION_METADATA_FIELDS = ["title", "laneName", "statusLine"] as const;
diff --git a/apps/desktop/src/shared/types/personalChats.ts b/apps/desktop/src/shared/types/personalChats.ts
index d0539b5c5..ff53103ac 100644
--- a/apps/desktop/src/shared/types/personalChats.ts
+++ b/apps/desktop/src/shared/types/personalChats.ts
@@ -10,6 +10,7 @@ import type {
   AgentChatEventHistoryPage,
   AgentChatEventHistorySnapshot,
   AgentChatInterruptArgs,
+  AgentChatStopTaskArgs,
   AgentChatRestoreCancelledQueueArgs,
   AgentChatDispatchSteerArgs,
   AgentChatEditSteerArgs,
@@ -45,6 +46,7 @@ export const PERSONAL_CHAT_ACTIONS = [
   "cancelDispatchedSteer",
   "interrupt",
   "interruptWithQueueMode",
+  "stopTask",
   "restoreCancelledQueue",
   "recoverTurn",
   "resolveUnprocessedMessage",
@@ -125,6 +127,7 @@ export type PersonalChatCallArgs =
   | { action: "cancelDispatchedSteer"; args: AgentChatCancelDispatchedSteerArgs }
   | { action: "interrupt"; args: AgentChatInterruptArgs }
   | { action: "interruptWithQueueMode"; args: AgentChatInterruptArgs }
+  | { action: "stopTask"; args: AgentChatStopTaskArgs }
   | { action: "restoreCancelledQueue"; args: AgentChatRestoreCancelledQueueArgs }
   | { action: "recoverTurn"; args: AgentChatRecoverTurnArgs }
   | { action: "resolveUnprocessedMessage"; args: AgentChatResolveUnprocessedMessageArgs }
diff --git a/apps/desktop/src/shared/types/sessions.ts b/apps/desktop/src/shared/types/sessions.ts
index ae4928a24..df50169a8 100644
--- a/apps/desktop/src/shared/types/sessions.ts
+++ b/apps/desktop/src/shared/types/sessions.ts
@@ -309,6 +309,11 @@ export type TerminalSessionSummary = {
   chatIdleSinceAt?: string | null;
   /** Earliest armed, unpaused scheduled wake for chat-backed sessions. */
   nextWakeAt?: string | null;
+  /**
+   * ISO instant this chat is parked waiting for a usage-limit reset. Distinct
+   * from `nextWakeAt` so the session list can read Parked instead of Waiting.
+   */
+  usageLimitParkedUntil?: string | null;
   /** Current ADE-chat mode, projected for desktop Work-row presentation only. */
   chatActivityMode?: "planning" | null;
   /** Authoritative provider-reported background tasks still running after the foreground turn. */
diff --git a/apps/desktop/src/shared/types/sync.ts b/apps/desktop/src/shared/types/sync.ts
index 40ebeb6c7..cf50f9914 100644
--- a/apps/desktop/src/shared/types/sync.ts
+++ b/apps/desktop/src/shared/types/sync.ts
@@ -1897,6 +1897,7 @@ export type SyncRemoteCommandAction =
   | "chat.create"
   | "chat.send"
   | "chat.interrupt"
+  | "chat.stopTask"
   | "chat.recoverCodexTurn"
   | "chat.recoverTurn"
   | "chat.resolveUnprocessedMessage"
diff --git a/apps/ios/ADE/Models/RemoteModels.swift b/apps/ios/ADE/Models/RemoteModels.swift
index 870ad74f3..7d2e804cd 100644
--- a/apps/ios/ADE/Models/RemoteModels.swift
+++ b/apps/ios/ADE/Models/RemoteModels.swift
@@ -788,6 +788,8 @@ struct AgentChatScheduledWorkItem: Codable, Identifiable, Equatable {
   var cancellable: Bool
   var late: Bool?
   var outcomeSummary: String?
+  /// Provenance for rows ADE armed itself. Older hosts omit it.
+  var source: String? = nil
 }
 
 struct AgentChatCancelScheduledWorkResult: Codable, Equatable {
@@ -892,6 +894,12 @@ struct AgentChatSessionSummary: Codable, Identifiable, Equatable {
   var scheduledWorkPaused: Bool? = nil
   /// Earliest armed, unpaused wake reported by the host. Older hosts omit it.
   var nextWakeAt: String? = nil
+  /// Claude SDK auto-continue after a claude.ai usage-limit reset. Older hosts omit it.
+  var autoContinueAtUsageLimit: Bool? = nil
+  /// ISO instant this chat is parked waiting for a usage-limit reset. Older hosts omit it.
+  var usageLimitParkedUntil: String? = nil
+  /// Live background tasks still running after the foreground turn. Older hosts omit it.
+  var activeBackgroundTaskCount: Int? = nil
   var threadId: String?
   var requestedCwd: String?
   // Orchestration-mode fields (populated when session is part of an orchestration run)
@@ -955,6 +963,9 @@ struct AgentChatSessionSummary: Codable, Identifiable, Equatable {
       && lhs.scheduledWork == rhs.scheduledWork
       && lhs.scheduledWorkPaused == rhs.scheduledWorkPaused
       && lhs.nextWakeAt == rhs.nextWakeAt
+      && lhs.autoContinueAtUsageLimit == rhs.autoContinueAtUsageLimit
+      && lhs.usageLimitParkedUntil == rhs.usageLimitParkedUntil
+      && lhs.activeBackgroundTaskCount == rhs.activeBackgroundTaskCount
       && lhs.threadId == rhs.threadId
       && lhs.requestedCwd == rhs.requestedCwd
       && lhs.orchestrationRunId == rhs.orchestrationRunId
@@ -2116,6 +2127,8 @@ struct AgentChatContextUsageCategory: Codable, Equatable {
   var percentage: Double
   var color: String?
   var isDeferred: Bool?
+  /// SDK `categories[].kind`. Classify by this, never by matching the name "free".
+  var kind: String?
 }
 
 struct AgentChatContextUsage: Codable, Equatable {
@@ -3591,9 +3604,11 @@ struct AgentChatCancelDispatchedSteerRequest: Codable, Equatable {
   var steerId: String
 }
 
-enum AgentChatStopMode: String, Codable, Equatable {
-  case stopAndClear = "stop_and_clear"
+enum AgentChatStopMode: String, Codable, Equatable, Hashable, CaseIterable {
   case stopOnly = "stop_only"
+  case stopAndClear = "stop_and_clear"
+  case stopAndBackground = "stop_and_background"
+  case stopAndClearAndBackground = "stop_and_clear_and_background"
 }
 
 struct AgentChatInterruptRequest: Codable, Equatable {
@@ -3601,6 +3616,11 @@ struct AgentChatInterruptRequest: Codable, Equatable {
   var mode: AgentChatStopMode? = nil
 }
 
+struct AgentChatStopTaskRequest: Codable, Equatable {
+  var sessionId: String
+  var taskId: String
+}
+
 struct AgentChatHandoffRequest: Codable, Equatable {
   var sourceSessionId: String
   var targetModelId: String
@@ -3695,6 +3715,7 @@ struct AgentChatUpdateSessionRequest: Codable, Equatable {
   var manuallyNamed: Bool?
   var spawnKind: String?
   var subagentTakeoverPromptShown: Bool?
+  var autoContinueAtUsageLimit: Bool?
 }
 
 struct AgentChatTranscriptEntry: Codable, Identifiable, Equatable {
diff --git a/apps/ios/ADE/Services/SyncService.swift b/apps/ios/ADE/Services/SyncService.swift
index c9d652438..5caaed336 100644
--- a/apps/ios/ADE/Services/SyncService.swift
+++ b/apps/ios/ADE/Services/SyncService.swift
@@ -13407,6 +13407,18 @@ final class SyncService: ObservableObject {
     )
   }
 
+  func stopChatTask(sessionId: String, taskId: String) async throws {
+    let action = chatActionName("chat.stopTask", sessionId: sessionId)
+    try requireInvokableRemoteAction(action)
+    let scope = chatCommandScope(for: sessionId)
+    _ = try await sendChatCommand(
+      action: action,
+      payload: AgentChatStopTaskRequest(sessionId: sessionId, taskId: taskId),
+      targetProjectId: scope.projectId,
+      targetProjectRootPath: scope.rootPath
+    )
+  }
+
   func handoffChatSession(
     sourceSessionId: String,
     targetModelId: String,
@@ -13860,7 +13872,8 @@ final class SyncService: ObservableObject {
     computerUse: RemoteJSONValue? = nil,
     manuallyNamed: Bool? = nil,
     spawnKind: String? = nil,
-    subagentTakeoverPromptShown: Bool? = nil
+    subagentTakeoverPromptShown: Bool? = nil,
+    autoContinueAtUsageLimit: Bool? = nil
   ) async throws -> AgentChatSession {
     let scope = chatCommandScope(for: sessionId)
     return try await sendDecodableChatCommand(
@@ -13885,7 +13898,8 @@ final class SyncService: ObservableObject {
         computerUse: computerUse,
         manuallyNamed: manuallyNamed,
         spawnKind: spawnKind,
-        subagentTakeoverPromptShown: subagentTakeoverPromptShown
+        subagentTakeoverPromptShown: subagentTakeoverPromptShown,
+        autoContinueAtUsageLimit: autoContinueAtUsageLimit
       ),
       targetProjectId: scope.projectId,
       targetProjectRootPath: scope.rootPath,
diff --git a/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift b/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift
index 780cbf76e..1c1522e44 100644
--- a/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift
+++ b/apps/ios/ADE/Views/Work/WorkChatRichCardViews.swift
@@ -2893,6 +2893,7 @@ struct WorkChatInfoDetailsSheet: View {
   let onSelect: @MainActor (WorkSubagentSnapshot) async -> Void
   let onCancelScheduledWork: (@MainActor (WorkScheduledWorkSnapshot) async -> Void)?
   let onSetScheduledWorkPaused: (@MainActor (Bool) async -> Void)?
+  var onStopTask: (@MainActor (String) async -> Void)? = nil
   @AppStorage private var paneUiRaw: String
   @AppStorage private var paneClearedRaw: String
   @State private var showAllSections: Set<String> = []
@@ -2920,7 +2921,8 @@ struct WorkChatInfoDetailsSheet: View {
     sessionModel: String? = nil,
     onSelect: @escaping @MainActor (WorkSubagentSnapshot) async -> Void,
     onCancelScheduledWork: (@MainActor (WorkScheduledWorkSnapshot) async -> Void)? = nil,
-    onSetScheduledWorkPaused: (@MainActor (Bool) async -> Void)? = nil
+    onSetScheduledWorkPaused: (@MainActor (Bool) async -> Void)? = nil,
+    onStopTask: (@MainActor (String) async -> Void)? = nil
   ) {
     self.sessionId = sessionId
     self.subagentSnapshots = subagentSnapshots
@@ -2935,6 +2937,7 @@ struct WorkChatInfoDetailsSheet: View {
     self.onSelect = onSelect
     self.onCancelScheduledWork = onCancelScheduledWork
     self.onSetScheduledWorkPaused = onSetScheduledWorkPaused
+    self.onStopTask = onStopTask
     self._paneUiRaw = AppStorage(
       wrappedValue: #"{"collapsed":{},"earlier":{}}"#,
       "ade.chat.paneUi.v1:\(sessionId)"
@@ -3183,7 +3186,15 @@ struct WorkChatInfoDetailsSheet: View {
                 clearedCount: backgroundPartition.clearedCount,
                 allClear: backgroundPartition.active.isEmpty && backgroundPartition.earlier.isEmpty && backgroundPartition.clearedCount > 0
               ) {
-                scalableSectionBody(title: "Background", sectionKey: "background", spacing: 8, partition: backgroundPartition, visible: visibleBackground) { item, _ in WorkBackgroundWorkRow(item: item) }
+                scalableSectionBody(title: "Background", sectionKey: "background", spacing: 8, partition: backgroundPartition, visible: visibleBackground) { item, _ in
+                  WorkBackgroundWorkRow(
+                    item: item,
+                    onStop: onStopTask.flatMap { stop in
+                      guard workBackgroundCanStopTask(item), let taskId = item.sourceTaskId else { return nil }
+                      return { Task { await stop(taskId) } }
+                    }
+                  )
+                }
               }
             }
             if !scheduleItems.isEmpty {
@@ -3245,7 +3256,11 @@ struct WorkChatInfoDetailsSheet: View {
       expanded: expandedTaskIds.contains(snapshot.taskId),
       sessionModel: sessionModel,
       treePrefix: workSubagentTreePrefix(snapshot, in: subagents),
-      onSelect: { Task { await onSelect(snapshot) } }
+      onSelect: { Task { await onSelect(snapshot) } },
+      onStop: onStopTask.flatMap { stop in
+        guard workSubagentCanStopTask(snapshot) else { return nil }
+        return { Task { await stop(snapshot.taskId) } }
+      }
     )
   }
 
@@ -3377,6 +3392,30 @@ struct WorkChatInfoDetailsSheet: View {
 /// A single subagent roster row inside Chat Info. Reuses the drawer row shape
 /// (glyph, name, subtitle, status chip, expandable detail). Background agents
 /// get a small "background" chip.
+private struct WorkSquareStopButton: View {
+  let label: String
+  let action: () -> Void
+
+  var body: some View {
+    Button(action: action) {
+      Image(systemName: "stop.fill")
+        .font(.system(size: 9, weight: .bold))
+        .foregroundStyle(ADEColor.danger.opacity(0.85))
+        .frame(width: 28, height: 28)
+        .background(
+          RoundedRectangle(cornerRadius: 6, style: .continuous)
+            .fill(ADEColor.danger.opacity(0.08))
+        )
+        .overlay {
+          RoundedRectangle(cornerRadius: 6, style: .continuous)
+            .stroke(ADEColor.danger.opacity(0.25), lineWidth: 1)
+        }
+    }
+    .buttonStyle(.plain)
+    .accessibilityLabel(label)
+  }
+}
+
 private struct WorkChatInfoSubagentRow: View {
   let snapshot: WorkSubagentSnapshot
   let selected: Bool
@@ -3385,6 +3424,7 @@ private struct WorkChatInfoSubagentRow: View {
   let sessionModel: String?
   var treePrefix: String = ""
   let onSelect: () -> Void
+  var onStop: (() -> Void)? = nil
 
   @State private var filesOpen = false
 
@@ -3472,6 +3512,13 @@ private struct WorkChatInfoSubagentRow: View {
         )
       }
       .buttonStyle(.plain)
+      .overlay(alignment: .topTrailing) {
+        if let onStop {
+          WorkSquareStopButton(label: workSubagentStopLabel(snapshot), action: onStop)
+            .padding(.top, 8)
+            .padding(.trailing, 8)
+        }
+      }
 
       if !filePaths.isEmpty {
         VStack(alignment: .leading, spacing: 4) {
@@ -3562,6 +3609,7 @@ private struct WorkChatInfoSubagentRow: View {
 /// dim cwd chip when the command carried a leading `cd <path> &&`.
 private struct WorkBackgroundWorkRow: View {
   let item: WorkScheduledWorkSnapshot
+  var onStop: (() -> Void)? = nil
 
   @State private var expanded = false
 
@@ -3624,6 +3672,13 @@ private struct WorkBackgroundWorkRow: View {
       )
     }
     .buttonStyle(.plain)
+    .overlay(alignment: .topTrailing) {
+      if let onStop {
+        WorkSquareStopButton(label: "Stop \(item.title)", action: onStop)
+          .padding(.top, 8)
+          .padding(.trailing, 8)
+      }
+    }
   }
 }
 
@@ -3937,6 +3992,7 @@ struct WorkSubagentTimelineRowView: View {
   /// Tapping a real spawn/result row opens the subagent detail/transcript, the
   /// same surface the Chat Info roster row opens. Background chips are inert.
   let onOpen: (@MainActor (WorkSubagentSnapshot) async -> Void)?
+  var onStop: (@MainActor (WorkSubagentSnapshot) async -> Void)? = nil
 
   var body: some View {
     switch row.kind {
@@ -3944,11 +4000,22 @@ struct WorkSubagentTimelineRowView: View {
       WorkSubagentBackgroundChipRow(row: row)
     case .spawn:
       tappable { WorkSubagentSpawnRow(row: row) }
+        .overlay(alignment: .trailing) {
+          if let spawnStopAction {
+            WorkSquareStopButton(label: workSubagentStopLabel(row.snapshot), action: spawnStopAction)
+              .padding(.trailing, 12)
+          }
+        }
     case .result:
       tappable { WorkSubagentResultRow(row: row) }
     }
   }
 
+  private var spawnStopAction: (() -> Void)? {
+    guard let onStop, workSubagentCanStopTask(row.snapshot) else { return nil }
+    return { Task { await onStop(row.snapshot) } }
+  }
+
   @ViewBuilder
   private func tappable<Content: View>(@ViewBuilder _ content: () -> Content) -> some View {
     if let onOpen {
diff --git a/apps/ios/ADE/Views/Work/WorkChatSessionView+Timeline.swift b/apps/ios/ADE/Views/Work/WorkChatSessionView+Timeline.swift
index 89b1be4fe..c6e4ce6fe 100644
--- a/apps/ios/ADE/Views/Work/WorkChatSessionView+Timeline.swift
+++ b/apps/ios/ADE/Views/Work/WorkChatSessionView+Timeline.swift
@@ -198,7 +198,13 @@ extension WorkChatSessionView {
       )
       .equatable()
     case .subagent(let row):
-      WorkSubagentTimelineRowView(row: row, onOpen: onSelectSubagentRow)
+      WorkSubagentTimelineRowView(
+        row: row,
+        onOpen: onSelectSubagentRow,
+        onStop: onStopSubagentTask.map { stop in
+          { snapshot in await stop(snapshot.taskId) }
+        }
+      )
     case .subagentStoppedGroup(let model):
       WorkSubagentStoppedGroupCardView(
         model: model,
diff --git a/apps/ios/ADE/Views/Work/WorkChatSessionView.swift b/apps/ios/ADE/Views/Work/WorkChatSessionView.swift
index 0e7cc8a2c..5151d3254 100644
--- a/apps/ios/ADE/Views/Work/WorkChatSessionView.swift
+++ b/apps/ios/ADE/Views/Work/WorkChatSessionView.swift
@@ -512,6 +512,9 @@ struct WorkChatSummaryRenderContext: Equatable {
   /// that can rescue a pending-input card the transcript swept without a
   /// `pending_input_resolved` receipt — see `WorkPendingInputQueue.resolved(_:)`.
   let pendingInputItemId: String?
+  let activeBackgroundTaskCount: Int?
+  let showsUsageLimitOptOut: Bool
+  let usageLimitResetLabel: String
 
   init(_ summary: AgentChatSessionSummary?, parentTitle: String? = nil) {
     guard let summary else {
@@ -535,6 +538,9 @@ struct WorkChatSummaryRenderContext: Equatable {
       self.subagentTakeoverPromptShownAt = nil
       self.parentTitle = nil
       self.pendingInputItemId = nil
+      self.activeBackgroundTaskCount = nil
+      self.showsUsageLimitOptOut = false
+      self.usageLimitResetLabel = ""
       return
     }
 
@@ -558,6 +564,16 @@ struct WorkChatSummaryRenderContext: Equatable {
     self.subagentTakeoverPromptShownAt = summary.subagentTakeoverPromptShownAt
     self.parentTitle = parentTitle
     self.pendingInputItemId = summary.pendingInputItemId
+    self.activeBackgroundTaskCount = summary.activeBackgroundTaskCount
+    self.showsUsageLimitOptOut = WorkUsageLimitOptOut.shouldShow(
+      autoContinueAtUsageLimit: summary.autoContinueAtUsageLimit,
+      usageLimitParkedUntil: summary.usageLimitParkedUntil,
+      scheduledWork: summary.scheduledWork
+    )
+    self.usageLimitResetLabel = WorkUsageLimitOptOut.resetLabel(
+      usageLimitParkedUntil: summary.usageLimitParkedUntil,
+      scheduledWork: summary.scheduledWork
+    )
   }
 
   var currentModelId: String {
@@ -704,6 +720,8 @@ struct WorkChatSessionView: View {
   let onSend: @MainActor (String, [WorkChatInputAttachment], WorkActiveSendMode) async -> Bool
   let onInterrupt: @MainActor (AgentChatStopMode) async -> Void
   let onRestoreCancelledQueue: (@MainActor (String) async -> Void)?
+  var onOptOutUsageLimitAutoContinue: (@MainActor () async -> Void)? = nil
+  var onStopSubagentTask: (@MainActor (String) async -> Void)? = nil
   let onApproveRequest: @MainActor (String, AgentChatApprovalDecision, String?) async -> Void
   let onRespondToQuestion: @MainActor (String, String, AgentChatInputAnswerValue?, String?) async -> Void
   let onSubmitQuestionAnswers: @MainActor (String, [String: AgentChatInputAnswerValue], String?) async -> Void
@@ -1664,6 +1682,20 @@ struct WorkChatSessionView: View {
         )
       }
 
+      if chatSummaryContext.showsUsageLimitOptOut,
+         let onOptOutUsageLimitAutoContinue {
+        WorkUsageLimitBanner(
+          resetLabel: chatSummaryContext.usageLimitResetLabel,
+          optingOut: actionInFlight,
+          enabled: !hostUnreachable && !actionInFlight,
+          onOptOut: {
+            await runSessionAction {
+              await onOptOutUsageLimitAutoContinue()
+            }
+          }
+        )
+      }
+
       if chatSummaryContext.spawnKind == .subagent,
          let parentId = chatSummaryContext.orchestrationParentSessionId,
          !parentId.isEmpty,
@@ -3251,9 +3283,8 @@ private struct WorkChatComposerDraftInput: View {
     // failed-send restore that runs first would be preserved either way, but
     // binding first keeps the persisted key correct for the very first autosave.
     .task(id: draftPersistenceKey) {
-      stopMode = UserDefaults.standard.string(forKey: "\(draftPersistenceKey).stopMode") == AgentChatStopMode.stopOnly.rawValue
-        ? .stopOnly
-        : .stopAndClear
+      stopMode = AgentChatStopMode(rawValue: UserDefaults.standard.string(forKey: "\(draftPersistenceKey).stopMode") ?? "")
+        ?? WorkChatStopCapability.defaultMode
       restoreActiveSendMode()
       sendOptionsPresented = false
       stopOptionsPresented = false
@@ -3469,7 +3500,9 @@ private struct WorkChatComposerDraftInput: View {
             .frame(width: 32, height: 32)
         }
         .buttonStyle(.plain)
-        .accessibilityLabel(stopMode == .stopOnly ? "Stop turn and keep queue" : "Stop turn and clear queue")
+        .accessibilityLabel(WorkChatStopCapability.copy(mode: stopMode, jobCount: chatSummary.activeBackgroundTaskCount ?? 0).title)
+        .accessibilityValue(WorkChatStopCapability.copy(mode: stopMode, jobCount: chatSummary.activeBackgroundTaskCount ?? 0).title)
+        .accessibilityHint("Choose whether the turn, queue, and background jobs are stopped")
         .disabled(interruptInFlight)
 
         Button {
@@ -3482,26 +3515,25 @@ private struct WorkChatComposerDraftInput: View {
         }
         .buttonStyle(.plain)
         .accessibilityLabel("More stop options")
-        .accessibilityValue(stopMode == .stopOnly ? "Stop only" : "Stop and clear queue")
-        .accessibilityHint("Choose whether queued Claude messages are kept or cancelled")
+        .accessibilityValue(WorkChatStopCapability.copy(mode: stopMode, jobCount: chatSummary.activeBackgroundTaskCount ?? 0).title)
+        .accessibilityHint("Choose whether the turn, queue, and background jobs are stopped")
         .disabled(interruptInFlight)
         .popover(isPresented: $stopOptionsPresented, arrowEdge: .bottom) {
+          let jobCount = chatSummary.activeBackgroundTaskCount ?? 0
           VStack(alignment: .leading, spacing: 0) {
-            stopOption(
-              mode: .stopAndClear,
-              title: "Stop & clear queue",
-              detail: "Stop this turn and cancel staged Claude messages.",
-              systemImage: "trash"
-            )
-            Divider()
-            stopOption(
-              mode: .stopOnly,
-              title: "Stop only",
-              detail: "Stop this turn and keep staged messages.",
-              systemImage: "stop.fill"
-            )
+            ForEach(Array(WorkChatStopCapability.modes.enumerated()), id: \.element) { index, mode in
+              if index > 0 {
+                Divider().padding(.horizontal, 12)
+              }
+              stopOption(
+                mode: mode,
+                title: WorkChatStopCapability.copy(mode: mode, jobCount: jobCount).title,
+                detail: WorkChatStopCapability.copy(mode: mode, jobCount: jobCount).detail,
+                systemImage: WorkChatStopCapability.systemImage(for: mode)
+              )
+            }
           }
-          .frame(width: 260)
+          .frame(width: 300)
           .presentationCompactAdaptation(.popover)
         }
       }
@@ -3597,10 +3629,16 @@ private struct WorkChatComposerDraftInput: View {
         .controlSize(.mini)
         .tint(ADEColor.danger)
     } else if stopMode == .stopOnly {
-      Image(systemName: "stop.fill")
+      Image(systemName: WorkChatStopCapability.systemImage(for: .stopOnly))
         .font(.system(size: 10, weight: .bold))
+    } else if stopMode == .stopAndBackground {
+      Image(systemName: WorkChatStopCapability.systemImage(for: .stopAndBackground))
+        .font(.system(size: 10, weight: .bold))
+    } else if stopMode == .stopAndClearAndBackground {
+      Image(systemName: WorkChatStopCapability.systemImage(for: .stopAndClearAndBackground))
+        .font(.system(size: 11, weight: .bold))
     } else {
-      Image(systemName: "trash")
+      Image(systemName: WorkChatStopCapability.systemImage(for: .stopAndClear))
         .font(.system(size: 11, weight: .bold))
     }
   }
@@ -3712,6 +3750,64 @@ private struct WorkSubagentLineageBreadcrumb: View {
   }
 }
 
+private struct WorkUsageLimitBanner: View {
+  let resetLabel: String
+  let optingOut: Bool
+  let enabled: Bool
+  let onOptOut: @MainActor () async -> Void
+
+  var body: some View {
+    VStack(alignment: .leading, spacing: 8) {
+      Text("Usage limit reached")
+        .font(.caption.weight(.semibold))
+        .foregroundStyle(ADEColor.textPrimary)
+      if !resetLabel.isEmpty {
+        Text(resetLabel)
+          .font(.caption)
+          .foregroundStyle(ADEColor.textSecondary)
+      }
+      Text("Continue automatically")
+        .font(.caption)
+        .foregroundStyle(ADEColor.textSecondary)
+      HStack {
+        Spacer(minLength: 4)
+        Button {
+          Task { await onOptOut() }
+        } label: {
+          Group {
+            if optingOut {
+              ProgressView()
+                .controlSize(.small)
+            } else {
+              Text("Don't continue")
+                .font(.caption.weight(.semibold))
+            }
+          }
+          .frame(minWidth: 44, minHeight: 44)
+          .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+        .foregroundStyle(ADEColor.accent)
+        .disabled(!enabled)
+        .accessibilityLabel(
+          optingOut
+            ? "Opting out of automatic continue"
+            : (enabled ? "Don't continue" : "Don't continue unavailable")
+        )
+        .accessibilityHint("Stops this chat from resuming when the usage limit resets")
+      }
+    }
+    .padding(.leading, 12)
+    .padding(.trailing, 4)
+    .padding(.vertical, 8)
+    .background(ADEColor.warning.opacity(0.07), in: RoundedRectangle(cornerRadius: 10, style: .continuous))
+    .overlay {
+      RoundedRectangle(cornerRadius: 10, style: .continuous)
+        .stroke(ADEColor.warning.opacity(0.18), lineWidth: 1)
+    }
+  }
+}
+
 private struct WorkQueueRecoveryBanner: View {
   let recovery: WorkQueueRecoveryModel
   let restoring: Bool
diff --git a/apps/ios/ADE/Views/Work/WorkErrorAndMessageHelpers.swift b/apps/ios/ADE/Views/Work/WorkErrorAndMessageHelpers.swift
index 5960b8365..d7561dd99 100644
--- a/apps/ios/ADE/Views/Work/WorkErrorAndMessageHelpers.swift
+++ b/apps/ios/ADE/Views/Work/WorkErrorAndMessageHelpers.swift
@@ -22,7 +22,7 @@ func errorPresentation(for category: String) -> WorkErrorPresentation {
   case "auth":
     return WorkErrorPresentation(title: "Authentication issue", icon: "lock.trianglebadge.exclamationmark", tint: .danger)
   case "rate_limit":
-    return WorkErrorPresentation(title: "Rate limited", icon: "hourglass", tint: .warning)
+    return WorkErrorPresentation(title: "Usage limit reached", icon: "hourglass", tint: .warning)
   case "network":
     return WorkErrorPresentation(title: "Connection issue", icon: "wifi.exclamationmark", tint: .warning)
   case "permission":
diff --git a/apps/ios/ADE/Views/Work/WorkModels.swift b/apps/ios/ADE/Views/Work/WorkModels.swift
index 808b3a585..b9f7cd8fc 100644
--- a/apps/ios/ADE/Views/Work/WorkModels.swift
+++ b/apps/ios/ADE/Views/Work/WorkModels.swift
@@ -464,6 +464,116 @@ struct WorkActiveSendCapability: Equatable {
   }
 }
 
+/// Hand mirror of desktop `chatStopModes.ts`. iOS cannot import the TS table,
+/// so the two stay in step by this struct plus `testWorkChatStopCapabilityMirrorsDesktopStopMatrix`.
+struct WorkChatStopCapability: Equatable {
+  static let modes: [AgentChatStopMode] = [
+    .stopOnly,
+    .stopAndClear,
+    .stopAndBackground,
+    .stopAndClearAndBackground,
+  ]
+  static let defaultMode: AgentChatStopMode = .stopAndClear
+
+  static func copy(mode: AgentChatStopMode, jobCount: Int) -> (title: String, detail: String) {
+    let jobs = jobCount == 1 ? "1 job" : "\(max(0, jobCount)) jobs"
+    switch mode {
+    case .stopOnly:
+      return (
+        "Turn only",
+        "Stop the active turn. Keep queued messages and background jobs."
+      )
+    case .stopAndClear:
+      return (
+        "Turn + queue",
+        "Stop the active turn and cancel queued messages. Background jobs keep running."
+      )
+    case .stopAndBackground:
+      return (
+        "Turn + background (\(jobs))",
+        "Stop the active turn and stop \(jobs). Keep queued messages."
+      )
+    case .stopAndClearAndBackground:
+      return (
+        "Turn + queue + background (\(jobs))",
+        "Stop the active turn, cancel queued messages, and stop \(jobs)."
+      )
+    }
+  }
+
+  static func systemImage(for mode: AgentChatStopMode) -> String {
+    switch mode {
+    case .stopOnly: return "stop.fill"
+    case .stopAndClear: return "trash"
+    case .stopAndBackground: return "square.fill"
+    case .stopAndClearAndBackground: return "xmark.square.fill"
+    }
+  }
+}
+
+/// Hand mirror of desktop `chatAutoResume.ts` usage-limit opt-out. iOS cannot
+/// import the TS predicates, so this struct plus `testWorkUsageLimitOptOut*`
+/// keep the parked banner and Don’t-continue action aligned with desktop.
+struct WorkUsageLimitOptOut: Equatable {
+  static func isPendingAutoResume(_ item: AgentChatScheduledWorkItem) -> Bool {
+    guard item.source == "auto_resume_limit" else { return false }
+    switch item.status {
+    case "done", "completed", "cancelled": return false
+    default: return true
+    }
+  }
+
+  static func shouldShow(
+    autoContinueAtUsageLimit: Bool?,
+    usageLimitParkedUntil: String?,
+    scheduledWork: [AgentChatScheduledWorkItem]?,
+    now: Date = Date()
+  ) -> Bool {
+    if autoContinueAtUsageLimit == false { return false }
+    if let parkedUntil = usageLimitParkedUntil,
+       let parkedDate = workParsedDate(parkedUntil),
+       parkedDate > now {
+      return true
+    }
+    return (scheduledWork ?? []).contains(where: isPendingAutoResume)
+  }
+
+  static func pendingSchedule(_ scheduledWork: [AgentChatScheduledWorkItem]?) -> AgentChatScheduledWorkItem? {
+    scheduledWork?.first(where: isPendingAutoResume)
+  }
+
+  static func resetLabel(
+    usageLimitParkedUntil: String?,
+    scheduledWork: [AgentChatScheduledWorkItem]?,
+    now: Date = Date()
+  ) -> String {
+    workUsageLimitResetLabel(
+      usageLimitParkedUntil ?? pendingSchedule(scheduledWork)?.nextRunAt,
+      now: now
+    )
+  }
+}
+
+/// Native Claude Task subagents can be stopped one-at-a-time. Spawned ADE chats
+/// use a `chat:` task id and keep their own session stop control.
+func workSubagentCanStopTask(_ snapshot: WorkSubagentSnapshot) -> Bool {
+  guard snapshot.status == .running else { return false }
+  let taskId = snapshot.taskId.trimmingCharacters(in: .whitespacesAndNewlines)
+  guard !taskId.isEmpty, !taskId.hasPrefix("chat:") else { return false }
+  return true
+}
+
+func workSubagentStopLabel(_ snapshot: WorkSubagentSnapshot) -> String {
+  let type = snapshot.agentType?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+  if !type.isEmpty { return "Stop \(type)" }
+  return "Stop \(workSubagentMeaningfulName(snapshot))"
+}
+
+func workBackgroundCanStopTask(_ item: WorkScheduledWorkSnapshot) -> Bool {
+  item.status.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == "running"
+    && !(item.sourceTaskId?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ?? true)
+}
+
 struct WorkQueueRecoveryModel: Equatable {
   let recoveryId: String
   let messageCount: Int
diff --git a/apps/ios/ADE/Views/Work/WorkSessionCanonicalState.swift b/apps/ios/ADE/Views/Work/WorkSessionCanonicalState.swift
index 97faae30b..4c8cf2db5 100644
--- a/apps/ios/ADE/Views/Work/WorkSessionCanonicalState.swift
+++ b/apps/ios/ADE/Views/Work/WorkSessionCanonicalState.swift
@@ -455,7 +455,13 @@ func workSessionRowPresentation(
     phase: phase,
     badge: badge,
     tone: resolved.presentation.tone,
-    status: workSessionStatusSlot(session: session, phase: phase, resolved: resolved, now: now)
+    status: workSessionStatusSlot(
+      session: session,
+      phase: phase,
+      resolved: resolved,
+      now: now,
+      parkedUntil: summary?.usageLimitParkedUntil
+    )
   )
 }
 
@@ -483,7 +489,8 @@ private func workSessionStatusSlot(
   session: TerminalSessionSummary,
   phase: CanonicalSessionPhase,
   resolved: (kind: SessionBadgeKind?, presentation: ActivityPhasePresentation),
-  now: Date
+  now: Date,
+  parkedUntil: String?
 ) -> WorkSessionStatusPresentation? {
   // needsYou skips the overlay gate entirely and falls straight through to the
   // phase table below, which already says "Needs you" in amber.
@@ -517,6 +524,20 @@ private func workSessionStatusSlot(
     if phase == .settled { return nil }
   }
 
+  if (phase == .ready || phase == .idle),
+     let parkedUntil,
+     let parkedDate = workParsedDate(parkedUntil),
+     parkedDate > now {
+    return WorkSessionStatusPresentation(
+      label: "Parked",
+      tone: .neutral,
+      glyph: .waiting,
+      showsElapsed: false,
+      prominent: false,
+      kind: nil
+    )
+  }
+
   return WorkSessionStatusPresentation(
     label: resolved.presentation.label,
     tone: resolved.presentation.tone,
diff --git a/apps/ios/ADE/Views/Work/WorkSessionDestinationView+Actions.swift b/apps/ios/ADE/Views/Work/WorkSessionDestinationView+Actions.swift
index 899861c0e..02f34aa56 100644
--- a/apps/ios/ADE/Views/Work/WorkSessionDestinationView+Actions.swift
+++ b/apps/ios/ADE/Views/Work/WorkSessionDestinationView+Actions.swift
@@ -253,6 +253,37 @@ extension WorkSessionDestinationView {
     }
   }
 
+  @MainActor
+  func optOutUsageLimitAutoContinue() async {
+    do {
+      if let schedule = WorkUsageLimitOptOut.pendingSchedule(chatSummary?.scheduledWork),
+         syncService.canInvokeChatRemoteAction("chat.cancelScheduledWork", sessionId: sessionId) {
+        _ = try? await syncService.cancelScheduledWork(sessionId: sessionId, scheduleId: schedule.id)
+      }
+      _ = try await syncService.updateChatSession(
+        sessionId: sessionId,
+        autoContinueAtUsageLimit: false
+      )
+      await refreshChatStateAfterAction(forceRemote: true)
+      errorMessage = nil
+    } catch {
+      ADEHaptics.error()
+      errorMessage = error.localizedDescription
+    }
+  }
+
+  @MainActor
+  func stopChatTask(taskId: String) async {
+    do {
+      try await syncService.stopChatTask(sessionId: sessionId, taskId: taskId)
+      await refreshChatStateAfterAction(forceRemote: true)
+      errorMessage = nil
+    } catch {
+      ADEHaptics.error()
+      errorMessage = error.localizedDescription
+    }
+  }
+
   @MainActor
   func recoverCodexTurn(sessionId targetSessionId: String, turnId: String, action: String) async throws -> String {
     let result = try await syncService.recoverCodexTurn(
diff --git a/apps/ios/ADE/Views/Work/WorkSessionDestinationView.swift b/apps/ios/ADE/Views/Work/WorkSessionDestinationView.swift
index d442ca471..d4dd476eb 100644
--- a/apps/ios/ADE/Views/Work/WorkSessionDestinationView.swift
+++ b/apps/ios/ADE/Views/Work/WorkSessionDestinationView.swift
@@ -1305,6 +1305,15 @@ struct WorkSessionDestinationView: View {
     }
   }
 
+  private var stopTaskAction: (@MainActor (String) async -> Void)? {
+    guard syncService.canInvokeChatRemoteAction("chat.stopTask", sessionId: sessionId) else {
+      return nil
+    }
+    return { taskId in
+      await stopChatTask(taskId: taskId)
+    }
+  }
+
   @MainActor
   private func setScheduledWorkPausedOptimistically(_ paused: Bool) async {
     let previousSummary = composerChatSummary
@@ -1359,7 +1368,8 @@ struct WorkSessionDestinationView: View {
           sessionModel: composerChatSummary?.model,
           onSelect: handleSubagentSelection,
           onCancelScheduledWork: scheduledWorkCancelAction,
-          onSetScheduledWorkPaused: scheduledWorkPauseAction
+          onSetScheduledWorkPaused: scheduledWorkPauseAction,
+          onStopTask: stopTaskAction
         )
         .presentationDetents([.medium, .large])
         .presentationDragIndicator(.visible)
@@ -1795,6 +1805,8 @@ struct WorkSessionDestinationView: View {
       },
       onInterrupt: interruptSession,
       onRestoreCancelledQueue: restoreCancelledQueueAction,
+      onOptOutUsageLimitAutoContinue: optOutUsageLimitAutoContinue,
+      onStopSubagentTask: stopTaskAction,
       onApproveRequest: approveRequest,
       onRespondToQuestion: respondToQuestion,
       onSubmitQuestionAnswers: submitQuestionAnswers,
diff --git a/apps/ios/ADE/Views/Work/WorkStatusAndFormattingHelpers.swift b/apps/ios/ADE/Views/Work/WorkStatusAndFormattingHelpers.swift
index c41d88428..dd9878914 100644
--- a/apps/ios/ADE/Views/Work/WorkStatusAndFormattingHelpers.swift
+++ b/apps/ios/ADE/Views/Work/WorkStatusAndFormattingHelpers.swift
@@ -1417,6 +1417,22 @@ func relativeTimestamp(_ value: String) -> String {
   return RelativeDateTimeFormatter().localizedString(for: date, relativeTo: Date())
 }
 
+/// Clock-only usage-limit label matching desktop `formatUsageLimitResetLabel`
+/// ("Reset at 3:40 PM (47 min)"). Omits the remaining window after the reset.
+func workUsageLimitResetLabel(_ iso: String?, now: Date = Date()) -> String {
+  guard let iso, let date = workParsedDate(iso) else { return "" }
+  let formatter = DateFormatter()
+  formatter.locale = .current
+  formatter.dateStyle = .none
+  formatter.timeStyle = .short
+  let clock = formatter.string(from: date)
+  let remainingMs = date.timeIntervalSince(now) * 1000
+  if remainingMs <= 0 { return "Reset at \(clock)" }
+  let minutes = max(1, Int((remainingMs / 60_000).rounded()))
+  let remaining = minutes < 60 ? "\(minutes) min" : "\(Int((Double(minutes) / 60.0).rounded())) hr"
+  return "Reset at \(clock) (\(remaining))"
+}
+
 /// Ultra-compact relative-time label for sidebar rows: "now", "12m", "3h", "2d". Mirrors
 /// the desktop `relativeTimeCompact` (`apps/desktop/src/renderer/lib/format.ts`).
 func relativeTimestampCompact(_ value: String) -> String {
diff --git a/apps/ios/ADETests/ADETests.swift b/apps/ios/ADETests/ADETests.swift
index a457951ba..9887641a7 100644
--- a/apps/ios/ADETests/ADETests.swift
+++ b/apps/ios/ADETests/ADETests.swift
@@ -7391,6 +7391,13 @@ final class ADETests: XCTestCase {
                 "queueable": false,
               ],
             ],
+            [
+              "action": "chat.stopTask",
+              "policy": [
+                "viewerAllowed": true,
+                "queueable": false,
+              ],
+            ],
             [
               "action": "chat.restoreCancelledQueue",
               "policy": [
@@ -7420,6 +7427,7 @@ final class ADETests: XCTestCase {
     XCTAssertFalse(service.isChatRemoteActionQueueable("chat.setScheduledWorkPaused", sessionId: "chat-1"))
     XCTAssertTrue(service.supportsChatRemoteAction("chat.dispatchSteer", sessionId: "chat-1"))
     XCTAssertTrue(service.supportsChatRemoteAction("chat.interruptWithQueueMode", sessionId: "chat-1"))
+    XCTAssertTrue(service.supportsChatRemoteAction("chat.stopTask", sessionId: "chat-1"))
     XCTAssertTrue(service.supportsChatRemoteAction("chat.restoreCancelledQueue", sessionId: "chat-1"))
     service.configureConnectedTransportForTesting()
     XCTAssertTrue(service.canInvokeChatRemoteAction("chat.setScheduledWorkPaused", sessionId: "chat-1"))
@@ -13623,6 +13631,138 @@ final class ADETests: XCTestCase {
     }
   }
 
+  func testWorkChatStopCapabilityMirrorsDesktopStopMatrix() {
+    XCTAssertEqual(
+      WorkChatStopCapability.modes,
+      [.stopOnly, .stopAndClear, .stopAndBackground, .stopAndClearAndBackground]
+    )
+    XCTAssertEqual(WorkChatStopCapability.defaultMode, .stopAndClear)
+    XCTAssertEqual(WorkChatStopCapability.copy(mode: .stopOnly, jobCount: 3).title, "Turn only")
+    XCTAssertEqual(WorkChatStopCapability.copy(mode: .stopAndClear, jobCount: 3).title, "Turn + queue")
+    XCTAssertEqual(
+      WorkChatStopCapability.copy(mode: .stopAndBackground, jobCount: 3).title,
+      "Turn + background (3 jobs)"
+    )
+    XCTAssertEqual(
+      WorkChatStopCapability.copy(mode: .stopAndClearAndBackground, jobCount: 1).title,
+      "Turn + queue + background (1 job)"
+    )
+    XCTAssertEqual(AgentChatStopMode.stopOnly.rawValue, "stop_only")
+    XCTAssertEqual(AgentChatStopMode.stopAndClear.rawValue, "stop_and_clear")
+    XCTAssertEqual(AgentChatStopMode.stopAndBackground.rawValue, "stop_and_background")
+    XCTAssertEqual(AgentChatStopMode.stopAndClearAndBackground.rawValue, "stop_and_clear_and_background")
+  }
+
+  func testAgentChatSessionSummaryDecodesUsageLimitParkFields() throws {
+    let data = Data(#"""
+    {
+      "sessionId":"chat-1",
+      "laneId":"lane-1",
+      "provider":"claude",
+      "model":"claude-sonnet",
+      "status":"idle",
+      "startedAt":"2026-07-08T00:00:00.000Z",
+      "lastActivityAt":"2026-07-08T00:00:03.000Z",
+      "autoContinueAtUsageLimit":false,
+      "usageLimitParkedUntil":"2026-07-08T00:47:00.000Z",
+      "activeBackgroundTaskCount":3
+    }
+    """#.utf8)
+    let summary = try JSONDecoder().decode(AgentChatSessionSummary.self, from: data)
+    XCTAssertEqual(summary.autoContinueAtUsageLimit, false)
+    XCTAssertEqual(summary.usageLimitParkedUntil, "2026-07-08T00:47:00.000Z")
+    XCTAssertEqual(summary.activeBackgroundTaskCount, 3)
+  }
+
+  func testAgentChatContextUsageCategoryDecodesKindNotName() throws {
+    let data = Data(#"""
+    {"name":"Free","tokens":1200,"percentage":12,"kind":"used"}
+    """#.utf8)
+    let category = try JSONDecoder().decode(AgentChatContextUsageCategory.self, from: data)
+    XCTAssertEqual(category.name, "Free")
+    XCTAssertEqual(category.kind, "used")
+  }
+
+  func testWorkUsageLimitOptOutShowsWhenParkedAndHidesWhenOptedOut() {
+    let now = Date(timeIntervalSince1970: 1_783_468_800)
+    let parked = "2026-07-08T00:47:00.000Z"
+    XCTAssertTrue(
+      WorkUsageLimitOptOut.shouldShow(
+        autoContinueAtUsageLimit: nil,
+        usageLimitParkedUntil: parked,
+        scheduledWork: nil,
+        now: now
+      )
+    )
+    XCTAssertFalse(
+      WorkUsageLimitOptOut.shouldShow(
+        autoContinueAtUsageLimit: false,
+        usageLimitParkedUntil: parked,
+        scheduledWork: nil,
+        now: now
+      )
+    )
+    let label = workUsageLimitResetLabel(parked, now: now)
+    XCTAssertTrue(label.hasPrefix("Reset at "))
+    XCTAssertTrue(label.contains("47 min"))
+  }
+
+  func testAgentChatScheduledWorkItemDecodesAutoResumeSource() throws {
+    let data = Data(#"""
+    {
+      "id":"auto-resume:chat-1",
+      "sessionId":"chat-1",
+      "kind":"wakeup",
+      "status":"scheduled",
+      "title":"Auto-resume",
+      "prompt":"continue",
+      "createdAt":"2026-07-08T00:00:00.000Z",
+      "durable":true,
+      "cancellable":true,
+      "source":"auto_resume_limit",
+      "nextRunAt":"2026-07-08T00:47:00.000Z"
+    }
+    """#.utf8)
+    let item = try JSONDecoder().decode(AgentChatScheduledWorkItem.self, from: data)
+    XCTAssertEqual(item.source, "auto_resume_limit")
+    XCTAssertTrue(WorkUsageLimitOptOut.isPendingAutoResume(item))
+    XCTAssertTrue(
+      WorkUsageLimitOptOut.shouldShow(
+        autoContinueAtUsageLimit: nil,
+        usageLimitParkedUntil: nil,
+        scheduledWork: [item],
+        now: Date(timeIntervalSince1970: 1_783_468_800)
+      )
+    )
+  }
+
+  func testWorkSubagentCanStopTaskSkipsSpawnedChatsAndSettledRows() {
+    func snap(taskId: String, status: WorkSubagentSnapshot.Status, agentType: String? = "code-reviewer") -> WorkSubagentSnapshot {
+      WorkSubagentSnapshot(
+        taskId: taskId,
+        agentId: taskId,
+        agentType: agentType,
+        parentToolUseId: nil,
+        description: "Audit chat renderer",
+        background: false,
+        label: nil,
+        model: nil,
+        reasoningEffort: nil,
+        status: status,
+        lastToolName: nil,
+        latestSummary: nil,
+        turnId: nil,
+        startedAt: nil,
+        updatedAt: nil
+      )
+    }
+    let running = snap(taskId: "agent-1", status: .running)
+    XCTAssertTrue(workSubagentCanStopTask(running))
+    XCTAssertEqual(workSubagentStopLabel(running), "Stop code-reviewer")
+    XCTAssertFalse(workSubagentCanStopTask(snap(taskId: "agent-1", status: .succeeded)))
+    XCTAssertFalse(workSubagentCanStopTask(snap(taskId: "chat:child-1", status: .running)))
+  }
+
   func testSyncChatMessageDeliveryParsesQueuedSteerResult() {
     XCTAssertEqual(syncChatMessageDelivery(from: ["ok": true, "steerId": "steer-1", "queued": true]), .queued(steerId: "steer-1"))
     XCTAssertEqual(syncChatMessageDelivery(from: ["ok": true, "steerId": "steer-1", "queued": false]), .sent)
diff --git a/docs/features/chat/README.md b/docs/features/chat/README.md
index 0c533854a..430587993 100644
--- a/docs/features/chat/README.md
+++ b/docs/features/chat/README.md
@@ -135,12 +135,16 @@ for its separate RPC, sync, storage, and UI contracts.
 | `apps/desktop/src/renderer/components/chat/ChatPrPane.tsx`, `ChatPrInlineCreator.tsx` | Left floating PR pane for Work chat, with its own title bar (`Pull request` + ↻ refresh + ✕ close) — the manual PR-sync control lives here, not in `ChatGitToolbar`. Renders cached lane PR details immediately, then performs the same cooldown-bound targeted PR refresh as the toolbar before settling the state. Terminal PRs hide stale running-check labels so merged/closed PRs do not keep showing in-progress CI from an old cache row. An unmapped (`pr.unmapped`) lane PR skips the live refresh and the checks/reviews/status enrichment, since it has no DB row behind the synthetic `gh:` id. With no PR it embeds `ChatPrInlineCreator`, whose title defaults to the chat session title — unless the pane carries a `runtimePin`, in which case it says `Switch to <machine> to open one`, because the creator derives its branch, base, and Linear links from the bound machine's lanes and `createFromLane` is unpinned. Reads and the event subscription do follow the pin. The pane's open/closed state is per chat and persisted across restarts through `chatCompanionUiState` — see [Composer and chat UI](composer-and-ui.md#source-file-map). |
 | `apps/desktop/src/renderer/lib/visualContextFormatting.ts` | Serializes iOS, App Control, built-in browser, and attachment context into prompt text. |
 | `apps/desktop/src/renderer/components/chat/RewindFilesConfirmDialog.tsx`, `rewindFilesPreview.ts` | Chat file-rewind confirmation surface. Claude uses the SDK `rewindFiles` control call; Codex uses ADE's git-backed file restore plan plus a version-gated app-server call — `thread/fork` before the target turn on servers >= 0.145.0, and the deprecated `thread/rollback` fallback on <= 0.144 or when the target turn has no usable id (see [agent-routing.md](./agent-routing.md#codex-rewind-and-0145-readiness)). `rewindFilesPreview.ts` maps the selected user message to turn diff summaries and per-file SHA ranges; the dialog lists every restored file, expands rows into `AdeDiffViewer`, and confirms the provider rewind without using browser-native confirm UI. |
-| `apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx`, `chatExecutionSummary.ts`, `chatSubagentIdentity.tsx`, `codex/CodexGoalCard.tsx` | Chat Info drawer content: Codex goal card, capped/collapsible plan and task sections, and capped Subagents/Background/Schedule rosters. Every subagent row shows a sentence-case model chip: a reported envelope `model` is ground truth, and a missing model falls back to the parent session label marked **inherited**. Running subagent and background durations derive from the wall clock and tick once per second; terminal rows retain their final compact duration. Terminal work moves into one **Completed** disclosure without reordering survivors; failed and pinned rows stay active; Clear hides only terminal Completed rows and Restore reverses it. Schedule pause/play remains in the Schedule header, recurring rows show last-run plus next-fire timing, and each active ADE-managed durable row exposes Cancel; provider-only/non-durable transcript rows stay visible without a false cancellation control. Spawned-chat snapshots carry a derived `childSessionId`; the derivation preserves the `chat:` task id and `spawnKind` when the canonical dotted lifecycle twin merges into the underscore event. Their roster rows show the child's live session title, put the runtime in the small kind chip, and navigate directly to the child instead of opening a provider transcript drawer. `chatSubagentIdentity.tsx` centralizes deterministic identity and exposes status-optional, size-configurable glyphs for both roster state and compact lineage cues. |
+| `apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx`, `chatExecutionSummary.ts`, `chatSubagentIdentity.tsx`, `codex/CodexGoalCard.tsx` | Chat Info drawer content: Codex goal card, capped/collapsible plan and task sections, and capped Subagents/Background/Schedule rosters. Every subagent row shows a sentence-case model chip: a reported envelope `model` is ground truth, and a missing model falls back to the parent session label marked **inherited**. Running subagent and background durations derive from the wall clock and tick once per second; terminal rows retain their final compact duration. Terminal work moves into one **Completed** disclosure without reordering survivors; failed and pinned rows stay active; Clear hides only terminal Completed rows and Restore reverses it. Schedule pause/play remains in the Schedule header, recurring rows show last-run plus next-fire timing, and each active ADE-managed durable row exposes Cancel; provider-only/non-durable transcript rows stay visible without a false cancellation control. Running native subagent and background rows (those with a `sourceTaskId`, not spawned ADE `chat:` tasks) expose a square stop that calls `ade.agentChat.stopTask`. Spawned-chat snapshots carry a derived `childSessionId`; the derivation preserves the `chat:` task id and `spawnKind` when the canonical dotted lifecycle twin merges into the underscore event. Their roster rows show the child's live session title, put the runtime in the small kind chip, and navigate directly to the child instead of opening a provider transcript drawer. `chatSubagentIdentity.tsx` centralizes deterministic identity and exposes status-optional, size-configurable glyphs for both roster state and compact lineage cues. |
 | `apps/desktop/src/renderer/components/chat/ChatBuiltInBrowserPanel.tsx` | Renderer panel for the in-app browser. Renders the address bar, tabs strip, navigation controls, an inspect/select toolbar, and a `BuiltInBrowserStatus`-derived empty/error state, then asks the main process to position the underlying `WebContentsView` over the panel's bounding rect through `ade.builtInBrowser.setBounds`. Its trusted-renderer-only **Profile** panel shows global cookie counts/domains, cache size, last safe flush, and remembered site permissions, with per-row Remove and Clear all controls. Because native `WebContentsView` content sits above the renderer, the panel hides it while ADE overlays, dialogs, menus, or popovers overlap the browser surface so ADE chrome remains reachable. Mounted by `WorkSidebar` under the `browser` tab and (indirectly) by any renderer code that calls `openUrlInAdeBrowser()` — the helper opens the sidebar Browser tab and dispatches the URL into a fresh tab. Selections committed through inspect-mode hit-testing fan out via the `onAddContext` callback as `BuiltInBrowserContextItem` payloads. |
 | `apps/desktop/src/renderer/components/work/WorkSurfaceHeader.tsx`, `ClaudeLoginPromptButton.tsx` | Shared Work surface header chrome for chat and CLI surfaces: title, lane chip, Claude cache badge, git toolbar, caller-provided trailing actions, and the dismissible Claude login CTA that starts `claude auth login` in a tracked PTY. The `WorkSurfaceTitle` sub-component plays a one-time CSS shimmer when the title transitions from a provider default (`Claude Chat`, `Codex Chat`, …) to a real auto-generated title while the surface stays mounted, and respects `prefers-reduced-motion`. `AgentChatPane` also reuses `ClaudeLoginPromptButton` as a sticky bar above the composer (keyed `composer-auth:<sessionId>`) while a Claude session is logged out. Settled state is rendered by `ChatLifecycleBanner` as a compact pill above the composer; the header takes a `snoozeSessionId` for the remaining snooze affordance — see [composer-and-ui.md › Header](composer-and-ui.md#header). |
 | `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. |
-| `apps/desktop/src/renderer/components/chat/ProviderFailureRecoveryCard.tsx` | Classifies terminal provider capacity and usage-limit errors into actionable transcript cards. The card explains that the thread remains safe, offers an explicit same-thread **Retry turn**, and opens the composer model picker through a one-shot request for **Choose model**; neither action is enabled while another turn is active. When a usage-limit failure left an auto-resume armed, the card also shows `Auto-resume scheduled for <local time>` with a **Cancel auto-resume** button; the pending row arrives through `ChatAutoResumeContext`, which `AgentChatPane` fills from the chat's scheduled-work list. |
-| `apps/desktop/src/shared/chatAutoResume.ts` | Auto-resume after a provider usage limit resets. When a turn fails at a usage/rate limit **and** the provider published a reset instant (Claude's plan-quota snapshot, Codex's `account/rateLimits`), the chat service arms one durable scheduled-work row per chat at reset + a 90s buffer, prompting the agent to continue the interrupted task. The row uses the deterministic id `auto-resume:<sessionId>` and the `source: "auto_resume_limit"` tag, so a repeat failure replaces it rather than stacking, and ADE's own cancel-on-activity sweep never touches a user- or agent-created schedule. No reset time means no schedule — the manual recovery card stays the only path. The row is cancelled when the user sends a message or retries the turn, when the schedule is cancelled from the card or Chat Info, and when the chat is archived, deleted, or disposed. Delivery is ordinary scheduled work: a turn already active at the due time defers the resume to the next turn boundary instead of double-sending. This module is the shared half: the id/tag grammar, the buffer, the prompt, the local-time label, `autoResumeFireAtMs` (which returns null for an unknown or already-passed reset), `isPendingAutoResumeScheduledWork` (which accepts both status vocabularies — the host record spells the finished state `done`, the client item `completed`), and `isUsageLimitChatError`, the one predicate the host arms from *and* the renderer's `classifyProviderFailure` delegates its `rate_limit` branch to, so the card and the schedule can never disagree about what counts as a usage limit (Codex spells it `usageLimitReached`, not `usageLimitExceeded`). |
+| `apps/desktop/src/renderer/components/chat/ProviderFailureRecoveryCard.tsx` | Classifies terminal provider capacity and usage-limit errors into actionable transcript cards. The card explains that the thread remains safe, offers an explicit same-thread **Retry turn**, and opens the composer model picker through a one-shot request for **Choose model**; neither action is enabled while another turn is active. When a usage-limit failure left auto-continue armed, the card shows **Usage limit reached**, the local reset clock, status text **Continue automatically**, and **Don't continue**; Don't continue opts the chat out of Claude SDK `autoContinueAtUsageLimit` and cancels any ADE `auto_resume_limit` schedule. The pending row arrives through `ChatAutoResumeContext`, which `AgentChatPane` fills from the chat's parked-until instant and scheduled-work list. |
+| `apps/desktop/src/shared/chatAutoResume.ts` | Auto-resume after a provider usage limit resets. When a turn fails at a usage/rate limit **and** the provider published a reset instant (Claude's plan-quota snapshot, Codex's `account/rateLimits`), the chat service arms one durable scheduled-work row per chat at reset + a 90s buffer, prompting the agent to continue the interrupted task — except Claude chats with `autoContinueAtUsageLimit` left on (the default): those park in the session list (`usageLimitParkedUntil`) and let the SDK continue natively. ADE's own scheduled-work auto-resume is not armed for that Claude path. `sessionAutoContinueAtUsageLimit()` is the one opt-out predicate (explicit `false` only; missing/undefined is on). Don't continue persists that false, clears park, cancels any ADE schedule, and interrupts a busy Claude query with default Stop (`stop_and_clear`, which spares background). A user send while parked clears park without firing the OS "Chat resumed" notification; an ADE auto-resume `user_message` or an SDK `status: started` while still parked does notify. The row uses the deterministic id `auto-resume:<sessionId>` and the `source: "auto_resume_limit"` tag, so a repeat failure replaces it rather than stacking, and ADE's own cancel-on-activity sweep never touches a user- or agent-created schedule. No reset time means no schedule — the manual recovery card stays the only path. The row is cancelled when the user sends a message or retries the turn, when Don't continue runs, when the schedule is cancelled from Chat Info, and when the chat is archived, deleted, or disposed. Delivery is ordinary scheduled work: a turn already active at the due time defers the resume to the next turn boundary instead of double-sending. This module is the shared half: the id/tag grammar, the buffer, the prompt, the local-time label, `autoResumeFireAtMs` (which returns null for an unknown or already-passed reset), `isPendingAutoResumeScheduledWork` (which accepts both status vocabularies — the host record spells the finished state `done`, the client item `completed`), `formatUsageLimitResetLabel`, and `isUsageLimitChatError`, the one predicate the host arms from *and* the renderer's `classifyProviderFailure` delegates its `rate_limit` branch to, so the card and the schedule can never disagree about what counts as a usage limit (Codex spells it `usageLimitReached`, not `usageLimitExceeded`). |
+| `apps/desktop/src/shared/chatStopModes.ts` | Canonical four-mode stop matrix (`stop_only`, `stop_and_clear`, `stop_and_background`, `stop_and_clear_and_background`), default `stop_and_clear`, settle teardown `stop_and_background`, live job-count copy, hyphen/flag aliases, and `shouldDeclarePerTaskStopAffordance` — ADE sets Claude SDK `perTaskStopAffordance` only after the public `stopTask` controls are reachable. iOS hand-mirrors the table in `WorkChatStopCapability`. |
+| `apps/desktop/src/shared/claudeContextUsage.ts` | Normalizes SDK `context_usage` / `getContextUsage` into `ClaudeContextUsage`. Rows are classified by `categories[].kind` (`used` / `free` / `buffer` / `deferred`), never by the display name `"free"`. A used row named Free stays used; remaining capacity is synthesized as `kind: "free"` only when the SDK omitted that row. |
+| `apps/desktop/src/shared/claudeClassifierContext.ts` | Builds the Claude SDK `classifierContext` string for PostToolUse. Relays only explicit user approvals and user-typed consent; never tool output, model text, a summary of either, session-override auto-allows, or policy allows. Approval-without-text becomes `"The user approved this tool call."` with no command text. The 2000 UTF-16 cap is enforced; the hook return is synchronous. Every relay emits a `system_notice` with `status: "classifier_context"`. |
+| `apps/desktop/src/shared/claudeModelSwitch.ts` | Parses PreModelSwitch / PostModelSwitch hook args. PostModelSwitch emits a quiet transcript divider (`system_notice` `status: "model_switched"`). |
 | `apps/desktop/src/main/services/chat/chatAutoResumeCoordinator.ts` | The whole auto-resume subsystem on the host: per-chat streak state, the durable row, two system notices, and the races between arming, cancelling and firing. `agentChatService` keeps only thin call sites — it reports a limit error, a dispatch, a dismissal, and a turn finishing, and this decides what each means. Three contracts are load-bearing. **`cancelEpoch`**: arming is asynchronous (it waits for the scheduler, then upserts), so a user message can land while the upsert is in flight and find nothing to cancel; every cancel bumps the epoch and the arm undoes its own row if the epoch moved. **The re-arm cap** (`AUTO_RESUME_MAX_CONSECUTIVE_ARMS = 2`): the reset instant a provider publishes is not always the limit that rejected the turn — Claude's snapshot is session-scoped and can carry a stale `resetsAtMs` forward, so a weekly-limit rejection would arm against a session reset, fail again, and burn a turn every cycle. Two arms against *distinct* reset instants, then the chat emits `Auto-resume paused after two attempts` and waits for a human. A resume that runs without hitting the limit again resets the streak, which is why `noteResumeTurnStarted` / `noteTurnFinished` exist: a fired resume always carries `scheduledWake`, exactly what the cancel sweep skips, so without that watch the cap would be a lifetime budget and a healthy headless chat would pause itself after two limits days apart. **Notice ordering**: both notices are emitted after one microtask, because this runs inside the event commit before the error event has minted its sequence number and an inline emit would render the notice above the failure it explains. Notices are `system_notice` rows with `noticeKind: "rate_limit"`, attributed to the failed turn, de-duped one per armed fire time. |
 | `apps/desktop/src/main/services/chat/attachmentInlineGuard.ts` | The one check every adapter that base64s attachment bytes into a model request runs, plus the stand-in it substitutes. `MAX_PROVIDER_INLINE_IMAGE_BYTES` (10 MB) is deliberately smaller than the 50 MB attachment cap: most providers receive a *path* and do not care how large the file is, but Claude images (`buildClaudeV2Message`), the AI-SDK streaming content OpenCode uses (`buildStreamingUserContent`), and the Droid/Pi prompt blocks (`buildAgentPromptBlocks`) inline the bytes, where base64 inflates by a third and the provider rejects the request. Over the ceiling those three push `inlineAttachmentHintPart` instead — a text part naming the path, the size, and the limit, so the agent can read the file with its own tools and the turn still runs. `workerAttachmentImages.ts` uses the same constant for Cursor/Pi/Droid worker IPC, and it deliberately did not move when the attachment cap did. |
 | `apps/desktop/src/shared/chatAttachmentStagingFs.ts` | The disk-side rule for staging a chat attachment, shared by every process that writes into `<projectRoot>/.ade/attachments`: the desktop main process, the ADE action registry the local brain serves, the CLI sync host's HTTP upload route, and `imageAttachment.ts`. `projectAttachmentsDir` is the one spelling of the directory; `stageAttachmentCopy` copies a file that already exists on this machine's disk; `stageAttachmentBytes` writes bytes a caller already holds. Both give the destination a fresh UUID basename with only a regex-validated extension from the caller's display name (`safeAttachmentExtension`), then re-check containment with `path.relative` rather than a string prefix — the prefix form false-rejects a filesystem or Windows drive root and cannot see a cross-drive path at all. `stageAttachmentCopy` is deliberately *not* constrained to the project root (users drag files in from Downloads), stats for size before copying a byte, and must only ever be reachable from the machine that owns the file. There used to be three copies of this rule and only two validated the extension, so the same drag-and-drop produced a differently-named file depending on which process answered. |
@@ -522,7 +526,7 @@ Three rules are specific to it:
 - **It announces itself in the transcript.** Both outcomes are
   `system_notice` rows with `noticeKind: "rate_limit"`, attributed to the failed
   turn, so `ProviderFailureRecoveryCard` renders them beside the failure they
-  explain — and the live schedule with its **Cancel auto-resume** button appears
+  explain — and the live schedule with **Continue automatically** / **Don't continue** appears
   only on the newest usage-limit card, never on every one in the thread's
   history.
 
@@ -585,10 +589,14 @@ Three rules are specific to it:
   as a real SDK continuity change, deduplicates ADE-owned `command_lifecycle`
   frames, preserves the query when an interrupt receipt reports queued messages,
   and uses the capability-advertised interrupt request with
-  `cancel_queued: true` for **Stop & clear queue**. Older compatible runtimes
+  `cancel_queued: true` for **Turn + queue** (`stop_and_clear`, the default).
+  Older compatible runtimes
   fall back to the public interrupt plus the capability-probed
-  `cancelAsyncMessage` control for attributed queued steers. **Stop only**
-  interrupts the model step while preserving queued messages. The SDK's
+  `cancelAsyncMessage` control for attributed queued steers. **Turn only**
+  (`stop_only`) interrupts the model step while preserving queued messages
+  and background jobs. Modes that also stop background
+  (`stop_and_background`, `stop_and_clear_and_background`) call
+  `stopActiveClaudeSubagents` and reset the query. Default Stop does not. The SDK's
   level-triggered
   `background_tasks_changed` set and active subagents protect that query from
   idle-TTL cleanup and runtime-budget eviction until the work actually ends —
@@ -755,11 +763,13 @@ Three rules are specific to it:
   message queued as a steer instead of racing the live turn (see
   [remote commands](../sync-and-multi-device/remote-commands.md)).
   Stop is a separate queue-aware action: active Claude sessions can choose
-  **Stop & clear queue** or **Stop only**. Clear is the
-  backward-compatible default. If clear cancels an ADE-attributed queued
+  among **Turn only**, **Turn + queue** (default), **Turn + background**, and
+  **Turn + queue + background**. If a queue-clearing mode cancels an ADE-attributed queued
   message, the transcript exposes one eight-second Undo card backed by
   `restoreCancelledQueue`; expiry is explicit and a restore reuses the
-  original steer ids, text, attachments, and context attachments.
+  original steer ids, text, attachments, and context attachments. Per-task
+  `ade.agentChat.stopTask({ sessionId, taskId })` stops one running Claude
+  task; siblings keep running.
 - **Identity sessions.** Sessions carrying `identityKey` (now just
   `"cto"`) are filtered out of the Work tab list and rendered by the
   dedicated CTO tab. See [Agent Routing and
@@ -1204,11 +1214,15 @@ resolved in the terminal and the menu says **Resolve input to settle**.
 
 The teardown that a settle performs is deliberately narrower than the dismissal.
 `sessions/settleTeardownWiring.ts` stops the session's work through
-`interrupt({ mode: "stop_only" })`, and that mode does **not** settle Codex
+`interrupt({ mode: "stop_and_background" })` (`SETTLE_TEARDOWN_STOP_MODE`): it
+keeps the user's queued prompts (those are unrecoverable) and still stops
+background work (the reason settle exists). That mode does **not** settle Codex
 cards: stopping work is
-not the same as discarding a decision the user still owns, exactly as `stop_only`
-already spares queued follow-ups. Only `stop_and_clear` — the user pressing Stop
-— settles them, and only the explicit **Dismiss & settle** transaction discards a
+not the same as discarding a decision the user still owns, exactly as
+`stop_only` already spares queued follow-ups. Only queue-clearing modes
+(`stop_and_clear`, `stop_and_clear_and_background`) — the user pressing a
+Stop that clears the queue — settle them, and only the explicit **Dismiss & settle**
+transaction discards a
 card the user is still looking at. The exception is a card attached to a turn that
 is genuinely running: the app-server request behind it dies when the turn aborts
 either way, so it is settled regardless of mode.
@@ -1754,17 +1768,18 @@ handlers live in `apps/desktop/src/main/services/ipc/registerIpc.ts`.
 | `ade.agentChat.cancelSteer` / `ade.agentChat.editSteer` | invoke | Queue management for queued steers. `cancelSteer({ requireQueued: true })` rejects if delivery already claimed the row; desktop Edit uses that guarded form before restoring the message and attachments to the composer. |
 | `ade.agentChat.dispatchSteer` | invoke | Deliver an already staged steer immediately. The accepted `mode` per provider comes from `ACTIVE_TURN_DISPATCH_MODES`, so this is one guard rather than a per-provider ladder. Claude pushes an SDK message with `priority: "next"` (`mode: "inline"`) or `priority: "now"` (`mode: "interrupt"`), both with `shouldQuery: true`, and the staged row is removed only after the input pump accepts it. Cursor accepts `mode: "interrupt"` only: the staged row is spliced out, resolved with a "Delivering your queued message..." notice, and promoted to the interrupt-and-continue redirect; the row is put back (and its settlement re-opened) if the redirect throws, so the message is never silently lost. Queue-only providers (Codex, OpenCode, Droid, Pi) and `"inline"` on Cursor are rejected with `unsupportedActiveTurnDispatchModeMessage`. |
 | `ade.agentChat.cancelDispatchedSteer` | invoke | Claude-only cancellation for an attributed SDK-queued priority message. Resolves the ADE `steerId` to its bounded command UUID, capability-probes the runtime `cancelAsyncMessage` control, and returns `{ cancelled: true }` only after Claude confirms cancellation. |
-| `ade.agentChat.interrupt` | invoke | Provider-specific interruption of the in-flight turn. Claude accepts optional `mode: "stop_and_clear" \| "stop_only"` (default `stop_and_clear`) and returns the chosen mode, cancelled queue count, and an optional eight-second recovery id/expiry. Codex reads the same `mode`: a `stop_and_clear` settles the session's pending Codex cards through `settleCodexPendingInputs` on every arm — including the two arms that return early because there is nothing to interrupt (no thread id, no active turn), which is the *common* case, since a plan approval is raised after its turn completes and would otherwise stay unanswerable and keep the composer locked. `stop_only` stops the work and leaves the cards. Other providers retain their existing stop behavior. |
-| `ade.agentChat.restoreCancelledQueue` | invoke | Claude-only recovery for a recent `stop_and_clear`. Restores the original ADE-attributed queued steers when the matching recovery id is still live; returns `{ restored, restoredCount }` and never recreates expired or foreign-session entries. |
+| `ade.agentChat.interrupt` | invoke | Provider-specific interruption of the in-flight turn. Claude accepts optional `mode: "stop_and_clear" \| "stop_only" \| "stop_and_background" \| "stop_and_clear_and_background"` (default `stop_and_clear`) and returns the chosen mode, cancelled queue count, and an optional eight-second recovery id/expiry. Default `stop_and_clear` stops the turn and clears the queue but leaves Claude background jobs running once `perTaskStopAffordance` is on. Codex reads the queue axis of the same `mode`: a queue-clearing mode settles the session's pending Codex cards through `settleCodexPendingInputs` on every arm — including the two arms that return early because there is nothing to interrupt (no thread id, no active turn), which is the *common* case, since a plan approval is raised after its turn completes and would otherwise stay unanswerable and keep the composer locked. `stop_only` and `stop_and_background` stop the work and leave the cards. Other providers retain their existing stop behavior. |
+| `ade.agentChat.stopTask` | invoke | Claude-only: stop one running background task or native subagent by `taskId`. Siblings keep running. Spawned ADE chats (`chat:` prefixes) are not this API; they have their own session interrupt. Desktop Chat Info, spawn cards, iOS Work, `ade chat stop-task`, and `chat.stopTask` over sync all call this. The ADE Code TUI has no per-task control. |
+| `ade.agentChat.restoreCancelledQueue` | invoke | Claude-only recovery for a recent queue-clearing Stop. Restores the original ADE-attributed queued steers when the matching recovery id is still live; returns `{ restored, restoredCount }` and never recreates expired or foreign-session entries. |
 | `ade.agentChat.recoverCodexTurn` | invoke | Execute one guarded recovery action for the currently active stalled Codex turn: `wait`, `steer`, `interrupt_retry_same_thread`, or `restart_resume_thread`. Calls are single-flight per session/turn and reject stale cards once that turn is no longer active. |
 | `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: first waits for current-session Claude jobs to confirm provider cancellation, locally tombstones jobs whose earlier provider owner is unreachable, then 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. A current-provider timeout leaves the chat unchanged. Archiving uses the same cancellation gate. |
-| `ade.agentChat.updateSession` | invoke | Mutate permission modes, `manuallyNamed`, capability mode, the legacy-named `codexFastMode` Fast Mode toggle, Claude SDK session title/tag metadata, `spawnKind` (`subagent` / `peer`), and `subagentTakeoverPromptShown`. An empty tag clears the SDK tag. Demoting to peer posts a quiet takeover note on the parent. |
+| `ade.agentChat.updateSession` | invoke | Mutate permission modes, `manuallyNamed`, capability mode, the legacy-named `codexFastMode` Fast Mode toggle, Claude SDK session title/tag metadata, `spawnKind` (`subagent` / `peer`), `subagentTakeoverPromptShown`, and `autoContinueAtUsageLimit`. Setting `autoContinueAtUsageLimit: false` persists Don't continue, clears `usageLimitParkedUntil`, cancels any ADE auto-resume schedule, and interrupts a busy Claude query with default Stop (background jobs keep running). An empty tag clears the SDK tag. Demoting to peer posts a quiet takeover note on the parent. |
 | `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. |
-| `ade.agentChat.getContextUsage` | invoke | Claude-only: return the SDK control-channel context usage breakdown (`AgentChatContextUsage`) for the `/context` panel. The harness also performs this authoritative read after initialization, each settled turn, and compact completion; streamed estimates remain the responsive in-turn signal. |
+| `ade.agentChat.getContextUsage` | invoke | Claude-only: return the SDK control-channel context usage breakdown (`AgentChatContextUsage`) for the `/context` panel. Categories are classified by `kind` (`used` / `free` / `buffer` / `deferred`), never by the display name `"free"`. The harness also performs this authoritative read after initialization, each settled turn, and compact completion; streamed estimates remain the responsive in-turn signal. |
 | `ade.agentChat.rewindFiles` | invoke | Dry-run and apply provider-backed file rewind for a selected user message. Claude uses SDK file checkpoints and leaves conversation history untouched; `skippedLinks` reports linked paths the SDK could not restore and produces a visible notice rather than silently claiming a complete rewind. Codex restores ADE's git-tracked file plan and moves the app-server thread back — `thread/fork` before the selected turn on servers >= 0.145.0, or the deprecated `thread/rollback` (latest user message only) on older servers or when the turn id cannot be resolved. The renderer dry-run opens the same confirmation dialog with message context, aggregate stats, per-file rows, and lazy diff previews. |
 | `ade.agentChat.claudePlugins.list` / `.reload` | invoke | Claude-only: enumerate discovered Claude plugins and force a plugin reload. Backs `/plugin`. |
 | `ade.agentChat.claudeOutputStyles.list` / `.set` | invoke | Claude-only: list and select discovered output styles (user + project + plugin roots). Backs `/output-style`. |
@@ -1938,9 +1953,11 @@ Provider connection management lives on the `ade.ai.*` surface (handled in `regi
   it settles it, so a second call — the app-server's own `turn/aborted` landing
   after a local interrupt already settled — finds an empty map and cannot
   resolve the same card twice. Five details are load-bearing:
-  - **`stop_only` does not settle.** Settle teardown stops the work without
-    discarding a decision the user still owns, the same way it spares queued
-    follow-ups. Only `stop_and_clear` and the explicit **Dismiss & settle**
+  - **Queue-preserving modes do not settle Codex cards.** Settle teardown
+    uses `stop_and_background`, which stops work without discarding a
+    decision the user still owns, the same way `stop_only` spares queued
+    follow-ups. Only queue-clearing modes (`stop_and_clear`,
+    `stop_and_clear_and_background`) and the explicit **Dismiss & settle**
     transaction settle cards.
   - **Runtime-death paths pass `preserveRecoverablePlanApprovals: true`**
     (`teardownRuntime`, `proc` error/exit). A plan approval outlives its runtime
diff --git a/docs/features/chat/composer-and-ui.md b/docs/features/chat/composer-and-ui.md
index 9b87ac082..04e1f46b4 100644
--- a/docs/features/chat/composer-and-ui.md
+++ b/docs/features/chat/composer-and-ui.md
@@ -20,9 +20,9 @@ subagents, computer use). The pane derives all visible state from the
 | `CrossMachineHandoffModal.tsx`, `crossMachineHandoffPresentation.tsx` | Modal state and user flow for **Send to machine**. It takes a `runtimePin` naming the machine the *source* chat runs on (`null` = this tab's bound machine), and every source-side call is pinned to it: the lane list, `git.getSyncStatus`, `git.getOriginRemote`, `git.push`, `git.pull`, `agentChat.prepareCrossMachineHandoff`, `validateCrossMachineSource`, and `markCrossMachineHandoff`. Destination dispatch already routes by target id and is unaffected. The pin is held in a ref and **frozen once per operation** so every await inside one handoff reaches the same runtime — reading it fresh after an await could cross a lane-index change and split one handoff across two machines. It verifies the source lane on the pinned machine, follows live remote connection snapshots, lets the user pick brief or full-history fork (fork defaults on for fork-capable providers and constrains the model picker to the same provider), lets the user set the destination chat's model, reasoning effort, fast mode, and permission mode with the same shared pills the composer uses, handles existing-project versus confirmed-clone setup, offers a destination-run fast-forward when the target lane is clean and strictly behind the source commit, decodes destination responses at the renderer boundary, pins acceptance to the reviewed route kind, and exposes retryable source-marker failures after destination success. Source blockers render through `BlockedReasons` / `BlockedActionButton` instead of silently disabling Continue. The pure half — stage/mode types, `SourceCheck`, branch/route/repo-readiness copy, permission tone and icon maps, send-step labels, `CheckRow` — lives in `crossMachineHandoffPresentation.tsx` so it is assertable without mounting the stateful modal. Once destination acceptance is dispatched, a runtime timeout or connection interruption produces an amber unknown-outcome notice: the destination chat may still appear, the user should check that machine before retrying, and the modal never reports a truthful cancellation that the runtime did not perform. A fork that the destination can't accept (older ADE with no `forkHandoffSupport`, oversize history, or an unforkable provider file) surfaces a plain reason and a one-click **send as brief** that re-runs prepare + preflight; the insecure-route consent line is fork-aware (a fork discloses that the full history is sent exactly as recorded, a brief that only the summary is sent). |
 | `ChatRuntimeScope.tsx` | Which machine THIS chat is on, and what its lane looks like there — the single derivation every chat-scoped panel reads instead of a global store selector. `useChatRuntimeScope()` returns `{ pin, binding, laneId, lane, laneWorktreePath, rootPath, isRemote, machineName, online }` from context, `useChatRuntimeScopeForPin(pin, laneId, bindingOverride?)` derives the same from a pin passed as a prop (for surfaces mounted outside a chat pane), `useChatScopeDerivation({...})` answers it from a *session* for `AgentChatPane`, and `ChatRuntimeScopeProvider` carries the resolved scope down the panel/drawer subtree. `pin === null` means, and only means, "this chat lives on the tab's binding". ESLint bans `useAppStore` / `useRootAppStore` reads of `projectBinding` / `lanes`, `project.rootPath` reads, and `selectActiveProjectRoot` imports inside `components/chat/**` so no panel can quietly go back to reading the tab's machine. Full contract in the chat [README](README.md#source-file-map). |
 | `AgentChatMessageList.tsx` | Virtualized message list. The virtualizer is **hand-rolled**, not `@tanstack/react-virtual`: a `measuredHeights` row-key → height `Map` feeds top/bottom spacer divs around the rendered window, and each rendered row is wrapped in `MeasuredEventRow`, whose `ResizeObserver` reports its real height through `handleMeasure` → `reconcileMeasuredScrollTop` so a height correction above the viewport does not shift what the reader is looking at. Renders transcript rows and turn dividers, including a `Woke on schedule` divider before every synthetic scheduled turn and inline `SubagentSpawnCard` / `SubagentResultCard` / `BackgroundJobLine` rows (from `SubagentActivityCards.tsx`) for real subagents and backgrounded shell commands, and accepts stable row-key jump requests from the compact while-you-were-away card and the spawn/result jump affordances. Keeps sticky-bottom sessions pinned across streamed row growth, late virtual-height measurements, and a shrinking transcript viewport (a growing composer must not unstick the thread). A Claude `queue_recovery: available` row renders one eight-second Undo card; later `restored`/`expired` rows settle the same recovery id so history replay cannot show a stale action. 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`; terminal provider capacity/usage-limit errors render `ProviderFailureRecoveryCard` with same-thread retry and model-selection actions. User messages marked `metadata.hideFullPrompt` render and copy only their `displayText`, keeping internal handoff briefs out of the visible transcript details, and a handoff-brief user row shows a small brief chip. When a fork seeds pre-fork history into the new chat, the envelopes carry the `handoff_fork` provider origin and the list draws a single `Forked from the previous chat — full history above` divider (`computeForkHistoryDividerRowKey` pins it to the first live row after the seeded history) instead of one marker per seeded row. `WorkingIndicator` is the in-flight turn's status line — `<activity> · working for <elapsed>`, plus a `taking longer than usual` marker past `LONG_RUNNING_TURN_SECONDS`. The activity half comes from `resolveWorkingIndicatorLabel`: `ACTIVITY_LABELS` is keyed against the `activity` union in `shared/types/chat.ts` so a new runtime value is a compile error rather than a raw `web_searching` on screen, and an `editing_file` activity is named with its target (`Editing laneService.ts`) by walking back to the most recent unfinished write entry in the turn — `activity` events carry the tool name, not the file. Its elapsed is written imperatively (`textContent` on a ref) rather than through state, so the once-per-second tick never commits a render on the message list. The line swaps a bare `<span>` for an expander `<button>` the instant the turn's first tool entry arrives, which remounts the timer node, so the ref is a **callback** ref: it repaints the counter in the same commit it attaches, and the ticker re-reads the ref every tick. An element captured once when the ticker started would be detached by that swap and the display would sit frozen at `0s` while the long-running marker still appeared. `ChatInfoHostContext` also lives here — a boolean context reporting whether the *owning host* listens for `ade:chat:open-info`. `AgentChatPane` provides `true` (it owns the chat actions pane); `PersonalChatsPage` mounts the same transcript without it, so the `BackgroundJobLine` `open` button is absent there rather than dispatching into nothing. It must stay a context rather than a module-level registry: `App` renders every `ProjectSurface` and only toggles `active`, so each `AgentChatPane` stays mounted while Personal Chats is open, and a global "is any host alive" flag would read true on exactly the surface that has no pane. |
-| `AgentChatComposer.tsx`, `ComposerPromptStash.tsx`, `ComposerSmartLinkMenu.tsx`, `smartLinkChipMark.ts` | Text input, attachments, model selector, compact title-only permission controls (per-provider `PermissionModePickerOption` tables fed into the shared `components/shared/PermissionModePicker`, which the composer owns the option data for but not the control), slash commands, desktop prompt stashes, smart-link chips (`smartLinkChipMark.ts` returns the inline `currentColor` SVG brand mark each chip renders), **chat-context chips** (select assistant output → Add to chat; the chip label is `Chat context`, serializes an `<ade-chat-context>` block so the agent sees the highlighted passage, and click/backspace copy or remove it like a smart-link chip), pending-input answering (including Codex MCP form/URL elicitations), voice-dictation target registration, and parallel model-slot controls. A running chat's toolbar also shows a read-only amber tower plus the owning machine name beside the model and thinking controls; it identifies where the chat executes and directs moves to Chat actions → Handoff → Continue on another machine. A draft omits that label because its launch shelf owns the machine choice. `ComposerPromptStash` keeps its command surface mounted when the Appearance preference hides the bookmark, so Cmd/Ctrl+S remains available, but the visible bookmark stays out of the toolbar while both the composer and stash list are empty. Its menu is rendered in a viewport-clamped body portal with a bounded, scrolling list so composer overflow and short windows cannot crop it. A save first copies up to ten attached images into the owning project runtime, commits the text plus image references, then clears only the unchanged composer snapshot; restore reapplies both text and images before consuming the stash. The list renders an image thumbnail when the active runtime owns the bytes. On another synced runtime, the row retains its text and image count, labels the images as living on another machine, and refuses restore until the composer is connected to the origin runtime. Machine-bound context and non-image files are not stashed. Completed URLs are non-editable inline chips whose `data-composer-chip-text` preserves the literal URL during serialization; clicking or keyboard-activating a chip opens the Copy link / Remove link menu, and character deletion removes the whole URL token. Every chip also carries a kind-naming `data-composer-chip` attribute, and a scoped `selectionchange` effect marks intersecting chips with `data-composer-chip-selected` so the native selection paints continuously across them (overlay styling lives in `apps/desktop/src/renderer/index.css`). During an active Claude turn, its split Send control selects without dispatching among inline, after-turn, and interrupt delivery; the primary button and Enter execute the selected mode. A separate Claude split Stop control selects **Stop & clear queue** or **Stop only**, persists that choice per chat, and dismisses its custom popover immediately after selection. Staged rows expose send-during-turn, interrupt, cancel, and Edit-back-to-composer actions. It forwards one-shot open requests to the shared ModelPicker so transcript recovery cards can open model selection without synthetic DOM events; the picker acknowledges each request so remounts do not reopen it. 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. It holds the last `@`/`/` popover dismissal in a ref (it gates the next open, never a render) and has **three** distinct close semantics: `closeCommandMenu()` closes and forgets the dismissal, for a trigger that is resolved (a selection was made, the trigger is gone, the composer locked or reset); `dismissCommandMenu(trigger)` closes and keeps it closed while the user extends this query, used for Escape (an explicit dismissal — typing the rest of the token must not bring the menu back), for Enter/Tab with no matching row, and for the menu's own dead-query report; and `closeCommandMenuKeepingDismissal()` is the third and the one that is easy to write by accident — this trigger cannot open a menu right now (it is already a confirmed token, or still covered by an earlier dismissal), but nothing is resolved and nothing new was dismissed, so clearing the dismissal here would reopen the menu the user just escaped and recording one would suppress the menu for a trigger the user never dismissed. |
+| `AgentChatComposer.tsx`, `ComposerPromptStash.tsx`, `ComposerSmartLinkMenu.tsx`, `smartLinkChipMark.ts` | Text input, attachments, model selector, compact title-only permission controls (per-provider `PermissionModePickerOption` tables fed into the shared `components/shared/PermissionModePicker`, which the composer owns the option data for but not the control), slash commands, desktop prompt stashes, smart-link chips (`smartLinkChipMark.ts` returns the inline `currentColor` SVG brand mark each chip renders), **chat-context chips** (select assistant output → Add to chat; the chip label is `Chat context`, serializes an `<ade-chat-context>` block so the agent sees the highlighted passage, and click/backspace copy or remove it like a smart-link chip), pending-input answering (including Codex MCP form/URL elicitations), voice-dictation target registration, and parallel model-slot controls. A running chat's toolbar also shows a read-only amber tower plus the owning machine name beside the model and thinking controls; it identifies where the chat executes and directs moves to Chat actions → Handoff → Continue on another machine. A draft omits that label because its launch shelf owns the machine choice. `ComposerPromptStash` keeps its command surface mounted when the Appearance preference hides the bookmark, so Cmd/Ctrl+S remains available, but the visible bookmark stays out of the toolbar while both the composer and stash list are empty. Its menu is rendered in a viewport-clamped body portal with a bounded, scrolling list so composer overflow and short windows cannot crop it. A save first copies up to ten attached images into the owning project runtime, commits the text plus image references, then clears only the unchanged composer snapshot; restore reapplies both text and images before consuming the stash. The list renders an image thumbnail when the active runtime owns the bytes. On another synced runtime, the row retains its text and image count, labels the images as living on another machine, and refuses restore until the composer is connected to the origin runtime. Machine-bound context and non-image files are not stashed. Completed URLs are non-editable inline chips whose `data-composer-chip-text` preserves the literal URL during serialization; clicking or keyboard-activating a chip opens the Copy link / Remove link menu, and character deletion removes the whole URL token. Every chip also carries a kind-naming `data-composer-chip` attribute, and a scoped `selectionchange` effect marks intersecting chips with `data-composer-chip-selected` so the native selection paints continuously across them (overlay styling lives in `apps/desktop/src/renderer/index.css`). During an active Claude turn, its split Send control selects without dispatching among inline, after-turn, and interrupt delivery; the primary button and Enter execute the selected mode. A separate Claude split Stop control selects among the four-mode matrix — **Turn only**, **Turn + queue** (the default), **Turn + background (N jobs)**, and **Turn + queue + background (N jobs)** — persists that choice per chat, and dismisses its custom popover immediately after selection. Default Stop stops the turn and clears the queue but leaves background jobs running; per-task square stops on Chat Info and spawn cards kill one job. Staged rows expose send-during-turn, interrupt, cancel, and Edit-back-to-composer actions. It forwards one-shot open requests to the shared ModelPicker so transcript recovery cards can open model selection without synthetic DOM events; the picker acknowledges each request so remounts do not reopen it. 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. It holds the last `@`/`/` popover dismissal in a ref (it gates the next open, never a render) and has **three** distinct close semantics: `closeCommandMenu()` closes and forgets the dismissal, for a trigger that is resolved (a selection was made, the trigger is gone, the composer locked or reset); `dismissCommandMenu(trigger)` closes and keeps it closed while the user extends this query, used for Escape (an explicit dismissal — typing the rest of the token must not bring the menu back), for Enter/Tab with no matching row, and for the menu's own dead-query report; and `closeCommandMenuKeepingDismissal()` is the third and the one that is easy to write by accident — this trigger cannot open a menu right now (it is already a confirmed token, or still covered by an earlier dismissal), but nothing is resolved and nothing new was dismissed, so clearing the dismissal here would reopen the menu the user just escaped and recording one would suppress the menu for a trigger the user never dismissed. |
 | `apps/desktop/src/main/services/chat/promptStashService.ts` | Runtime-backed prompt-stash persistence. Exact prompt text, up to ten image references, their origin sync-site id, provider/model labels, and creation time are stored in the PK-only, CRR-compatible `prompt_stashes` table; newest-first retention is capped at 20 entries. Text and metadata converge across runtimes. HTTP(S) image references remain portable, while local-image bytes stay on the originating runtime: off-origin readers receive the image count but no absolute paths and cannot consume the stash. Origin-owned image files referenced by live stashes are protected from the normal seven-day temporary-attachment cleanup. |
-| `ProviderFailureRecoveryCard.tsx` | Friendly recovery surface for terminal provider capacity and usage-limit failures. Shows human-readable error identity and guidance, then offers **Retry turn** and **Choose model** only after the failed turn has released the composer. `classifyProviderFailure` delegates its `rate_limit` branch to the shared `isUsageLimitChatError`, so the card recognises exactly the set of shapes the host arms an auto-resume for. On a usage-limit failure with a known reset time it also reports the armed auto-resume (`Auto-resume scheduled for <local time>`) and a **Cancel auto-resume** button, read from `ChatAutoResumeContext` so only this card re-renders when the schedule appears or is cancelled. The context is **per chat**, so a card renders the schedule only when its own `providerFailureEventId` matches the context's `anchorEventId` — otherwise every usage-limit failure ever written to this transcript, including ones from days ago, would advertise the one armed row. That id is `<envelope timestamp>::<turnId>::<message>`: error events carry no id, `turnId` is optional on this path, and a usage limit produces the same message every time, so the timestamp is what separates two of them. |
+| `ProviderFailureRecoveryCard.tsx` | Friendly recovery surface for terminal provider capacity and usage-limit failures. Shows human-readable error identity and guidance, then offers **Retry turn** and **Choose model** only after the failed turn has released the composer. `classifyProviderFailure` delegates its `rate_limit` branch to the shared `isUsageLimitChatError`, so the card recognises exactly the set of shapes the host arms an auto-resume for. On a usage-limit failure with a known reset time it reports **Usage limit reached**, the local reset clock (`Reset at 3:40 PM (47 min)`), status text **Continue automatically**, and a **Don't continue** button. Don't continue opts the chat out of Claude SDK `autoContinueAtUsageLimit` (and cancels any ADE scheduled-work auto-resume row). The pending row arrives through `ChatAutoResumeContext` so only this card re-renders when the schedule appears or is cancelled. The context is **per chat**, so a card renders the schedule only when its own `providerFailureEventId` matches the context's `anchorEventId` — otherwise every usage-limit failure ever written to this transcript, including ones from days ago, would advertise the one armed row. That id is `<envelope timestamp>::<turnId>::<message>`: error events carry no id, `turnId` is optional on this path, and a usage limit produces the same message every time, so the timestamp is what separates two of them. |
 | `chatTurnState.ts` | Pure turn-state helpers shared by live and hydration paths. Terminal transcript evidence beats a stale active session summary, and failed-turn retry resolves the associated non-steer user message even when the optimistic row has no provider turn id. |
 | `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`, `microphonePermissionGuidance.ts`, `apps/desktop/src/renderer/services/globalVoiceRecorder.ts`, `apps/desktop/src/renderer/components/voice/*`, `apps/desktop/src/main/services/transcription/microphoneAccess.ts` | Desktop dictation UI, platform permission boundary, 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. Main asks Electron for the platform microphone status; Windows denied/restricted states return explicit Privacy & security > Microphone guidance, while unknown/not-determined states are left to Chromium's origin permission flow. The header indicator and composer pill render the same recording state. |
@@ -44,7 +44,7 @@ subagents, computer use). The pane derives all visible state from the
 | `apps/desktop/src/shared/chatScheduledWork.ts` | Pure scheduled-work derivation. Folds `scheduled_work_update` envelopes into Chat Info schedule rows for Claude wakeups, cron tasks, `/loop`, remote triggers, and background work; defines the shared Background/Schedule Earlier predicates (including fired one-shot wakeups); and formats next-fire labels. A parent turn's terminal event does not stop a background row, and background snapshots whose `sourceTaskId` belongs to a real subagent are omitted so native Agents do not appear twice. Shared by desktop, ADE Code, and mirrored by iOS. |
 | `ChatFileChangesPanel.tsx` | Turn-level file change summary for checkpoint-backed `turn_diff_summary` events, with lazy diff expansion. File rows render the lane-relative path (dimmed directory + filename) rather than a bare basename, so several `index.ts` in one turn stay distinguishable; the directory truncates first and the full path stays in the row tooltip. Diff reads come from `useChatRuntimeScope()`, so a foreign chat's file changes are fetched from the machine that has them. |
 | `RewindFilesConfirmDialog.tsx`, `rewindFilesPreview.ts` | Undo confirmation for provider-backed file rewind. Builds a message-scoped file list from provider dry-run output plus turn diff summaries, then renders per-file expandable diffs before applying `rewindFiles`. Claude uses SDK file checkpoints; Codex forks the thread before the selected turn (`thread/fork` + `beforeTurnId`) on app-server >= 0.145.0, or falls back to `thread/rollback` (latest user message only) on older servers, and restores files through ADE's git plan. |
-| `ChatSubagentsPanel.tsx` | Chat Info panel. It renders the Codex goal card, latest plan, tasks, schedule, and subagent/background rosters. Every subagent row shows a sentence-case model chip (`subagentModelAttribution`): a reported envelope `model` is ground truth, and a missing model falls back to the parent session label marked **inherited**. Running subagent and background rows derive elapsed time from the wall clock and tick once per second; terminal rows keep their final compact duration. Large sections cap active rows and add Show all; terminal rows move into one Completed fold; Clear/Restore is a visual per-session filter. Failed and pinned rows remain active, survivors keep source order, and the pane variant owns a single scroller with sticky section headers. Spawned-chat rows are identified by `childSessionId`, show the live child title supplied by `AgentChatPane` / `WorkViewArea`, keep the runtime as a small kind chip, and navigate to the child rather than opening the provider-subagent drawer. The Schedule header keeps the per-chat pause/play action. For Codex sessions the goal card stays above plan/subagent progress so the current objective stays visible without crowding the chat header. |
+| `ChatSubagentsPanel.tsx` | Chat Info panel. It renders the Codex goal card, latest plan, tasks, schedule, and subagent/background rosters. Every subagent row shows a sentence-case model chip (`subagentModelAttribution`): a reported envelope `model` is ground truth, and a missing model falls back to the parent session label marked **inherited**. Running subagent and background rows derive elapsed time from the wall clock and tick once per second; terminal rows keep their final compact duration. Large sections cap active rows and add Show all; terminal rows move into one Completed fold; Clear/Restore is a visual per-session filter. Failed and pinned rows remain active, survivors keep source order, and the pane variant owns a single scroller with sticky section headers. Spawned-chat rows are identified by `childSessionId`, show the live child title supplied by `AgentChatPane` / `WorkViewArea`, keep the runtime as a small kind chip, and navigate to the child rather than opening the provider-subagent drawer. Running native subagent rows (and background rows that carry a `sourceTaskId`) expose a square stop whose aria-label is `Stop ${agentType}`; spawned ADE chats (`chat:` task ids) are not stoppable this way. The Schedule header keeps the per-chat pause/play action. For Codex sessions the goal card stays above plan/subagent progress so the current objective stays visible without crowding the chat header. |
 | `ChatComputerUsePanel.tsx` | Complete chat proof drawer with image lightbox, inline video, availability/error states, and irreversible artifact deletion. Preview reads stay runtime-routed through `useChatRuntimeScope()` — the chat's machine, not the tab's — and the surface has no review or Finder/reveal controls. Inline transcript proof is owned by `AgentChatMessageList` + `ChatProofFilmstrip`: a collapsed count on the producing turn expands in chronology instead of pinning the newest items to the thread tail. |
 | `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. It takes a `runtimePin` and every status/target/input call routes through it, so the panel drives the machine the chat runs on rather than the one the tab is bound to; the pin also participates in the panel's `sessionStorage` key so two machines' panels cannot share state. 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. It also takes a `runtimePin` and derives its scope with `useChatRuntimeScopeForPin`, so status, device listing, launch, and interaction all reach the chat's own machine — and its project root comes from that machine's lane worktree rather than the tab's project root. See [iOS Simulator feature](../ios-simulator/README.md). |
@@ -789,15 +789,25 @@ that could not work without it.
   queue-on-send affordance, and a queued Cursor message still gets the plain
   "Message queued — will be sent when the current turn completes." notice.
 - **Queue-aware Stop button.** In an active Claude chat, Stop becomes a compact
-  split control. **Stop & clear queue** is the
-  backward-compatible default and uses a trash icon; **Stop only** keeps queued
-  messages and uses the stop-square icon. The selection is stored per chat,
-  drives the primary button and `Cmd+.`, and the custom portal menu dismisses
-  as soon as an option is selected. A successful clear that cancelled
-  ADE-attributed messages produces one transcript Undo card for eight seconds;
-  Undo calls `restoreCancelledQueue` and restores the original queued payloads.
-  With no queue, or on providers without this contract, Stop remains the
-  single-action interrupt button.
+  split control whose menu is the four-mode matrix in
+  `apps/desktop/src/shared/chatStopModes.ts`: **Turn only** (`stop_only`),
+  **Turn + queue** (`stop_and_clear`, the backward-compatible default, trash
+  icon), **Turn + background (N jobs)** (`stop_and_background`), and
+  **Turn + queue + background (N jobs)** (`stop_and_clear_and_background`).
+  The live job count is the same `activeBackgroundTaskCount` the session
+  summary already exposes. Default Stop does **not** tear down the Claude
+  query or its background jobs once `perTaskStopAffordance` is declared;
+  square stops on Chat Info / spawn cards call `ade.agentChat.stopTask` for
+  one `taskId`. The selection is stored per chat, drives the primary button
+  and `Cmd+.`, and the custom portal menu dismisses as soon as an option is
+  selected. A successful clear that cancelled ADE-attributed messages
+  produces one transcript Undo card for eight seconds; Undo calls
+  `restoreCancelledQueue` and restores the original queued payloads. With no
+  queue, or on providers without this contract, Stop remains the
+  single-action interrupt button. The TUI `/stop` command accepts the same
+  four modes (hyphen aliases `keep-queue`, `clear-queue`, `background`,
+  `clear-and-background`); it has no per-task `stopTask` control — use
+  `ade chat stop-task <session> <taskId>`.
 - **Context meter lifecycle.** `ContextUsageDial` shows a percentage only for
   `state: "measured"`. During compaction it shows an ellipsis and explains that
   the last exact reading is hidden; after a boundary without an exact post
diff --git a/docs/features/chat/transcript-and-turns.md b/docs/features/chat/transcript-and-turns.md
index 8ff7c2498..3ba2024e1 100644
--- a/docs/features/chat/transcript-and-turns.md
+++ b/docs/features/chat/transcript-and-turns.md
@@ -148,18 +148,18 @@ Two helpers summarise a parsed stream:
 | `scheduled_work_update` | Scheduled/background-work lifecycle snapshot. ADE emits it for provider-neutral action schedules and Claude `ScheduleWakeup`, `CronCreate`, `CronDelete`, `/loop`/hook snapshots, remote triggers, cron/background task lifecycle messages, and durable scheduler transitions. It carries `kind` (`wakeup`, `cron`, `loop`, `remote_trigger`, `background_task`), `status` (`scheduled`, `paused`, `running`, `fired`, `missed`, `completed`, `cancelled`, `failed`, `stopped`), provenance ids, optional cron/prompt/reason/timestamps, `firedAt`, `late`, and `durable`; `shared/chatScheduledWork.ts` folds it into active/history Chat Info rows on desktop, ADE Code, and iOS. `background_task` is additionally how the live Claude runtime reports a backgrounded shell command — it emits no subagent lifecycle events for one — so on desktop those snapshots also drive the in-thread `background_job_line`; other kinds bundle as activity. Parent turn completion does not imply background completion, and `background_task` snapshots whose `sourceTaskId` belongs to a real subagent are omitted from the Background roster (and from the job line) to avoid duplicate Agent rows. One-shots progress through `scheduled` -> `fired` -> `completed`; crons record the fire and return to `scheduled` with `lastRunAt` plus their next occurrence. |
 | `tool_use_start` / `tool_use_complete` / `tool_use_summary` | Claude SDK tool lifecycle tracking (see [Claude tool-use tracking](#claude-tool-use-tracking)). |
 | `step_boundary` | Workflow step boundary marker. |
-| `system_notice` | Non-transcript chrome: auth errors, rate limits, and file persistence hints. Special-cased renders: the "Promoted to Cursor Cloud" pill, and the `status:"subagent_spawned"` chip (emitted into the parent when a child chat session is created with a parent lineage; `detail.spawnedSession` carries the child sessionId/laneId/title and the chip deep-links via `ade:work:select-session`; the TUI shows the message line; iOS renders it through its existing system_notice mapping). |
+| `system_notice` | Non-transcript chrome: auth errors, rate limits, and file persistence hints. Special-cased renders: the "Promoted to Cursor Cloud" pill, the `status:"subagent_spawned"` chip (emitted into the parent when a child chat session is created with a parent lineage; `detail.spawnedSession` carries the child sessionId/laneId/title and the chip deep-links via `ade:work:select-session`; the TUI shows the message line; iOS renders it through its existing system_notice mapping), the quiet `status:"model_switched"` divider after a Claude Pre/PostModelSwitch, and `status:"classifier_context"` audit lines when ADE relays user-authored classifierContext. |
 | `model_handoff` | A completed provider/model transition. Desktop draws a divider with previous and current provider marks. The TUI prints `[model] Codex → Claude`. iOS maps it to a system notice (`Model handoff · Codex → Claude`). Emitted on Send when the composer model differs from the committed session. |
 | `conversation_reset` | Marks a fresh Claude conversation inside the same ADE session. ADE adopts `newConversationId` as the next SDK resume pointer, clears conversation-scoped auto-title/continuity caches while preserving a manual title, and renderers show a `New conversation` divider. |
 | `interrupt_receipt` | Records SDK UUIDs that remain queued or were cancelled after an interrupt, plus the selected `stopMode`. Clients show the full remaining count; ADE-attributed messages include their `steerId` and offer cancellation through the SDK control channel. The long-lived query remains attached while messages are still queued so the receipt stays actionable. |
-| `queue_recovery` | Bounded recovery lifecycle for Claude **Stop & clear queue**: `available` renders one Undo card for the actually cancelled ADE-attributed messages, `restored` rehydrates the original steer payloads/ids, and `expired` closes the eight-second window. Terminal recovery events suppress the earlier available card during replay. |
+| `queue_recovery` | Bounded recovery lifecycle for Claude queue-clearing Stop (`stop_and_clear` / `stop_and_clear_and_background`): `available` renders one Undo card for the actually cancelled ADE-attributed messages, `restored` rehydrates the original steer payloads/ids, and `expired` closes the eight-second window. Terminal recovery events suppress the earlier available card during replay. |
 | `command_lifecycle` | Ground-truth lifecycle for ADE-owned Claude messages (`queued`, `started`, `completed`, `cancelled`, `discarded`). ADE ignores internal UUIDs it cannot attribute, deduplicates repeated states, clears staged composer rows once execution begins, and renders only cancelled/discarded terminal anomalies to keep transcripts quiet. |
 | `claude_goal_updated` / `claude_goal_cleared` | Read-only Claude `/goal` lifecycle. The update carries the condition, iteration count, token baseline, timestamps, and optional last reason; the session summary mirrors the latest value as `claudeGoal`. |
 | `session_meta_updated` | Runtime-native session metadata update. Carries title / manual-name state, and — when a client changes the session's mode via `updateSession` — the permission/interaction mode fields (`permissionMode`, `interactionMode`, `claudePermissionMode`, `codexApprovalPolicy`/`codexSandbox`/`codexConfigSource`, `opencodePermissionMode`, `droidPermissionMode`, `cursorModeId`, `cursorModeSnapshot`). The renderer treats it as a local-touch event so Work lists and grid tiles refresh when a provider renames a session, patches the session summary with any mode fields present, and re-seeds the selected chat's composer mode controls so a mode change on another client (desktop ↔ iOS) shows up live without a refetch. All mode fields are optional; a title-only emit carries none of them. |
 | `completion_report` | Structured closeout produced by the `reportCompletion` workflow tool. |
 | `turn_diff_summary` | Git-level before/after SHA + per-file stats for a completed turn. |
 | `delegation_state` | Delegated worker state updates. |
-| `context_usage` | Provider-neutral context occupancy. Automatic Claude samples use `origin: "live" \| "snapshot" \| "compact"` and are filtered out of the transcript; `live` is the responsive stream estimate, while `snapshot`/`compact` come from the SDK control channel after initialization, settled turns, and compact completion. `state` is `measured`, `compacting`, `recalculating`, or `unknown`; non-measured states deliberately hide the old percentage. Monotonic `sampleId` plus `capturedAt` support stale-response rejection and diagnostics. The user-invoked `/context` command carries `origin: "command"` (historical undefined-origin snapshots are treated the same) and still renders its inline breakdown card. Optional typed fields (`inputTokens`, `outputTokens`, `cacheReadTokens`, `cacheCreationTokens`) carry the breakdown the meter's hover shows without reparsing the display `categories`. |
+| `context_usage` | Provider-neutral context occupancy. Automatic Claude samples use `origin: "live" \| "snapshot" \| "compact"` and are filtered out of the transcript; `live` is the responsive stream estimate, while `snapshot`/`compact` come from the SDK control channel after initialization, settled turns, and compact completion. `state` is `measured`, `compacting`, `recalculating`, or `unknown`; non-measured states deliberately hide the old percentage. Monotonic `sampleId` plus `capturedAt` support stale-response rejection and diagnostics. The user-invoked `/context` command carries `origin: "command"` (historical undefined-origin snapshots are treated the same) and still renders its inline breakdown card, classified by each category's `kind` (`used` / `free` / `buffer` / `deferred`) — never by the display name `"free"`. Optional typed fields (`inputTokens`, `outputTokens`, `cacheReadTokens`, `cacheCreationTokens`) carry the breakdown the meter's hover shows without reparsing the display `categories`. |
 | `context_compact` | Provider-neutral manual/automatic compaction lifecycle. `state: "started"` begins the boundary and `state: "completed"` may carry `preTokens`, `postTokens`, `tokensRemoved`, `durationMs`, provider, and per-session count. `trigger: "ade_fallback"` identifies ADE's guarded fallback. A completed boundary invalidates older context-meter usage on desktop, ADE Code, and iOS; exact post-compaction snapshots may refill the meter immediately, while stale same-turn aggregate counters are ignored. |
 | `web_search` | Provider-neutral web-search/fetch lifecycle; renderers group these with other tool calls instead of showing them as standalone event cards. Actions can carry `query`, `queries`, `title`, `url`, and `snippet`; desktop and iOS render URL actions as in-app-browser result chips, while the TUI keeps a concise one-line action summary. Codex 0.145 additionally emits structured `results` (an array of `{ url, title, snippet }` capped at 8 by the adapter) plus `resultsTotal` (the pre-cap hit count). Renderers thread these onto the same grouped row — desktop/iOS surface them as `Sources` chips (deduped against the action URLs) and the Sources tab, and the TUI shows up to three `title — domain` preview lines with a `+N more` tail. Codex emits native web-search items; `claudeStructuredActivity.ts` maps Claude server-tool blocks into the same event. |
 | `codex_image_generation` / `codex_image_view` | Compact generated/viewed-image lifecycle used across providers despite the legacy type prefix. Codex emits native image items, Cursor maps `generateImage`, OpenCode maps image `file` parts, and Droid maps assistant image blocks. Large stored data URIs are removed with original/omitted byte metadata. |
@@ -767,12 +767,14 @@ an idle or stale Claude session waits only for input-dispatch acceptance; the
 provider turn keeps streaming asynchronously instead of making the steer action
 wait for the full answer.
 
-Queue handling is explicit at this boundary. `stop_and_clear` is the
+Queue handling is explicit at this boundary. `stop_and_clear` (**Turn + queue**) is the
 backward-compatible default and uses `cancel_queued: true` when the Claude
 session advertises the capability; otherwise ADE interrupts first and cancels
 each attributed provider-queued message through `cancelAsyncMessage`. Local
 pending steers are cleared in the same operation. `stop_only` interrupts the
-turn but preserves the local/provider queues. A successful clear snapshots only
+turn but preserves the local/provider queues **and** background jobs.
+`stop_and_background` / `stop_and_clear_and_background` also stop running
+Claude tasks. A successful clear snapshots only
 the queued steers the runtime actually cancelled, emits `queue_recovery`, and
 accepts one `restoreCancelledQueue` call for eight seconds; expiry and restore
 are persisted as terminal recovery events so replay cannot resurrect Undo.
diff --git a/docs/features/sync-and-multi-device/ios-companion.md b/docs/features/sync-and-multi-device/ios-companion.md
index 14a1cf773..06f7546fe 100644
--- a/docs/features/sync-and-multi-device/ios-companion.md
+++ b/docs/features/sync-and-multi-device/ios-companion.md
@@ -3329,10 +3329,19 @@ the stats and shows update guidance.
   Queue-only providers (a single mode is not a choice) keep the plain
   stage-behind-turn button, matching the desktop composer. When the host
   advertises additive `chat.interruptWithQueueMode`, Claude Stop likewise
-  becomes a split control for **Stop & clear queue**
-  and **Stop only**; the per-chat choice is stored in `UserDefaults`, carries
+  becomes a split control for the four-mode matrix (**Turn only**, **Turn + queue**,
+  **Turn + background**, **Turn + queue + background**); the per-chat choice is stored in `UserDefaults`, carries
   VoiceOver labels and haptics, and falls back to legacy Stop against older
-  brains.
+  brains. Running native subagent rows, background rows with a `sourceTaskId`,
+  and timeline spawn cards expose a square stop that calls `chat.stopTask`
+  when the host advertises it; spawned ADE chats (`chat:` task ids) are not
+  stoppable this way. A parked usage-limit chat shows **Usage limit reached**,
+  the reset clock, **Continue automatically**, and **Don't continue** above the
+  composer (`WorkUsageLimitBanner`); Don't continue opts out via
+  `updateChatSession(autoContinueAtUsageLimit: false)`. iOS still uses the
+  existing context meter rather than a kind-classified `/context` card; it
+  decodes `AgentChatContextUsageCategory.kind` so a row named Free with
+  `kind: "used"` stays used.
 - **Active-turn sends are atomic, so nothing flashes through the staged strip.**
   `AgentChatSteerRequest` carries the desktop's `dispatchMode` field
   (`"inline"` / `"interrupt"`, spelled exactly as the host validates it), and
diff --git a/docs/features/sync-and-multi-device/remote-commands.md b/docs/features/sync-and-multi-device/remote-commands.md
index 4d3da0707..2b69fe8a2 100644
--- a/docs/features/sync-and-multi-device/remote-commands.md
+++ b/docs/features/sync-and-multi-device/remote-commands.md
@@ -426,23 +426,29 @@ original idempotent cancel behavior.
 
 `chat.interruptWithQueueMode` is an additive capability probe for queue-aware
 Claude Stop. It takes
-`{ sessionId, mode: "stop_and_clear" | "stop_only" }` and returns
+`{ sessionId, mode: "stop_and_clear" | "stop_only" | "stop_and_background" | "stop_and_clear_and_background" }` and returns
 `{ mode, cancelledQueuedCount, recoveryId?, recoveryExpiresAt? }`.
 `stop_and_clear` is the backward-compatible default; it asks a capable Claude
 runtime to interrupt with `cancel_queued: true`, then falls back to
-per-message cancellation where needed. `stop_only` interrupts the model turn
-and preserves queued messages. A controller that does not see this additive
+per-message cancellation where needed, and leaves background jobs running.
+`stop_only` interrupts the model turn and preserves queued messages and
+background jobs. The two `*_and_background` modes also stop running Claude
+tasks. A controller that does not see this additive
 descriptor must call legacy `chat.interrupt` without assuming the host honors
-the mode. `chat.restoreCancelledQueue` takes `{ sessionId, recoveryId }`,
+the mode. `chat.stopTask` takes `{ sessionId, taskId }`, stops that one
+Claude task, and is advertised in the mobile compatibility hello payload.
+`chat.restoreCancelledQueue` takes `{ sessionId, recoveryId }`,
 returns `{ restored, restoredCount }`, and is accepted only during the
-eight-second recovery window for that same session. Both actions are
-viewer-allowed and non-queueable: replaying either after reconnect could stop a
+eight-second recovery window for that same session. Interrupt, stopTask, and
+restore are
+viewer-allowed and non-queueable: replaying them after reconnect could stop a
 different turn or resurrect stale input.
 
 **Personal chat** (`personalChats.*`)
 - `list`, `create`, `getSummary`, `read`, `send`
 - `steer`, `cancelSteer`, `editSteer`, `dispatchSteer`,
   `cancelDispatchedSteer`, `interrupt`, `interruptWithQueueMode`,
+  `stopTask`,
   `restoreCancelledQueue`, `respondToInput`, `approve`
 - `createScheduledWork`, `cancelScheduledWork`, `setScheduledWorkPaused`
 - `updateSession`, `archive`, `unarchive`, `delete`

From 2a359d9d8746e3c05c2487e8fbed0b31968a138f Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Wed, 2 Sep 2026 18:05:05 -0400
Subject: [PATCH 2/3] fix(chat): spare default-stop subagents and parse
 stop-task flags

Default Stop now leaves background tasks running, so result-gate tests that expected them to die on interrupt were red. Review also caught --task swallowing the session id, a stale parked deadline after opt-out, and a few stop/opt-out gaps on desktop and iOS.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 apps/ade-cli/src/cli.test.ts                  | 29 +++++++++
 apps/ade-cli/src/cli.ts                       |  2 +
 .../personalChats/personalChatScope.test.ts   | 19 ++++++
 .../personalChats/personalChatScope.ts        | 11 +++-
 .../services/sync/sharedSyncListener.test.ts  | 22 ++++---
 apps/ade-cli/src/tuiClient/app.tsx            |  5 +-
 .../services/chat/agentChatService.test.ts    | 60 +++++++++++++++++++
 .../chat/claudeSubagentResultGate.test.ts     | 26 +++++++-
 .../sessions/chatSessionProjection.test.ts    | 11 ++++
 .../sessions/chatSessionProjection.ts         |  2 +-
 .../components/chat/AgentChatMessageList.tsx  |  8 ++-
 .../components/chat/AgentChatPane.tsx         |  2 +-
 .../chat/SubagentActivityCards.test.tsx       | 20 +++++++
 .../components/chat/SubagentActivityCards.tsx | 19 ++++++
 .../chat/chatTranscriptRows.test.ts           |  1 +
 .../components/chat/chatTranscriptRows.ts     | 15 ++++-
 .../src/shared/claudeContextUsage.test.ts     | 15 ++++-
 apps/desktop/src/shared/claudeContextUsage.ts |  2 +-
 .../WorkSessionDestinationView+Actions.swift  |  2 +-
 19 files changed, 247 insertions(+), 24 deletions(-)

diff --git a/apps/ade-cli/src/cli.test.ts b/apps/ade-cli/src/cli.test.ts
index ac2eba937..10bdd43f0 100644
--- a/apps/ade-cli/src/cli.test.ts
+++ b/apps/ade-cli/src/cli.test.ts
@@ -4577,6 +4577,35 @@ describe("ADE CLI", () => {
       action: "stopTask",
       args: { sessionId: "personal-1", taskId: "task-B" },
     });
+
+    const stopTaskFlagFirst = expectExecutePlan(buildCliPlan([
+      "chat",
+      "stop-task",
+      "--task",
+      "task-A",
+      "chat-1",
+    ]));
+    expect(stopTaskFlagFirst.steps[0]?.params).toMatchObject({
+      arguments: {
+        domain: "chat",
+        action: "stopTask",
+        args: { sessionId: "chat-1", taskId: "task-A" },
+      },
+    });
+
+    const personalStopTaskFlagFirst = expectExecutePlan(buildCliPlan([
+      "chat",
+      "stop-task",
+      "--personal",
+      "--task",
+      "task-B",
+      "personal-1",
+    ]));
+    expect(personalStopTaskFlagFirst.machineOnly).toBe(true);
+    expect(personalStopTaskFlagFirst.steps[0]?.params).toEqual({
+      action: "stopTask",
+      args: { sessionId: "personal-1", taskId: "task-B" },
+    });
   });
 
   it("routes chat demote, promote, and keep-reporting to spawn-kind actions", () => {
diff --git a/apps/ade-cli/src/cli.ts b/apps/ade-cli/src/cli.ts
index 004b907a9..1f183333f 100644
--- a/apps/ade-cli/src/cli.ts
+++ b/apps/ade-cli/src/cli.ts
@@ -13023,6 +13023,8 @@ const VALUE_CARRIER_FLAGS: ReadonlySet<string> = new Set([
   "--state",
   "--tab",
   "--tab-identifier",
+  "--task",
+  "--task-id",
   "--target",
   "--target-id",
   "--terminal",
diff --git a/apps/ade-cli/src/services/personalChats/personalChatScope.test.ts b/apps/ade-cli/src/services/personalChats/personalChatScope.test.ts
index 81cd8246d..ba8eae881 100644
--- a/apps/ade-cli/src/services/personalChats/personalChatScope.test.ts
+++ b/apps/ade-cli/src/services/personalChats/personalChatScope.test.ts
@@ -64,6 +64,11 @@ describe("PersonalChatScope", () => {
         restored: true,
         restoredCount: 2,
       })),
+      stopTask: vi.fn(async ({ sessionId, taskId }: { sessionId: string; taskId: string }) => ({
+        sessionId,
+        taskId,
+        stopped: true,
+      })),
       recoverTurn: vi.fn(async ({ turnId, action }) => ({
         turnId,
         action,
@@ -693,6 +698,20 @@ describe("PersonalChatScope", () => {
       mode: "stop_only",
     });
 
+    await expect(scope.call("stopTask", {
+      sessionId: "chat-1",
+      taskId: "task-A",
+    })).resolves.toEqual({
+      action: "stopTask",
+      result: { sessionId: "chat-1", taskId: "task-A", stopped: true },
+    });
+    expect(service.stopTask).toHaveBeenCalledWith({
+      sessionId: "chat-1",
+      taskId: "task-A",
+    });
+    await expect(scope.call("stopTask", { sessionId: "chat-1" })).rejects.toThrow("taskId is required.");
+    expect(service.stopTask).toHaveBeenCalledTimes(1);
+
     await expect(scope.call("restoreCancelledQueue", {
       sessionId: "chat-1",
       recoveryId: "recovery-1",
diff --git a/apps/ade-cli/src/services/personalChats/personalChatScope.ts b/apps/ade-cli/src/services/personalChats/personalChatScope.ts
index 24d158282..a7c9da228 100644
--- a/apps/ade-cli/src/services/personalChats/personalChatScope.ts
+++ b/apps/ade-cli/src/services/personalChats/personalChatScope.ts
@@ -461,10 +461,15 @@ export class PersonalChatScope {
         await this.requirePersonalSession(service, readSessionId(args));
         result = await service.interrupt(args as never);
         break;
-      case "stopTask":
-        await this.requirePersonalSession(service, readSessionId(args));
-        result = await service.stopTask(args as never);
+      case "stopTask": {
+        const sessionId = readSessionId(args);
+        await this.requirePersonalSession(service, sessionId);
+        result = await service.stopTask({
+          sessionId,
+          taskId: requiredString(args.taskId, "taskId"),
+        });
         break;
+      }
       case "restoreCancelledQueue":
         await this.requirePersonalSession(service, readSessionId(args));
         result = await service.restoreCancelledQueue(args as never);
diff --git a/apps/ade-cli/src/services/sync/sharedSyncListener.test.ts b/apps/ade-cli/src/services/sync/sharedSyncListener.test.ts
index d2ba933f3..a85168b5f 100644
--- a/apps/ade-cli/src/services/sync/sharedSyncListener.test.ts
+++ b/apps/ade-cli/src/services/sync/sharedSyncListener.test.ts
@@ -408,15 +408,19 @@ describe.runIf(process.platform === "win32")("inspectSyncListenerPort against th
     const address = holder.address();
     if (!address || typeof address === "string") throw new Error("Expected a TCP holder.");
     try {
-      const diagnosis = await inspectSyncListenerPort(address.port);
-      expect(diagnosis.port).toBe(address.port);
-      const self = diagnosis.holders.find((entry) => entry.pid === process.pid);
-      expect(self).toBeDefined();
-      // The reclaim path matches on the command line and guards PID reuse with
-      // the start time, so neither may be null for a process we own.
-      expect(self?.command).toBeTruthy();
-      expect(self?.startTime).toBeTruthy();
-      expect(Number.isFinite(Date.parse(self!.startTime!))).toBe(true);
+      // Get-NetTCPConnection can lag a newly bound LISTEN socket on a loaded
+      // Windows runner. Retry until this process is named, or the reclaim path
+      // would see "no holders" and skip same-channel reclaim. Command line and
+      // start time must be present so PID-reuse guards still work.
+      await vi.waitFor(async () => {
+        const diagnosis = await inspectSyncListenerPort(address.port);
+        expect(diagnosis.port).toBe(address.port);
+        const self = diagnosis.holders.find((entry) => entry.pid === process.pid);
+        expect(self, `holders=${JSON.stringify(diagnosis.holders)}`).toBeDefined();
+        expect(self?.command).toBeTruthy();
+        expect(self?.startTime).toBeTruthy();
+        expect(Number.isFinite(Date.parse(self!.startTime!))).toBe(true);
+      }, { timeout: 20_000, interval: 250 });
     } finally {
       await new Promise<void>((resolve) => holder.close(() => resolve()));
     }
diff --git a/apps/ade-cli/src/tuiClient/app.tsx b/apps/ade-cli/src/tuiClient/app.tsx
index dfffe349d..86114c43d 100644
--- a/apps/ade-cli/src/tuiClient/app.tsx
+++ b/apps/ade-cli/src/tuiClient/app.tsx
@@ -1335,9 +1335,10 @@ function formatTokenSummary(stats: ReturnType<typeof latestTokenStats>): string
 }
 
 function chatInterruptNotice(result: Awaited<ReturnType<typeof interruptChat>>): string {
-  const stoppedBackground = stopModeStopsBackground(parseAgentChatStopMode(result.mode));
+  const mode = parseAgentChatStopMode(result.mode);
+  const stoppedBackground = stopModeStopsBackground(mode);
   const backgroundNote = stoppedBackground ? " Background jobs were stopped." : "";
-  if (!stopModeClearsQueue(parseAgentChatStopMode(result.mode))) {
+  if (!stopModeClearsQueue(mode)) {
     return `Stopped. Queued messages are preserved.${backgroundNote}`;
   }
   if (result.cancelledQueuedCount > 0 && result.recoveryId) {
diff --git a/apps/desktop/src/main/services/chat/agentChatService.test.ts b/apps/desktop/src/main/services/chat/agentChatService.test.ts
index 938463d40..613d60448 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.test.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.test.ts
@@ -10967,6 +10967,16 @@ describe("createAgentChatService", () => {
 
       const optedOut = await service.getSessionSummary(session.id);
       expect(optedOut?.autoContinueAtUsageLimit).toBe(false);
+      await waitForEvent(
+        events,
+        (event): event is AgentChatEventEnvelope =>
+          event.event.type === "status" && event.event.turnStatus === "interrupted",
+      );
+      await waitForEvent(
+        events,
+        (event): event is AgentChatEventEnvelope =>
+          event.event.type === "done" && event.event.status === "interrupted",
+      );
       const interruptedStatuses = events.filter(
         (event) => event.event.type === "status" && event.event.turnStatus === "interrupted",
       );
@@ -15160,6 +15170,56 @@ describe("createAgentChatService", () => {
       await expect(sendPromise).resolves.toBeUndefined();
     });
 
+    it("does not stop a task that belongs to a different session", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      let streamCall = 0;
+      let warmupComplete = false;
+      let hangResolve: (() => void) | null = null;
+      const hangPromise = new Promise<void>((resolve) => { hangResolve = resolve; });
+      const send = vi.fn().mockResolvedValue(undefined);
+      const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+      const stopTask = vi.fn().mockResolvedValue(undefined);
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall <= 2) {
+          yield { type: "system", subtype: "init", session_id: `sdk-stop-cross-${streamCall}`, slash_commands: [] };
+          if (streamCall === 2) warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        yield { type: "system", subtype: "task_started", task_id: "task-A", description: "review A" };
+        await hangPromise;
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      let queryN = 0;
+      vi.mocked(claudeSdkCreateSessionCompat).mockImplementation(() => {
+        queryN += 1;
+        return {
+          send,
+          stream,
+          close: vi.fn(),
+          sessionId: `sdk-stop-cross-${queryN}`,
+          setPermissionMode,
+          stopTask,
+        } as any;
+      });
+      const { service } = createService({ onEvent: (event: AgentChatEventEnvelope) => events.push(event) });
+      const session = await service.createSession({ laneId: "lane-1", provider: "claude", model: "sonnet" });
+      const other = await service.createSession({ laneId: "lane-1", provider: "claude", model: "sonnet" });
+      await vi.waitFor(() => { expect(warmupComplete).toBe(true); });
+      const sendPromise = service.sendMessage({ sessionId: session.id, text: "spawn A" });
+
+      await waitForEvent(events, (e): e is AgentChatEventEnvelope =>
+        e.event.type === "subagent_started" && (e.event as any).taskId === "task-A");
+
+      await expect(service.stopTask({ sessionId: other.id, taskId: "task-A" }))
+        .resolves.toMatchObject({ stopped: false, reason: "That task is not running." });
+      expect(stopTask).not.toHaveBeenCalled();
+
+      hangResolve!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+
     it("splits the background level into working and monitoring counts on the session summary", async () => {
       // The classifier is a DENYLIST: only a type whose whole job is to watch
       // (`monitor`) reads as monitoring. A generic backgrounded shell, a real
diff --git a/apps/desktop/src/main/services/chat/claudeSubagentResultGate.test.ts b/apps/desktop/src/main/services/chat/claudeSubagentResultGate.test.ts
index eec9eafb5..bfcd115b2 100644
--- a/apps/desktop/src/main/services/chat/claudeSubagentResultGate.test.ts
+++ b/apps/desktop/src/main/services/chat/claudeSubagentResultGate.test.ts
@@ -124,6 +124,7 @@ vi.mock("./permissionMapping", () => ({
 vi.mock("../../../shared/chatTranscript", () => ({ parseAgentChatTranscript: vi.fn(() => []) }));
 
 import { createAgentChatService } from "./agentChatService";
+import type { AgentChatStopMode } from "../../../shared/chatStopModes";
 import type { AgentChatEventEnvelope } from "../../../shared/types";
 
 let tempRoot: string;
@@ -255,6 +256,7 @@ function resultsFor(events: AgentChatEventEnvelope[], taskId: string) {
 async function interruptAfterEvent(
   messages: Array<Record<string, unknown>>,
   ready: (event: AgentChatEventEnvelope) => boolean,
+  mode?: AgentChatStopMode,
 ) {
   const harness = await createSession(messages, true);
   const sendPromise = harness.service.sendMessage({
@@ -264,7 +266,10 @@ async function interruptAfterEvent(
   await vi.waitFor(() => {
     expect(harness.events.some(ready)).toBe(true);
   });
-  await harness.service.interrupt({ sessionId: harness.session.id });
+  await harness.service.interrupt({
+    sessionId: harness.session.id,
+    ...(mode ? { mode } : {}),
+  });
   claudeSdk.release?.();
   await expect(sendPromise).resolves.toBeUndefined();
   return harness.events;
@@ -300,7 +305,7 @@ describe("Claude subagent result gate", () => {
     expect(resultsFor(events, taskId)).toHaveLength(0);
   });
 
-  it("emits exactly one stopped result for a subagent that emitted started", async () => {
+  it("spares a started subagent on default interrupt", async () => {
     const taskId = "real-subagent";
     const events = await interruptAfterEvent([
       {
@@ -312,6 +317,21 @@ describe("Claude subagent result gate", () => {
       },
     ], (envelope) => envelope.event.type === "subagent_started" && envelope.event.taskId === taskId);
 
+    expect(resultsFor(events, taskId)).toHaveLength(0);
+  });
+
+  it("emits exactly one stopped result for a subagent when interrupt stops background work", async () => {
+    const taskId = "real-subagent";
+    const events = await interruptAfterEvent([
+      {
+        type: "system",
+        subtype: "task_started",
+        task_id: taskId,
+        description: "Inspect the chat pipeline",
+        task_type: "subagent",
+      },
+    ], (envelope) => envelope.event.type === "subagent_started" && envelope.event.taskId === taskId, "stop_and_clear_and_background");
+
     expect(resultsFor(events, taskId)).toEqual([
       expect.objectContaining({ type: "subagent_result", taskId, status: "stopped" }),
     ]);
@@ -366,7 +386,7 @@ describe("Claude subagent result gate", () => {
         task_id: taskId,
         patch: { status: "in_progress", description: `Unknown ${taskId}` },
       })),
-    ], (envelope) => envelope.event.type === "subagent_progress" && envelope.event.taskId === strayIds.at(-1));
+    ], (envelope) => envelope.event.type === "subagent_progress" && envelope.event.taskId === strayIds.at(-1), "stop_and_clear_and_background");
 
     const stoppedResults = events.filter((envelope) =>
       envelope.event.type === "subagent_result" && envelope.event.status === "stopped"
diff --git a/apps/desktop/src/main/services/sessions/chatSessionProjection.test.ts b/apps/desktop/src/main/services/sessions/chatSessionProjection.test.ts
index e968de1c1..774eabeb6 100644
--- a/apps/desktop/src/main/services/sessions/chatSessionProjection.test.ts
+++ b/apps/desktop/src/main/services/sessions/chatSessionProjection.test.ts
@@ -104,6 +104,17 @@ describe("chatSessionProjection", () => {
     expect(projected.cursorCloudAgentId).toBe("bc-cloud-agent");
   });
 
+  it("clears a parked usage-limit deadline when the chat no longer has one", () => {
+    const projected = projectChatOntoSession({
+      ...session(),
+      usageLimitParkedUntil: "2026-08-17T12:47:00.000Z",
+    }, chat({
+      usageLimitParkedUntil: null,
+    }));
+
+    expect(projected.usageLimitParkedUntil ?? null).toBeNull();
+  });
+
   it("projects model handoff history onto the Work row", () => {
     const projected = projectChatOntoSession(session(), chat({
       modelHandoffHistory: [{
diff --git a/apps/desktop/src/main/services/sessions/chatSessionProjection.ts b/apps/desktop/src/main/services/sessions/chatSessionProjection.ts
index 4ffe87692..98f98a1c1 100644
--- a/apps/desktop/src/main/services/sessions/chatSessionProjection.ts
+++ b/apps/desktop/src/main/services/sessions/chatSessionProjection.ts
@@ -75,7 +75,7 @@ export function projectChatOntoSession(
     ...session,
     currentTurnStartedAt: chat.currentTurnStartedAt ?? null,
     nextWakeAt: chat.nextWakeAt,
-    ...(chat.usageLimitParkedUntil ? { usageLimitParkedUntil: chat.usageLimitParkedUntil } : {}),
+    usageLimitParkedUntil: chat.usageLimitParkedUntil ?? null,
     chatActivityMode: chat.interactionMode === "plan" ? "planning" : null,
     activeBackgroundTaskCount: chat.activeBackgroundTaskCount ?? 0,
     ...(chat.backgroundWork ? { backgroundWork: chat.backgroundWork } : {}),
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
index cd80deb1c..b08cb53cb 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
@@ -2918,6 +2918,7 @@ function renderEvent(
   /* ── Background command one-liner (live from spawn through finish), and the
         folded run of identical jobs — same line, same `open` target ── */
   if (event.type === "background_job_line" || event.type === "background_job_group") {
+    const taskId = event.type === "background_job_line" ? event.taskId : null;
     return (
       <BackgroundJobLine
         event={event}
@@ -2928,8 +2929,13 @@ function renderEvent(
         // selecting an agent. Omitted entirely on a host with no actions pane,
         // so the affordance never renders as a button that does nothing.
         onOpenBackgroundJobs={options?.chatInfoHostAvailable
-          ? () => openChatInfoFromActivity(options?.sessionId, null)
+          ? () => openChatInfoFromActivity(options?.sessionId, taskId ?? null)
           : undefined}
+        onStop={
+          event.type === "background_job_line" && taskId && options?.onStopSubagent
+            ? (id) => options.onStopSubagent?.(id)
+            : undefined
+        }
       />
     );
   }
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
index ff9923b4f..a7d022416 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
@@ -12250,7 +12250,7 @@ export function AgentChatPane({
           });
           return;
         }
-        setError("Per-task stop is only available for Claude chats.");
+        setError("Per-task stop is not available for this provider.");
       } : undefined}
       onStopSubagent={selectedSessionId && (selectedSession?.provider ?? sessionProvider) === "claude"
         ? (snapshot) => {
diff --git a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.test.tsx b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.test.tsx
index 21c4438f8..82f573f00 100644
--- a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.test.tsx
@@ -141,4 +141,24 @@ describe("BackgroundJobLine", () => {
     );
     expect(screen.getByText(/npm install/).textContent).not.toContain("×");
   });
+
+  it("stops a running job by provider task id", () => {
+    const onStop = vi.fn();
+    render(
+      <BackgroundJobLine
+        event={{
+          type: "background_job_line",
+          agentKey: "bg-1",
+          label: "npm install",
+          startedAt: "2026-08-06T10:00:00.000Z",
+          status: "running",
+          taskId: "bg-1",
+        }}
+        onStop={onStop}
+      />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: /stop npm install/i }));
+    expect(onStop).toHaveBeenCalledTimes(1);
+    expect(onStop).toHaveBeenCalledWith("bg-1");
+  });
 });
diff --git a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx
index 8f90b3682..7db543079 100644
--- a/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx
+++ b/apps/desktop/src/renderer/components/chat/SubagentActivityCards.tsx
@@ -427,6 +427,7 @@ export function BackgroundJobLine({
   event,
   sessionEnded = false,
   onOpenBackgroundJobs,
+  onStop,
 }: {
   event: BackgroundJobLineRenderEvent | BackgroundJobGroupRenderEvent;
   /**
@@ -438,6 +439,8 @@ export function BackgroundJobLine({
    */
   sessionEnded?: boolean;
   onOpenBackgroundJobs?: () => void;
+  /** Stop this one running job by provider task id. Groups omit this. */
+  onStop?: (taskId: string) => void;
 }) {
   const running = event.status === "running";
   // A frozen counter is still a wrong counter: an archived job that never got a
@@ -449,6 +452,7 @@ export function BackgroundJobLine({
   const ok = event.status === "completed";
   const duration = formatSubagentDurationMs(running ? (stale ? null : liveMs) : event.durationMs);
   const count = event.type === "background_job_group" ? event.count : 1;
+  const jobTaskId = event.type === "background_job_line" ? event.taskId ?? null : null;
   const parts = [
     count > 1 ? `${event.label} ×${count}` : event.label,
     !running && typeof event.exitCode === "number" ? `exit ${event.exitCode}` : null,
@@ -486,6 +490,21 @@ export function BackgroundJobLine({
           Background · {parts.join(" · ")}
         </span>
       </span>
+      {running && onStop && jobTaskId ? (
+        <button
+          type="button"
+          aria-label={`Stop ${event.label}`}
+          title="Stop this background job"
+          onClick={(clickEvent) => {
+            clickEvent.preventDefault();
+            clickEvent.stopPropagation();
+            onStop(jobTaskId);
+          }}
+          className="inline-flex h-5 w-5 shrink-0 items-center justify-center rounded-md text-current opacity-70 transition-opacity hover:bg-rose-500/10 hover:text-rose-200/90 hover:opacity-100 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-rose-300/40"
+        >
+          <Square size={8} weight="fill" aria-hidden />
+        </button>
+      ) : null}
       {onOpenBackgroundJobs ? (
         <button
           type="button"
diff --git a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
index edc5ddd2e..a21c5265f 100644
--- a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
+++ b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
@@ -3045,6 +3045,7 @@ describe("subagent two-row rendering", () => {
     if (rows[0]!.event.type !== "background_job_line") throw new Error("Expected background job line");
     expect(rows[0]!.event.status).toBe("running");
     expect(rows[0]!.event.label).toBe("npm install");
+    expect(rows[0]!.event.taskId).toBe("bg-1");
     expect(rows[0]!.key).toBe("background-chip:bg-1");
   });
 
diff --git a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
index 60701c590..1ee88550d 100644
--- a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
+++ b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
@@ -243,6 +243,8 @@ export type BackgroundJobLineRenderEvent = {
   agentKey: string;
   label: string;
   startedAt: string | null;
+  /** Provider task id when ADE can stop this job via `stopTask`. */
+  taskId?: string | null;
 } & (
   | { status: "running" }
   | {
@@ -1596,6 +1598,7 @@ function handleSubagentLifecycleEvent(
           label: backgroundJobLabel(state),
           status: "running",
           startedAt: state.startedAt,
+          taskId: state.taskId,
         });
       }
       return true;
@@ -1651,6 +1654,7 @@ function handleSubagentLifecycleEvent(
       exitCode: backgroundExitCode(event),
       durationMs: durationMsBetween(state.startedAt, timestamp),
       startedAt: state.startedAt,
+      taskId: state.taskId,
     });
     return true;
   }
@@ -2221,19 +2225,28 @@ export function appendCollapsedChatTranscriptEvent(
     const label = backgroundCommandLabel(event.title ?? "")
       || event.title
       || "Background command";
+    const providerTaskId = event.sourceTaskId?.trim() || null;
     upsertBackgroundJobLine(
       rows,
       context,
       expectedKey,
       envelope.timestamp,
       status === "running"
-        ? { type: "background_job_line", agentKey: taskKey, label, startedAt, status }
+        ? {
+            type: "background_job_line",
+            agentKey: taskKey,
+            label,
+            startedAt,
+            status,
+            taskId: providerTaskId,
+          }
         : {
             type: "background_job_line",
             agentKey: taskKey,
             label,
             startedAt,
             status,
+            taskId: providerTaskId,
             // The scheduled-work wire format carries no exit code; duration is
             // measured from the row's own first sighting instead of trusting
             // the free-text summary the emitter composes.
diff --git a/apps/desktop/src/shared/claudeContextUsage.test.ts b/apps/desktop/src/shared/claudeContextUsage.test.ts
index dbc4a2ecd..a06932625 100644
--- a/apps/desktop/src/shared/claudeContextUsage.test.ts
+++ b/apps/desktop/src/shared/claudeContextUsage.test.ts
@@ -68,6 +68,19 @@ describe("Claude context usage kind classification", () => {
       categories: [{ name: "Messages", tokens: 40, kind: "used" }],
     });
     expect(usage.categories.some((row) => row.kind === "free" && row.tokens === 60)).toBe(true);
-    expect(usage.categories.some((row) => row.name.trim().toLowerCase() === "free" && row.kind !== "free")).toBe(false);
+    expect(usage.categories.filter((row) => row.name.trim().toLowerCase() === "free" && row.kind !== "free")).toEqual([]);
+  });
+
+  it("reads mcp_servers when the payload is a name-to-token map", () => {
+    const usage = normalizeClaudeContextUsage({
+      totalTokens: 18_000,
+      maxTokens: 200_000,
+      categories: [
+        { name: "MCP tools", tokens: 18_000, kind: "used", mcp_servers: { posthog: 18_000 } },
+      ],
+    });
+    expect(usage.categories.find((row) => row.name === "MCP tools")?.mcpServers).toEqual([
+      { name: "posthog", tokens: 18_000 },
+    ]);
   });
 });
diff --git a/apps/desktop/src/shared/claudeContextUsage.ts b/apps/desktop/src/shared/claudeContextUsage.ts
index 036539491..d4bf5f890 100644
--- a/apps/desktop/src/shared/claudeContextUsage.ts
+++ b/apps/desktop/src/shared/claudeContextUsage.ts
@@ -73,7 +73,7 @@ function readMcpServers(category: Record<string, unknown>): ClaudeContextMcpServ
   };
   const listed = fromArray(category.mcpServers ?? category.servers ?? category.mcp_servers);
   if (listed.length) return listed;
-  const map = category.mcpServers ?? category.servers;
+  const map = category.mcpServers ?? category.servers ?? category.mcp_servers;
   if (!map || typeof map !== "object" || Array.isArray(map)) return [];
   return Object.entries(map as Record<string, unknown>).flatMap(([name, tokens]) => {
     const count = nonNegativeInt(tokens);
diff --git a/apps/ios/ADE/Views/Work/WorkSessionDestinationView+Actions.swift b/apps/ios/ADE/Views/Work/WorkSessionDestinationView+Actions.swift
index 02f34aa56..cccffbfb5 100644
--- a/apps/ios/ADE/Views/Work/WorkSessionDestinationView+Actions.swift
+++ b/apps/ios/ADE/Views/Work/WorkSessionDestinationView+Actions.swift
@@ -256,7 +256,7 @@ extension WorkSessionDestinationView {
   @MainActor
   func optOutUsageLimitAutoContinue() async {
     do {
-      if let schedule = WorkUsageLimitOptOut.pendingSchedule(chatSummary?.scheduledWork),
+      if let schedule = WorkUsageLimitOptOut.pendingSchedule(composerChatSummary?.scheduledWork),
          syncService.canInvokeChatRemoteAction("chat.cancelScheduledWork", sessionId: sessionId) {
         _ = try? await syncService.cancelScheduledWork(sessionId: sessionId, scheduleId: schedule.id)
       }

From 42c55a162ce65cb75d825c0431d26d7834616b4c Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Wed, 2 Sep 2026 18:34:37 -0400
Subject: [PATCH 3/3] fix(test): give Windows sync-host hello more time

windows-foundation timed out waiting 5s for hello_ok after pairing on a loaded runner. The product handshake is unchanged; only the test wait is longer on win32.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../src/main/services/sync/syncHostService.test.ts        | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/apps/desktop/src/main/services/sync/syncHostService.test.ts b/apps/desktop/src/main/services/sync/syncHostService.test.ts
index 8ab19dfd6..5c7575bc0 100644
--- a/apps/desktop/src/main/services/sync/syncHostService.test.ts
+++ b/apps/desktop/src/main/services/sync/syncHostService.test.ts
@@ -93,6 +93,9 @@ function toText(raw: Buffer | ArrayBuffer | Buffer[]): string {
   return Buffer.from(raw).toString("utf8");
 }
 
+/** Hello after pairing can stall on a loaded Windows runner; 5s was too tight. */
+const SYNC_TEST_HELLO_TIMEOUT_MS = process.platform === "win32" ? 20_000 : 5_000;
+
 function createMessageQueue(ws: WebSocket) {
   const queued: ParsedSyncEnvelope[] = [];
   const waiters: Array<{
@@ -124,7 +127,8 @@ function createMessageQueue(ws: WebSocket) {
         const timer = setTimeout(() => {
           const index = waiters.findIndex((entry) => entry.resolve === resolve);
           if (index >= 0) waiters.splice(index, 1);
-          reject(new Error(`Timed out waiting for ${type}`));
+          const queuedTypes = queued.map((entry) => entry.type).join(",") || "none";
+          reject(new Error(`Timed out waiting for ${type} (queued: ${queuedTypes})`));
         }, timeoutMs);
         waiters.push({ type, resolve, reject, timer });
       });
@@ -167,7 +171,7 @@ async function connectClient(args: {
     },
     compressionThresholdBytes: 100_000,
   }));
-  const helloOk = await queue.next("hello_ok");
+  const helloOk = await queue.next("hello_ok", SYNC_TEST_HELLO_TIMEOUT_MS);
   return {
     ws,
     queue,