diff --git a/desktop/src/components/activity/SessionActivityPanel.test.tsx b/desktop/src/components/activity/SessionActivityPanel.test.tsx
index e93d1f40..f24518b9 100644
--- a/desktop/src/components/activity/SessionActivityPanel.test.tsx
+++ b/desktop/src/components/activity/SessionActivityPanel.test.tsx
@@ -52,6 +52,7 @@ vi.mock('../../i18n', () => ({
       'session.activity.status.inProgress': 'In progress',
       'session.activity.status.completed': 'Completed',
       'session.activity.status.running': 'Running',
+      'session.activity.status.stopping': 'Stopping',
       'session.activity.status.failed': 'Failed',
       'session.activity.status.stopped': 'Stopped',
       'session.activity.status.idle': 'Idle',
@@ -406,6 +407,41 @@ describe('SessionActivityPanel', () => {
     expect(screen.queryByRole('button', { name: 'Stop background task Background reviewer' })).not.toBeInTheDocument()
   })
 
+  it('stops SubAgent motion while a global stop request is settling', () => {
+    render(
+      <SessionActivityPanel
+        model={model({
+          sections: {
+            ...model().sections,
+            tasks: { id: 'tasks', title: 'Tasks', emptyLabel: 'No tasks', rows: [] },
+            subagents: {
+              id: 'subagents',
+              title: 'SubAgents',
+              emptyLabel: 'No SubAgents',
+              rows: [{
+                id: 'agent-task-1',
+                section: 'subagents',
+                label: 'Background reviewer',
+                status: 'running',
+                taskId: 'agent-task-1',
+                toolUseId: 'agent-tool-1',
+                openable: true,
+              }],
+            },
+          },
+        })}
+        open
+        onClose={vi.fn()}
+        onOpenSubagent={vi.fn()}
+        stoppingBackgroundTaskIds={{ 'agent-task-1': true }}
+      />,
+    )
+
+    expect(screen.getByText('Stopping')).toBeInTheDocument()
+    expect(screen.getByTestId('agent-mascot')).toHaveAttribute('data-agent-mascot-motion', 'still')
+    expect(screen.queryByTestId('agent-mascot-motion-ring')).not.toBeInTheDocument()
+  })
+
   it('keeps SubAgent rows to name and status instead of result previews', () => {
     render(
       <SessionActivityPanel
diff --git a/desktop/src/components/activity/SessionActivityPanel.tsx b/desktop/src/components/activity/SessionActivityPanel.tsx
index 15561b23..d1f5b652 100644
--- a/desktop/src/components/activity/SessionActivityPanel.tsx
+++ b/desktop/src/components/activity/SessionActivityPanel.tsx
@@ -227,9 +227,17 @@ function getTaskProgress(rows: ActivityRow[]): { completed: number; total: numbe
   return { completed, total: rows.length, percent: Math.round((completed / rows.length) * 100) }
 }
 
-function ActivityRowIcon({ row, sessionId }: { row: ActivityRow; sessionId: string }) {
+function ActivityRowIcon({
+  row,
+  sessionId,
+  status = row.status,
+}: {
+  row: ActivityRow
+  sessionId: string
+  status?: ActivityRow['status']
+}) {
   if (row.section === 'subagents') {
-    return <AgentMascot seed={`${sessionId}:${row.toolUseId ?? row.taskId ?? row.id}`} status={row.status} />
+    return <AgentMascot seed={`${sessionId}:${row.toolUseId ?? row.taskId ?? row.id}`} status={status} />
   }
 
   const Icon = getRowIcon(row)
@@ -316,6 +324,11 @@ function ActivityRowView({
 }) {
   const t = useTranslation()
   const isTask = row.section === 'tasks'
+  const isStoppingSubagent = row.section === 'subagents' && row.status === 'running' && stoppingBackgroundTask
+  const displayStatus: ActivityRow['status'] = isStoppingSubagent ? 'pending' : row.status
+  const statusLabel = isStoppingSubagent
+    ? t('session.activity.status.stopping')
+    : getActivityStatusLabel(row.status, t)
   const label = row.taskHistory
     ? t('session.activity.tasks.earlier')
     : row.label
@@ -335,7 +348,7 @@ function ActivityRowView({
       {isTask ? (
         <TaskStatusMarker status={row.status} t={t} />
       ) : (
-        <ActivityRowIcon row={row} sessionId={sessionId} />
+        <ActivityRowIcon row={row} sessionId={sessionId} status={displayStatus} />
       )}
       <span className="min-w-0 flex-1 truncate text-left">
         <span
@@ -355,8 +368,8 @@ function ActivityRowView({
       </span>
       {isTask ? null : (
         <ActivityStatusIndicator
-          status={row.status}
-          label={getActivityStatusLabel(row.status, t)}
+          status={displayStatus}
+          label={statusLabel}
           animated={row.section !== 'subagents'}
         />
       )}
@@ -389,7 +402,6 @@ function ActivityRowView({
   }
 
   if (row.section === 'subagents' && row.openable && row.toolUseId) {
-    const statusLabel = getActivityStatusLabel(row.status, t)
     const openButton = (
       <button
         type="button"
diff --git a/desktop/src/components/activity/sessionActivityModel.test.ts b/desktop/src/components/activity/sessionActivityModel.test.ts
index 374a5f47..4cc57080 100644
--- a/desktop/src/components/activity/sessionActivityModel.test.ts
+++ b/desktop/src/components/activity/sessionActivityModel.test.ts
@@ -39,6 +39,20 @@ const notification = (overrides: Partial<AgentTaskNotification>): AgentTaskNotif
   ...overrides,
 })
 
+const successfulTaskUpdateResult = (
+  toolUseId: string,
+  taskId: string,
+  timestamp: number,
+  updatedFields = 'status',
+): Extract<UIMessage, { type: 'tool_result' }> => ({
+  id: `${toolUseId}-result`,
+  type: 'tool_result',
+  toolUseId,
+  content: `Updated task #${taskId} ${updatedFields}`,
+  isError: false,
+  timestamp,
+})
+
 const agentMessages: UIMessage[] = [
   {
     id: 'agent-tool-1',
@@ -509,14 +523,16 @@ describe('buildSessionActivityModel', () => {
           input: { taskId: '1', status: 'completed' },
           timestamp: 1004,
         },
+        successfulTaskUpdateResult('task-update-call-1', '1', 1005),
         {
           id: 'task-update-2',
           type: 'tool_use',
           toolName: 'TaskUpdate',
           toolUseId: 'task-update-call-2',
           input: { taskId: '2', status: 'in_progress', activeForm: '正在补充边界测试' },
-          timestamp: 1005,
+          timestamp: 1006,
         },
+        successfulTaskUpdateResult('task-update-call-2', '2', 1007),
       ],
       tasks: [],
       completedAndDismissed: false,
@@ -541,6 +557,228 @@ describe('buildSessionActivityModel', () => {
     expect(model.badgeCount).toBe(1)
   })
 
+  it('keeps the last successful status when a later TaskUpdate fails', () => {
+    const model = buildSessionActivityModel({
+      sessionId: 'session-1',
+      messages: [
+        {
+          id: 'task-create-1',
+          type: 'tool_use',
+          toolName: 'TaskCreate',
+          toolUseId: 'task-create-call-1',
+          input: { subject: '补充活动面板回归测试' },
+          timestamp: 1000,
+        },
+        {
+          id: 'task-create-result-1',
+          type: 'tool_result',
+          toolUseId: 'task-create-call-1',
+          content: 'Task #2 created successfully: 补充活动面板回归测试',
+          isError: false,
+          timestamp: 1001,
+        },
+        {
+          id: 'task-update-completed',
+          type: 'tool_use',
+          toolName: 'TaskUpdate',
+          toolUseId: 'task-update-completed-call',
+          input: { taskId: '2', status: 'completed' },
+          timestamp: 1002,
+        },
+        {
+          id: 'task-update-completed-result',
+          type: 'tool_result',
+          toolUseId: 'task-update-completed-call',
+          content: 'Updated task #2 status\n\nTask completed. Call TaskList now to find your next available task.',
+          isError: false,
+          timestamp: 1003,
+        },
+        {
+          id: 'task-update-reopen',
+          type: 'tool_use',
+          toolName: 'TaskUpdate',
+          toolUseId: 'task-update-reopen-call',
+          input: { taskId: '2', status: 'in_progress', activeForm: '正在重新检查活动面板' },
+          timestamp: 1004,
+        },
+        {
+          id: 'task-update-reopen-result',
+          type: 'tool_result',
+          toolUseId: 'task-update-reopen-call',
+          content: 'Task not found',
+          // TaskUpdate deliberately reports this as a non-error so sibling
+          // tool calls are not cancelled.
+          isError: false,
+          timestamp: 1005,
+        },
+      ],
+      tasks: [],
+      completedAndDismissed: false,
+      backgroundTasks: [],
+      agentNotifications: [],
+    })
+
+    expect(model.sections.tasks.rows).toEqual([
+      expect.objectContaining({
+        id: '2',
+        label: '补充活动面板回归测试',
+        status: 'completed',
+      }),
+    ])
+    expect(model.badgeCount).toBe(0)
+  })
+
+  it('does not apply a stopped, unconfirmed TaskUpdate optimistically', () => {
+    const model = buildSessionActivityModel({
+      sessionId: 'session-1',
+      messages: [
+        {
+          id: 'task-create-1',
+          type: 'tool_use',
+          toolName: 'TaskCreate',
+          toolUseId: 'task-create-call-1',
+          input: { subject: '核对最终状态' },
+          timestamp: 1000,
+        },
+        {
+          id: 'task-create-result-1',
+          type: 'tool_result',
+          toolUseId: 'task-create-call-1',
+          content: 'Task #1 created successfully: 核对最终状态',
+          isError: false,
+          timestamp: 1001,
+        },
+        {
+          id: 'task-update-completed',
+          type: 'tool_use',
+          toolName: 'TaskUpdate',
+          toolUseId: 'task-update-completed-call',
+          input: { taskId: '1', status: 'completed' },
+          timestamp: 1002,
+        },
+        successfulTaskUpdateResult('task-update-completed-call', '1', 1003),
+        {
+          id: 'task-update-reopen',
+          type: 'tool_use',
+          toolName: 'TaskUpdate',
+          toolUseId: 'task-update-reopen-call',
+          input: { taskId: '1', status: 'in_progress' },
+          timestamp: 1004,
+          status: 'stopped',
+        },
+      ],
+      tasks: [],
+      completedAndDismissed: false,
+      backgroundTasks: [],
+      agentNotifications: [],
+    })
+
+    expect(model.sections.tasks.rows).toEqual([
+      expect.objectContaining({ id: '1', status: 'completed' }),
+    ])
+    expect(model.badgeCount).toBe(0)
+  })
+
+  it('matches a TaskUpdate result that arrives after an optimistic queued message', () => {
+    const model = buildSessionActivityModel({
+      sessionId: 'session-1',
+      messages: [
+        {
+          id: 'task-create-1',
+          type: 'tool_use',
+          toolName: 'TaskCreate',
+          toolUseId: 'task-create-call-1',
+          input: { subject: '完成当前任务' },
+          timestamp: 1000,
+        },
+        {
+          id: 'task-create-result-1',
+          type: 'tool_result',
+          toolUseId: 'task-create-call-1',
+          content: 'Task #1 created successfully: 完成当前任务',
+          isError: false,
+          timestamp: 1001,
+        },
+        {
+          id: 'task-update-completed',
+          type: 'tool_use',
+          toolName: 'TaskUpdate',
+          toolUseId: 'task-update-completed-call',
+          input: { taskId: '1', status: 'completed' },
+          timestamp: 1002,
+        },
+        {
+          id: 'queued-user-message',
+          type: 'user_text',
+          content: '完成后继续检查下一项',
+          timestamp: 1003,
+          optimisticQueued: true,
+        },
+        successfulTaskUpdateResult('task-update-completed-call', '1', 1004),
+      ],
+      tasks: [],
+      completedAndDismissed: false,
+      backgroundTasks: [],
+      agentNotifications: [],
+    })
+
+    expect(model.sections.tasks.rows).toEqual([
+      expect.objectContaining({ id: '1', label: '完成当前任务', status: 'completed' }),
+    ])
+    expect(model.badgeCount).toBe(0)
+  })
+
+  it('preserves status when a successful TaskUpdate changes another field', () => {
+    const model = buildSessionActivityModel({
+      sessionId: 'session-1',
+      messages: [
+        {
+          id: 'task-create-1',
+          type: 'tool_use',
+          toolName: 'TaskCreate',
+          toolUseId: 'task-create-call-1',
+          input: { subject: '保留完成状态' },
+          timestamp: 1000,
+        },
+        {
+          id: 'task-create-result-1',
+          type: 'tool_result',
+          toolUseId: 'task-create-call-1',
+          content: 'Task #1 created successfully: 保留完成状态',
+          isError: false,
+          timestamp: 1001,
+        },
+        {
+          id: 'task-update-completed',
+          type: 'tool_use',
+          toolName: 'TaskUpdate',
+          toolUseId: 'task-update-completed-call',
+          input: { taskId: '1', status: 'completed' },
+          timestamp: 1002,
+        },
+        successfulTaskUpdateResult('task-update-completed-call', '1', 1003),
+        {
+          id: 'task-update-owner',
+          type: 'tool_use',
+          toolName: 'TaskUpdate',
+          toolUseId: 'task-update-owner-call',
+          input: { taskId: '1', owner: 'reviewer' },
+          timestamp: 1004,
+        },
+        successfulTaskUpdateResult('task-update-owner-call', '1', 1005, 'owner'),
+      ],
+      tasks: [],
+      completedAndDismissed: false,
+      backgroundTasks: [],
+      agentNotifications: [],
+    })
+
+    expect(model.sections.tasks.rows).toEqual([
+      expect.objectContaining({ id: '1', status: 'completed' }),
+    ])
+    expect(model.badgeCount).toBe(0)
+  })
+
   it('drops tasks deleted by TaskUpdate instead of showing them as pending', () => {
     const model = buildSessionActivityModel({
       sessionId: 'session-1',
@@ -585,14 +823,16 @@ describe('buildSessionActivityModel', () => {
           input: { taskId: '2', status: 'completed' },
           timestamp: 1004,
         },
+        successfulTaskUpdateResult('task-update-call-1', '2', 1005),
         {
           id: 'task-update-2',
           type: 'tool_use',
           toolName: 'TaskUpdate',
           toolUseId: 'task-update-call-2',
           input: { taskId: '1', status: 'deleted' },
-          timestamp: 1005,
+          timestamp: 1006,
         },
+        successfulTaskUpdateResult('task-update-call-2', '1', 1007, 'deleted'),
       ],
       tasks: [task({ id: '2', subject: '给 summarize 加空数组保护', status: 'completed' })],
       completedAndDismissed: false,
@@ -606,6 +846,55 @@ describe('buildSessionActivityModel', () => {
     expect(model.badgeCount).toBe(0)
   })
 
+  it('keeps a task when its TaskUpdate deletion fails', () => {
+    const model = buildSessionActivityModel({
+      sessionId: 'session-1',
+      messages: [
+        {
+          id: 'task-create-1',
+          type: 'tool_use',
+          toolName: 'TaskCreate',
+          toolUseId: 'task-create-call-1',
+          input: { subject: '保留仍然存在的任务' },
+          timestamp: 1000,
+        },
+        {
+          id: 'task-create-result-1',
+          type: 'tool_result',
+          toolUseId: 'task-create-call-1',
+          content: 'Task #1 created successfully: 保留仍然存在的任务',
+          isError: false,
+          timestamp: 1001,
+        },
+        {
+          id: 'task-update-delete',
+          type: 'tool_use',
+          toolName: 'TaskUpdate',
+          toolUseId: 'task-update-delete-call',
+          input: { taskId: '1', status: 'deleted' },
+          timestamp: 1002,
+        },
+        {
+          id: 'task-update-delete-result',
+          type: 'tool_result',
+          toolUseId: 'task-update-delete-call',
+          content: 'Failed to delete task',
+          isError: false,
+          timestamp: 1003,
+        },
+      ],
+      tasks: [],
+      completedAndDismissed: false,
+      backgroundTasks: [],
+      agentNotifications: [],
+    })
+
+    expect(model.sections.tasks.rows).toEqual([
+      expect.objectContaining({ id: '1', label: '保留仍然存在的任务', status: 'pending' }),
+    ])
+    expect(model.badgeCount).toBe(1)
+  })
+
   it('does not invent a row for a TaskUpdate deletion without a matching TaskCreate', () => {
     const model = buildSessionActivityModel({
       sessionId: 'session-1',
@@ -624,6 +913,7 @@ describe('buildSessionActivityModel', () => {
           input: { taskId: '7', status: 'deleted' },
           timestamp: 1001,
         },
+        successfulTaskUpdateResult('task-update-call-1', '7', 1002, 'deleted'),
       ],
       tasks: [],
       completedAndDismissed: false,
@@ -680,6 +970,7 @@ describe('buildSessionActivityModel', () => {
           input: { taskId: '1', status: 'completed' },
           timestamp: 1005,
         },
+        successfulTaskUpdateResult('task-update-call-1', '1', 1006),
         { id: 'user-2', type: 'user_text', content: 'README 不写了，继续做活动面板', timestamp: 2000 },
         {
           id: 'task-update-2',
@@ -689,13 +980,14 @@ describe('buildSessionActivityModel', () => {
           input: { taskId: '2', status: 'deleted' },
           timestamp: 2001,
         },
+        successfulTaskUpdateResult('task-update-call-2', '2', 2002, 'deleted'),
         {
           id: 'task-create-3',
           type: 'tool_use',
           toolName: 'TaskCreate',
           toolUseId: 'task-create-call-3',
           input: { subject: '实现活动面板' },
-          timestamp: 2002,
+          timestamp: 2003,
         },
         {
           id: 'task-create-result-3',
@@ -703,7 +995,7 @@ describe('buildSessionActivityModel', () => {
           toolUseId: 'task-create-call-3',
           content: 'Task #3 created successfully: 实现活动面板',
           isError: false,
-          timestamp: 2003,
+          timestamp: 2004,
         },
       ],
       tasks: [],
@@ -735,13 +1027,14 @@ describe('buildSessionActivityModel', () => {
           input: { taskId: '1', status: 'deleted' },
           timestamp: 1000,
         },
+        successfulTaskUpdateResult('task-update-call-1', '1', 1001, 'deleted'),
         {
           id: 'task-create-1',
           type: 'tool_use',
           toolName: 'TaskCreate',
           toolUseId: 'task-create-call-1',
           input: { subject: '补充边界测试' },
-          timestamp: 1001,
+          timestamp: 1002,
         },
         {
           id: 'task-create-result-1',
@@ -749,7 +1042,7 @@ describe('buildSessionActivityModel', () => {
           toolUseId: 'task-create-call-1',
           content: 'Task #2 created successfully: 补充边界测试',
           isError: false,
-          timestamp: 1002,
+          timestamp: 1003,
         },
       ],
       // tool_result 后才异步 refreshTasks，这一刻的列表还没剔掉已删任务
@@ -768,6 +1061,52 @@ describe('buildSessionActivityModel', () => {
     expect(model.badgeCount).toBe(1)
   })
 
+  it('keeps TodoWrite rows authoritative over a later failed TaskUpdate', () => {
+    const model = buildSessionActivityModel({
+      sessionId: 'session-1',
+      messages: [
+        {
+          id: 'todo-1',
+          type: 'tool_use',
+          toolName: 'TodoWrite',
+          toolUseId: 'todo-call-1',
+          input: {
+            todos: [{ content: '继续验证桌面活动面板', status: 'in_progress' }],
+          },
+          timestamp: 1000,
+        },
+        {
+          id: 'task-update-1',
+          type: 'tool_use',
+          toolName: 'TaskUpdate',
+          toolUseId: 'task-update-call-1',
+          input: { taskId: '1', status: 'completed' },
+          timestamp: 1001,
+        },
+        {
+          id: 'task-update-result-1',
+          type: 'tool_result',
+          toolUseId: 'task-update-call-1',
+          content: 'Task not found',
+          isError: false,
+          timestamp: 1002,
+        },
+      ],
+      tasks: [],
+      completedAndDismissed: false,
+      backgroundTasks: [],
+      agentNotifications: [],
+    })
+
+    expect(model.sections.tasks.rows).toEqual([
+      expect.objectContaining({
+        label: '继续验证桌面活动面板',
+        status: 'in_progress',
+      }),
+    ])
+    expect(model.badgeCount).toBe(1)
+  })
+
   it('prefers task summary rows over earlier TodoWrite rows', () => {
     const model = buildSessionActivityModel({
       sessionId: 'session-1',
diff --git a/desktop/src/components/activity/sessionActivityModel.ts b/desktop/src/components/activity/sessionActivityModel.ts
index 0e2dcf5f..a07d1db0 100644
--- a/desktop/src/components/activity/sessionActivityModel.ts
+++ b/desktop/src/components/activity/sessionActivityModel.ts
@@ -250,9 +250,9 @@ function splitMessagesIntoTurns(messages: UIMessage[]): TaskMessageTurn[] {
   return turns
 }
 
-function normalizeTaskStatus(status: unknown): TaskSummaryItem['status'] {
+function parseTaskStatus(status: unknown): TaskSummaryItem['status'] | undefined {
   if (status === 'completed' || status === 'in_progress' || status === 'pending') return status
-  return 'pending'
+  return undefined
 }
 
 function taskIdFromInput(input: Record<string, unknown>): string {
@@ -263,18 +263,32 @@ function isDeletedStatus(input: Record<string, unknown>): boolean {
   return stringField(input, 'status') === 'deleted'
 }
 
+function collectToolResults(
+  messages: UIMessage[],
+): Map<string, Extract<UIMessage, { type: 'tool_result' }>> {
+  const resultsByToolUseId = new Map<string, Extract<UIMessage, { type: 'tool_result' }>>()
+  for (const message of messages) {
+    if (message.type === 'tool_result') {
+      resultsByToolUseId.set(message.toolUseId, message)
+    }
+  }
+  return resultsByToolUseId
+}
+
 /**
  * TaskUpdate 的 deleted 是删除动作而非状态，删除可能发生在创建它的那一轮之后，
  * 所以要跨轮次收集，避免已删任务留在历史统计里。
  */
 function collectDeletedTaskIds(messages: UIMessage[]): Set<string> {
   const deletedTaskIds = new Set<string>()
+  const resultsByToolUseId = collectToolResults(messages)
 
   for (const message of messages) {
     if (message.type !== 'tool_use' || message.toolName !== 'TaskUpdate') continue
 
     const input = isRecordValue(message.input) ? message.input : {}
     if (!isDeletedStatus(input)) continue
+    if (!isSuccessfulTaskUpdate(input, resultsByToolUseId.get(message.toolUseId))) continue
 
     const taskId = taskIdFromInput(input)
     if (taskId) deletedTaskIds.add(taskId)
@@ -294,6 +308,20 @@ function parseCreatedTaskResult(content: unknown): { id: string; subject?: strin
   }
 }
 
+function parseUpdatedTaskResult(content: unknown): { id: string } | null {
+  const match = extractTextContent(content).trimStart().match(/^Updated task #([^\s]+)(?:\s|$)/i)
+  return match?.[1] ? { id: match[1] } : null
+}
+
+function isSuccessfulTaskUpdate(
+  input: Record<string, unknown>,
+  result: Extract<UIMessage, { type: 'tool_result' }> | undefined,
+): boolean {
+  if (!result || result.isError) return false
+  const taskId = taskIdFromInput(input)
+  return Boolean(taskId && parseUpdatedTaskResult(result.content)?.id === taskId)
+}
+
 function buildTaskToolRow(
   id: string,
   input: Record<string, unknown>,
@@ -449,13 +477,10 @@ function buildAgentRowsFromMessages(messages: UIMessage[]): ActivityRow[] {
   return rows
 }
 
-function buildTaskRowsFromTaskTools(messages: UIMessage[]): ActivityRow[] {
-  const resultsByToolUseId = new Map<string, Extract<UIMessage, { type: 'tool_result' }>>()
-  for (const message of messages) {
-    if (message.type === 'tool_result') {
-      resultsByToolUseId.set(message.toolUseId, message)
-    }
-  }
+function buildTaskRowsFromTaskTools(
+  messages: UIMessage[],
+  resultsByToolUseId = collectToolResults(messages),
+): ActivityRow[] {
 
   const rowsByTaskId = new Map<string, ActivityRow>()
   let createIndex = 0
@@ -477,6 +502,9 @@ function buildTaskRowsFromTaskTools(messages: UIMessage[]): ActivityRow[] {
       const input = isRecordValue(message.input) ? message.input : {}
       const taskId = taskIdFromInput(input)
       if (!taskId) continue
+      // TaskUpdate reports benign failures such as "Task not found" with
+      // isError=false, so only its positive result is authoritative.
+      if (!isSuccessfulTaskUpdate(input, resultsByToolUseId.get(message.toolUseId))) continue
 
       // deleted 不是一种任务状态：CLI 侧 TaskUpdateTool 会真的删掉任务文件
       if (isDeletedStatus(input)) {
@@ -487,6 +515,7 @@ function buildTaskRowsFromTaskTools(messages: UIMessage[]): ActivityRow[] {
       const existing = rowsByTaskId.get(taskId)
       const activeForm = stringField(input, 'activeForm')
       const subject = stringField(input, 'subject')
+      const status = parseTaskStatus(input.status) ?? existing?.status ?? 'pending'
       rowsByTaskId.set(taskId, {
         ...(existing ?? {
           id: taskId,
@@ -495,7 +524,7 @@ function buildTaskRowsFromTaskTools(messages: UIMessage[]): ActivityRow[] {
           taskId,
           openable: false,
         }),
-        status: normalizeTaskStatus(input.status),
+        status,
         ...(activeForm && activeForm !== (existing?.label ?? subject) ? { description: activeForm } : {}),
       })
     }
@@ -504,7 +533,10 @@ function buildTaskRowsFromTaskTools(messages: UIMessage[]): ActivityRow[] {
   return Array.from(rowsByTaskId.values())
 }
 
-function buildTaskRowsFromTurnMessages(messages: UIMessage[]): ActivityRow[] {
+function buildTaskRowsFromTurnMessages(
+  messages: UIMessage[],
+  resultsByToolUseId = collectToolResults(messages),
+): ActivityRow[] {
   let latestSummary: Extract<UIMessage, { type: 'task_summary' }> | undefined
   let latestTodoWrite: Extract<UIMessage, { type: 'tool_use' }> | undefined
   let latestTaskToolTimestamp = -Infinity
@@ -514,8 +546,13 @@ function buildTaskRowsFromTurnMessages(messages: UIMessage[]): ActivityRow[] {
       latestSummary = message
     } else if (message.type === 'tool_use' && message.toolName === 'TodoWrite') {
       latestTodoWrite = message
-    } else if (message.type === 'tool_use' && (message.toolName === 'TaskCreate' || message.toolName === 'TaskUpdate')) {
+    } else if (message.type === 'tool_use' && message.toolName === 'TaskCreate') {
       latestTaskToolTimestamp = Math.max(latestTaskToolTimestamp, message.timestamp)
+    } else if (message.type === 'tool_use' && message.toolName === 'TaskUpdate') {
+      const input = isRecordValue(message.input) ? message.input : {}
+      if (isSuccessfulTaskUpdate(input, resultsByToolUseId.get(message.toolUseId))) {
+        latestTaskToolTimestamp = Math.max(latestTaskToolTimestamp, message.timestamp)
+      }
     }
   }
 
@@ -528,7 +565,7 @@ function buildTaskRowsFromTurnMessages(messages: UIMessage[]): ActivityRow[] {
     return dedupeTaskRows(input.todos.map(buildTodoTaskRow))
   }
 
-  return buildTaskRowsFromTaskTools(messages)
+  return buildTaskRowsFromTaskTools(messages, resultsByToolUseId)
 }
 
 function mergeTaskRowsById(baseRows: ActivityRow[], liveRows: ActivityRow[]): ActivityRow[] {
@@ -580,11 +617,15 @@ function buildHistoricalTasksRow(groups: TaskTurnRows[]): ActivityRow | null {
 
 function buildTaskRowsFromMessages(messages: UIMessage[], liveTasks: CLITask[]): ActivityRow[] {
   const deletedTaskIds = collectDeletedTaskIds(messages)
+  const resultsByToolUseId = collectToolResults(messages)
   const isLiveRow = (row: ActivityRow) => (row.taskId ? !deletedTaskIds.has(row.taskId) : true)
   // 任务列表要等 tool_result 到达后才异步刷新，这中间 liveTasks 里还留着已删的任务
   const liveRows = liveTasks.filter((task) => !deletedTaskIds.has(task.id)).map(buildTaskRow)
   const taskTurnRows = splitMessagesIntoTurns(messages)
-    .map((turn) => ({ turn, rows: buildTaskRowsFromTurnMessages(turn.messages).filter(isLiveRow) }))
+    .map((turn) => ({
+      turn,
+      rows: buildTaskRowsFromTurnMessages(turn.messages, resultsByToolUseId).filter(isLiveRow),
+    }))
     .filter((group) => group.rows.length > 0)
 
   if (taskTurnRows.length === 0) {
diff --git a/desktop/src/components/chat/ChatInput.test.tsx b/desktop/src/components/chat/ChatInput.test.tsx
index 20a45aec..d54a3353 100644
--- a/desktop/src/components/chat/ChatInput.test.tsx
+++ b/desktop/src/components/chat/ChatInput.test.tsx
@@ -933,6 +933,75 @@ describe('ChatInput file mentions', () => {
     expect(stop).not.toBeDisabled()
   })
 
+  it.each(['local_agent', 'remote_agent'])('keeps Run available alongside Stop for an idle session with a running %s', (taskType) => {
+    useChatStore.setState({
+      sessions: {
+        ...useChatStore.getState().sessions,
+        [sessionId]: {
+          ...useChatStore.getState().sessions[sessionId]!,
+          chatState: 'idle',
+          backgroundAgentTasks: {
+            agent: {
+              taskId: 'agent',
+              taskType,
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 1,
+            },
+          },
+        },
+      },
+    })
+
+    render(<ChatInput compact />)
+
+    const input = screen.getByRole('textbox')
+    fireEvent.change(input, {
+      target: { value: 'continue while the agent runs', selectionStart: 29 },
+    })
+
+    const run = screen.getByRole('button', { name: 'Run' })
+    const stop = screen.getByRole('button', { name: 'Stop' })
+    expect(run).not.toBeDisabled()
+    expect(stop).not.toBeDisabled()
+
+    fireEvent.click(stop)
+    fireEvent.click(run)
+
+    expect(mocks.wsSend).toHaveBeenCalledWith(sessionId, { type: 'stop_generation' })
+    expect(mocks.wsSend).toHaveBeenCalledWith(sessionId, {
+      type: 'user_message',
+      content: 'continue while the agent runs',
+      attachments: [],
+    })
+  })
+
+  it.each(['local_bash', 'dream'])('does not turn Run into Stop for a running %s task', (taskType) => {
+    useChatStore.setState({
+      sessions: {
+        ...useChatStore.getState().sessions,
+        [sessionId]: {
+          ...useChatStore.getState().sessions[sessionId]!,
+          chatState: 'idle',
+          backgroundAgentTasks: {
+            task: {
+              taskId: 'task',
+              taskType,
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 1,
+            },
+          },
+        },
+      },
+    })
+
+    render(<ChatInput compact />)
+
+    expect(screen.getByRole('button', { name: 'Run' })).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Stop' })).not.toBeInTheDocument()
+  })
+
   // This used to assert that the run button shed its label before the location
   // moved. The button has no label to shed any more — it is one round icon at
   // every width — so what needs pinning is that it does *not* change with the
diff --git a/desktop/src/components/chat/ChatInput.tsx b/desktop/src/components/chat/ChatInput.tsx
index 2a577f6e..66972beb 100644
--- a/desktop/src/components/chat/ChatInput.tsx
+++ b/desktop/src/components/chat/ChatInput.tsx
@@ -52,6 +52,7 @@ import { useComposerFileDrop } from './useComposerFileDrop'
 import { shouldSubmitOnEnter } from './sendShortcut'
 import type { PermissionMode } from '../../types/settings'
 import { getSessionWorkspaceState } from '../../lib/sessionWorkspace'
+import { hasRunningSubagentTasks } from '../../lib/backgroundTasks'
 
 type GitInfo = SessionGitInfo
 
@@ -220,6 +221,7 @@ export function ChatInput({ variant = 'default', compact = false }: ChatInputPro
 
   const isMemberSession = !!memberInfo
   const isActive = chatState !== 'idle'
+  const hasRunningSubagents = hasRunningSubagentTasks(sessionState?.backgroundAgentTasks)
   const workspaceState = getSessionWorkspaceState(activeSession)
   const isWorkspaceMissing = workspaceState !== 'available'
   const hasWorkspaceReferences = !isMemberSession && workspaceReferences.length > 0
@@ -1405,6 +1407,22 @@ export function ChatInput({ variant = 'default', compact = false }: ChatInputPro
                   fluid={isMobileComposer}
                 />
               )}
+              {!isMemberSession && !isActive && hasRunningSubagents ? (
+                <Button
+                  variant="danger"
+                  size="base"
+                  shape="circle"
+                  onClick={() => stopGeneration(activeTabId!)}
+                  aria-label={t('common.stop')}
+                  title={t('chat.stopTitle')}
+                  className={`shrink-0 ${isMobileComposer ? 'h-11 w-11' : ''}`}
+                  icon={(
+                    <span className="material-symbols-outlined text-[18px]">
+                      stop
+                    </span>
+                  )}
+                />
+              ) : null}
               {/* Same component, shape and icon as EmptySession's send button.
                   The two rendered mirror images of each other until it was
                   spotted in a walkthrough — the arrow led here and trailed
diff --git a/desktop/src/hooks/useKeyboardShortcuts.test.tsx b/desktop/src/hooks/useKeyboardShortcuts.test.tsx
index 531d9652..1de8c25f 100644
--- a/desktop/src/hooks/useKeyboardShortcuts.test.tsx
+++ b/desktop/src/hooks/useKeyboardShortcuts.test.tsx
@@ -1,8 +1,10 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { cleanup, fireEvent, render, waitFor } from '@testing-library/react'
 import { APP_ZOOM_STORAGE_KEY } from '../lib/appZoom'
 import { useSettingsStore } from '../stores/settingsStore'
 import { useKeyboardShortcuts } from './useKeyboardShortcuts'
+import { useChatStore, type PerSessionState } from '../stores/chatStore'
+import { useTabStore } from '../stores/tabStore'
 
 function ShortcutHost() {
   useKeyboardShortcuts()
@@ -16,6 +18,30 @@ function setNavigatorPlatform(platform: string) {
   })
 }
 
+function makeIdleSession(overrides: Partial<PerSessionState> = {}): PerSessionState {
+  return {
+    messages: [],
+    chatState: 'idle',
+    connectionState: 'connected',
+    streamingText: '',
+    streamingToolInput: '',
+    activeToolUseId: null,
+    activeToolName: null,
+    activeThinkingId: null,
+    pendingPermission: null,
+    pendingComputerUsePermission: null,
+    tokenUsage: { input_tokens: 0, output_tokens: 0 },
+    streamingResponseChars: 0,
+    elapsedSeconds: 0,
+    statusVerb: '',
+    slashCommands: [],
+    agentTaskNotifications: {},
+    backgroundAgentTasks: {},
+    elapsedTimer: null,
+    ...overrides,
+  }
+}
+
 describe('useKeyboardShortcuts app zoom', () => {
   beforeEach(() => {
     window.localStorage.clear()
@@ -101,3 +127,89 @@ describe('useKeyboardShortcuts app zoom', () => {
     expect(window.localStorage.getItem(APP_ZOOM_STORAGE_KEY)).toBe('0.9')
   })
 })
+
+describe('useKeyboardShortcuts generation stop', () => {
+  const sessionId = 'session-with-background-work'
+  const initialChatState = useChatStore.getInitialState()
+  const initialTabState = useTabStore.getInitialState()
+  let stopGeneration: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    stopGeneration = vi.fn()
+    useTabStore.setState({
+      activeTabId: sessionId,
+      tabs: [{ sessionId, title: 'Session', type: 'session', status: 'running' }],
+    })
+  })
+
+  afterEach(() => {
+    cleanup()
+    useChatStore.setState(initialChatState, true)
+    useTabStore.setState(initialTabState, true)
+  })
+
+  it.each([
+    ['Cmd', 'local_agent', { metaKey: true }],
+    ['Ctrl', 'remote_agent', { ctrlKey: true }],
+  ] as const)('uses %s+. to stop an idle session with a running %s', (_label, taskType, modifier) => {
+    useChatStore.setState({
+      stopGeneration,
+      sessions: {
+        [sessionId]: makeIdleSession({
+          backgroundAgentTasks: {
+            agent: {
+              taskId: 'agent',
+              taskType,
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 1,
+            },
+          },
+        }),
+      },
+    })
+    render(<ShortcutHost />)
+
+    const event = new KeyboardEvent('keydown', {
+      key: '.',
+      bubbles: true,
+      cancelable: true,
+      ...modifier,
+    })
+    document.dispatchEvent(event)
+
+    expect(event.defaultPrevented).toBe(true)
+    expect(stopGeneration).toHaveBeenCalledWith(sessionId)
+  })
+
+  it.each(['local_bash', 'dream'])('does not stop an idle session for a running %s task', (taskType) => {
+    useChatStore.setState({
+      stopGeneration,
+      sessions: {
+        [sessionId]: makeIdleSession({
+          backgroundAgentTasks: {
+            task: {
+              taskId: 'task',
+              taskType,
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 1,
+            },
+          },
+        }),
+      },
+    })
+    render(<ShortcutHost />)
+
+    const event = new KeyboardEvent('keydown', {
+      key: '.',
+      ctrlKey: true,
+      bubbles: true,
+      cancelable: true,
+    })
+    document.dispatchEvent(event)
+
+    expect(event.defaultPrevented).toBe(false)
+    expect(stopGeneration).not.toHaveBeenCalled()
+  })
+})
diff --git a/desktop/src/hooks/useKeyboardShortcuts.ts b/desktop/src/hooks/useKeyboardShortcuts.ts
index 5382c3bc..8fb3d299 100644
--- a/desktop/src/hooks/useKeyboardShortcuts.ts
+++ b/desktop/src/hooks/useKeyboardShortcuts.ts
@@ -8,6 +8,7 @@ import {
   nextAppZoomLevel,
 } from '../lib/appZoom'
 import { useSettingsStore } from '../stores/settingsStore'
+import { hasRunningSubagentTasks } from '../lib/backgroundTasks'
 
 export function useKeyboardShortcuts() {
   const setActiveSession = useSessionStore((s) => s.setActiveSession)
@@ -17,14 +18,20 @@ export function useKeyboardShortcuts() {
   const activeModal = useUIStore((s) => s.activeModal)
   const stopGeneration = useChatStore((s) => s.stopGeneration)
   const activeTabId = useTabStore((s) => s.activeTabId)
-  const chatState = useChatStore((s) => activeTabId ? s.sessions[activeTabId]?.chatState ?? 'idle' : 'idle')
+  const canStopActiveSession = useChatStore((s) => {
+    const session = activeTabId ? s.sessions[activeTabId] : undefined
+    return Boolean(
+      session &&
+      (session.chatState !== 'idle' || hasRunningSubagentTasks(session.backgroundAgentTasks)),
+    )
+  })
   const uiZoom = useSettingsStore((s) => s.uiZoom)
   const setUiZoom = useSettingsStore((s) => s.setUiZoom)
 
   const activeModalRef = useRef(activeModal)
   activeModalRef.current = activeModal
-  const chatStateRef = useRef(chatState)
-  chatStateRef.current = chatState
+  const canStopActiveSessionRef = useRef(canStopActiveSession)
+  canStopActiveSessionRef.current = canStopActiveSession
   const activeTabIdRef = useRef(activeTabId)
   activeTabIdRef.current = activeTabId
   const appZoomLevelRef = useRef(uiZoom)
@@ -71,7 +78,7 @@ export function useKeyboardShortcuts() {
 
       // Cmd+. — Stop generation
       if (meta && e.key === '.') {
-        if (chatStateRef.current !== 'idle' && activeTabIdRef.current) {
+        if (canStopActiveSessionRef.current && activeTabIdRef.current) {
           e.preventDefault()
           stopGeneration(activeTabIdRef.current)
         }
diff --git a/desktop/src/i18n/locales/en.ts b/desktop/src/i18n/locales/en.ts
index 0c290874..e4c5fa10 100644
--- a/desktop/src/i18n/locales/en.ts
+++ b/desktop/src/i18n/locales/en.ts
@@ -2190,6 +2190,7 @@ Row 9, all 8 cells: continuing from straight down, turning left through lower-le
   'session.activity.status.inProgress': 'In progress',
   'session.activity.status.completed': 'Completed',
   'session.activity.status.running': 'Running',
+  'session.activity.status.stopping': 'Stopping',
   'session.activity.status.failed': 'Failed',
   'session.activity.status.stopped': 'Stopped',
   'session.activity.status.idle': 'Idle',
diff --git a/desktop/src/i18n/locales/jp.ts b/desktop/src/i18n/locales/jp.ts
index de2a8180..63d1ae56 100644
--- a/desktop/src/i18n/locales/jp.ts
+++ b/desktop/src/i18n/locales/jp.ts
@@ -2192,6 +2192,7 @@ export const jp: Record<TranslationKey, string> = {
   'session.activity.status.inProgress': '進行中',
   'session.activity.status.completed': '完了',
   'session.activity.status.running': '実行中',
+  'session.activity.status.stopping': '停止中',
   'session.activity.status.failed': '失敗',
   'session.activity.status.stopped': '停止済み',
   'session.activity.status.idle': 'アイドル',
diff --git a/desktop/src/i18n/locales/kr.ts b/desktop/src/i18n/locales/kr.ts
index 2cdba47e..8d343af7 100644
--- a/desktop/src/i18n/locales/kr.ts
+++ b/desktop/src/i18n/locales/kr.ts
@@ -2192,6 +2192,7 @@ export const kr: Record<TranslationKey, string> = {
   'session.activity.status.inProgress': '진행 중',
   'session.activity.status.completed': '완료됨',
   'session.activity.status.running': '실행 중',
+  'session.activity.status.stopping': '중지 중',
   'session.activity.status.failed': '실패',
   'session.activity.status.stopped': '중지됨',
   'session.activity.status.idle': '유휴',
diff --git a/desktop/src/i18n/locales/zh-TW.ts b/desktop/src/i18n/locales/zh-TW.ts
index a6b18fd3..28abd9eb 100644
--- a/desktop/src/i18n/locales/zh-TW.ts
+++ b/desktop/src/i18n/locales/zh-TW.ts
@@ -2191,6 +2191,7 @@ export const zh: Record<TranslationKey, string> = {
   'session.activity.status.inProgress': '進行中',
   'session.activity.status.completed': '已完成',
   'session.activity.status.running': '執行中',
+  'session.activity.status.stopping': '停止中',
   'session.activity.status.failed': '失敗',
   'session.activity.status.stopped': '已停止',
   'session.activity.status.idle': '閒置',
diff --git a/desktop/src/i18n/locales/zh.ts b/desktop/src/i18n/locales/zh.ts
index 9c65d3bf..487528bf 100644
--- a/desktop/src/i18n/locales/zh.ts
+++ b/desktop/src/i18n/locales/zh.ts
@@ -2191,6 +2191,7 @@ export const zh: Record<TranslationKey, string> = {
   'session.activity.status.inProgress': '进行中',
   'session.activity.status.completed': '已完成',
   'session.activity.status.running': '运行中',
+  'session.activity.status.stopping': '停止中',
   'session.activity.status.failed': '失败',
   'session.activity.status.stopped': '已停止',
   'session.activity.status.idle': '空闲',
diff --git a/desktop/src/lib/backgroundTasks.test.ts b/desktop/src/lib/backgroundTasks.test.ts
index 4036290d..acafc346 100644
--- a/desktop/src/lib/backgroundTasks.test.ts
+++ b/desktop/src/lib/backgroundTasks.test.ts
@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import type { BackgroundAgentTask } from '../types/chat'
-import { formatDurationMs, formatDurationSeconds, hasRunningBackgroundTasks } from './backgroundTasks'
+import {
+  formatDurationMs,
+  formatDurationSeconds,
+  hasRunningBackgroundTasks,
+  hasRunningSubagentTasks,
+} from './backgroundTasks'
 import { translate } from '../i18n'
 
 function task(
@@ -31,6 +36,26 @@ describe('hasRunningBackgroundTasks', () => {
   })
 })
 
+describe('hasRunningSubagentTasks', () => {
+  it.each(['local_agent', 'remote_agent'])('reports a running %s as stoppable', (taskType) => {
+    expect(hasRunningSubagentTasks({
+      agent: task('agent', { taskType }),
+    })).toBe(true)
+  })
+
+  it.each(['local_bash', 'dream', undefined])('does not treat %s as a stoppable SubAgent', (taskType) => {
+    expect(hasRunningSubagentTasks({
+      task: task('task', { taskType }),
+    })).toBe(false)
+  })
+
+  it('ignores an Agent that already reached a terminal status', () => {
+    expect(hasRunningSubagentTasks({
+      agent: task('agent', { taskType: 'local_agent', status: 'stopped' }),
+    })).toBe(false)
+  })
+})
+
 describe('formatDurationSeconds', () => {
   const t = (key: Parameters<typeof translate>[1], params?: Record<string, string | number>) =>
     translate('en', key, params)
diff --git a/desktop/src/lib/backgroundTasks.ts b/desktop/src/lib/backgroundTasks.ts
index 76dc909b..13b8ea92 100644
--- a/desktop/src/lib/backgroundTasks.ts
+++ b/desktop/src/lib/backgroundTasks.ts
@@ -11,6 +11,13 @@ export function hasRunningBackgroundTasks(tasks?: Record<string, BackgroundAgent
   )
 }
 
+export function hasRunningSubagentTasks(tasks?: Record<string, BackgroundAgentTask>): boolean {
+  return Object.values(tasks ?? {}).some(
+    (task) => task.status === 'running' &&
+      (task.taskType === 'local_agent' || task.taskType === 'remote_agent'),
+  )
+}
+
 export function createBackgroundTaskDismissKey(task: BackgroundAgentTask): string {
   return `${task.taskId}:${task.status}:${task.startedAt}`
 }
diff --git a/desktop/src/stores/chatStore.test.ts b/desktop/src/stores/chatStore.test.ts
index cf565ef4..da2cf57a 100644
--- a/desktop/src/stores/chatStore.test.ts
+++ b/desktop/src/stores/chatStore.test.ts
@@ -2406,6 +2406,235 @@ describe('chatStore history mapping', () => {
     vi.useRealTimers()
   })
 
+  it('marks every running SubAgent as stopping when generation is stopped', () => {
+    const backgroundAgentTasks = Object.fromEntries(
+      Array.from({ length: 4 }, (_, index) => {
+        const number = index + 1
+        return [`agent-task-${number}`, {
+          taskId: `agent-task-${number}`,
+          toolUseId: `agent-tool-${number}`,
+          taskType: number === 3 ? 'remote_agent' : 'local_agent',
+          description: `Review area ${number}`,
+          status: 'running' as const,
+          startedAt: number,
+          updatedAt: number,
+        }]
+      }),
+    )
+
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'tool_executing',
+          backgroundAgentTasks,
+        }),
+      },
+    })
+
+    useChatStore.getState().stopGeneration(TEST_SESSION_ID)
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(sendMock).toHaveBeenCalledWith(TEST_SESSION_ID, { type: 'stop_generation' })
+    expect(session?.stoppingBackgroundTaskIds).toEqual({
+      'agent-task-1': true,
+      'agent-task-2': true,
+      'agent-task-3': true,
+      'agent-task-4': true,
+    })
+    expect(Object.values(session?.backgroundAgentTasks ?? {}).map((task) => task.status)).toEqual([
+      'running',
+      'running',
+      'running',
+      'running',
+    ])
+  })
+
+  it('keeps a SubAgent that starts after the global stop in the stopping state', () => {
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({ chatState: 'tool_executing' }),
+      },
+    })
+
+    useChatStore.getState().stopGeneration(TEST_SESSION_ID)
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'task_started',
+      data: {
+        task_id: 'late-agent-task',
+        tool_use_id: 'late-agent-tool',
+        task_type: 'local_agent',
+        description: 'Started while the turn was stopping',
+      },
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'task_started',
+      data: {
+        task_id: 'late-bash-task',
+        tool_use_id: 'late-bash-tool',
+        task_type: 'local_bash',
+        description: 'Detached shell task',
+      },
+    })
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.stopAllSubagentsRequested).toBe(true)
+    expect(session?.stoppingBackgroundTaskIds).toEqual({ 'late-agent-task': true })
+
+    useChatStore.getState().sendMessage(TEST_SESSION_ID, 'Start the next turn')
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'task_started',
+      data: {
+        task_id: 'next-turn-agent-task',
+        tool_use_id: 'next-turn-agent-tool',
+        task_type: 'local_agent',
+        description: 'Belongs to the next turn',
+      },
+    })
+
+    const pendingSession = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(pendingSession?.stopAllSubagentsRequested).toBe(true)
+    expect(pendingSession?.stoppingBackgroundTaskIds?.['next-turn-agent-task']).toBe(true)
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'user_message_replay',
+      content: 'Start the next turn',
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'task_started',
+      data: {
+        task_id: 'replayed-turn-agent-task',
+        tool_use_id: 'replayed-turn-agent-tool',
+        task_type: 'local_agent',
+        description: 'Belongs to the replayed next turn',
+      },
+    })
+
+    const resumedSession = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(resumedSession?.stopAllSubagentsRequested).toBe(false)
+    expect(resumedSession?.stoppingBackgroundTaskIds?.['replayed-turn-agent-task']).toBeUndefined()
+    if (resumedSession?.elapsedTimer) clearInterval(resumedSession.elapsedTimer)
+  })
+
+  it('keeps the global SubAgent stop latch when a replacement fails before replay', () => {
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          stopAllSubagentsRequested: true,
+        }),
+      },
+    })
+
+    useChatStore.getState().sendMessage(TEST_SESSION_ID, 'Replacement that will fail')
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'error',
+      message: 'Replacement rejected',
+      code: 'CLI_START_FAILED',
+    })
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.stopAllSubagentsRequested).toBe(true)
+    if (session?.elapsedTimer) clearInterval(session.elapsedTimer)
+  })
+
+  it('ends the global SubAgent stop latch on authoritative local-command output', () => {
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'thinking',
+          stopAllSubagentsRequested: true,
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'content_start',
+      blockType: 'text',
+    })
+
+    expect(
+      useChatStore.getState().sessions[TEST_SESSION_ID]?.stopAllSubagentsRequested,
+    ).toBe(false)
+  })
+
+  it('ends the global SubAgent stop latch on authoritative /goal output', () => {
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'thinking',
+          stopAllSubagentsRequested: true,
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'goal_event',
+      message: 'Goal set: verify the replacement turn',
+      data: {
+        action: 'created',
+        status: 'active',
+        objective: 'verify the replacement turn',
+      },
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'message_complete',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.stopAllSubagentsRequested).toBe(false)
+    expect(session?.chatState).toBe('idle')
+    expect(session?.activeGoal).toMatchObject({
+      action: 'created',
+      status: 'active',
+      objective: 'verify the replacement turn',
+    })
+    expect(session?.messages).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: 'goal_event',
+        action: 'created',
+        objective: 'verify the replacement turn',
+      }),
+    ]))
+  })
+
+  it('ends the global stop latch when an authoritative replay starts the next turn', () => {
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          stopAllSubagentsRequested: true,
+          stoppingBackgroundTaskIds: { 'previous-turn-agent': true },
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'user_message_replay',
+      content: 'Start a turn from another renderer',
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'task_started',
+      data: {
+        task_id: 'next-turn-agent',
+        tool_use_id: 'next-turn-agent-tool',
+        task_type: 'local_agent',
+        description: 'Belongs to the authoritative replayed turn',
+      },
+    })
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.stopAllSubagentsRequested).toBe(false)
+    expect(session?.stoppingBackgroundTaskIds).toEqual({ 'previous-turn-agent': true })
+    expect(session?.backgroundAgentTasks?.['next-turn-agent']?.status).toBe('running')
+  })
+
   it('refreshes merged slash commands when a live CLI update omits project commands', async () => {
     const cliCommand = { name: 'builtin-help', description: 'Built-in command' }
     const projectCommand = { name: 'project-probe', description: 'Project custom command' }
@@ -2630,10 +2859,21 @@ describe('chatStore history mapping', () => {
     })
     expect(useChatStore.getState().sessions[TEST_SESSION_ID]?.connectionSnapshotReady).toBe(true)
 
+    useChatStore.setState((state) => ({
+      sessions: {
+        ...state.sessions,
+        [TEST_SESSION_ID]: {
+          ...state.sessions[TEST_SESSION_ID]!,
+          stoppingBackgroundTaskIds: { 'agent-task-before-reconnect': true },
+        },
+      },
+    }))
+
     onConnectionState?.('reconnecting')
     expect(useChatStore.getState().sessions[TEST_SESSION_ID]).toMatchObject({
       connectionState: 'reconnecting',
       connectionSnapshotReady: false,
+      stoppingBackgroundTaskIds: {},
     })
     onConnectionState?.('connected')
     expect(useChatStore.getState().sessions[TEST_SESSION_ID]).toMatchObject({
@@ -2642,6 +2882,32 @@ describe('chatStore history mapping', () => {
     })
   })
 
+  it('keeps global SubAgent stop markers visible while the socket reconnects', () => {
+    useChatStore.getState().connectToSession(TEST_SESSION_ID, {
+      prewarm: false,
+      applyRuntimeSelection: false,
+    })
+    const onConnectionState = connectionStateHandlers.get(TEST_SESSION_ID)
+    useChatStore.setState((state) => ({
+      sessions: {
+        ...state.sessions,
+        [TEST_SESSION_ID]: {
+          ...state.sessions[TEST_SESSION_ID]!,
+          stopAllSubagentsRequested: true,
+          stoppingBackgroundTaskIds: { 'agent-task-stop-reconnect': true },
+        },
+      },
+    }))
+
+    onConnectionState?.('reconnecting')
+
+    expect(useChatStore.getState().sessions[TEST_SESSION_ID]).toMatchObject({
+      connectionState: 'reconnecting',
+      stopAllSubagentsRequested: true,
+      stoppingBackgroundTaskIds: { 'agent-task-stop-reconnect': true },
+    })
+  })
+
   it('does not prewarm team member sessions', () => {
     getMemberBySessionIdMock.mockReturnValue({
       agentId: 'reviewer@test-team',
@@ -3808,6 +4074,199 @@ describe('chatStore history mapping', () => {
     expect(session?.messages).toHaveLength(1)
   })
 
+  it('replays a cold reconnect stop failure after task history hydrates', async () => {
+    vi.mocked(sessionsApi.getMessages).mockResolvedValueOnce({
+      messages: [],
+      taskNotifications: [],
+    })
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          historyStatus: 'loading',
+          backgroundAgentTasks: {},
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-cold-reconnect',
+      message: 'Remote archive could not be confirmed',
+    })
+    expect(
+      useChatStore.getState().sessions[TEST_SESSION_ID]?.pendingBackgroundTaskStopFailures,
+    ).toEqual({
+      'agent-task-cold-reconnect': 'Remote archive could not be confirmed',
+    })
+
+    useChatStore.setState((state) => ({
+      sessions: {
+        ...state.sessions,
+        [TEST_SESSION_ID]: {
+          ...state.sessions[TEST_SESSION_ID]!,
+          backgroundAgentTasks: {
+            'agent-task-cold-reconnect': {
+              taskId: 'agent-task-cold-reconnect',
+              toolUseId: 'agent-tool-cold-reconnect',
+              taskType: 'remote_agent',
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        },
+      },
+    }))
+    await useChatStore.getState().loadHistory(TEST_SESSION_ID)
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.pendingBackgroundTaskStopFailures).toEqual({})
+    expect(session?.backgroundAgentTasks?.['agent-task-cold-reconnect']?.status).toBe('running')
+    expect(session?.messages.at(-1)).toMatchObject({
+      type: 'error',
+      code: 'STOP_BACKGROUND_TASK_FAILED',
+      message: 'Remote archive could not be confirmed',
+    })
+  })
+
+  it('surfaces a cold reconnect stop failure when task history fails to load', async () => {
+    let rejectHistory!: (error: Error) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((_resolve, reject) => {
+      rejectHistory = reject
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          backgroundAgentTasks: {},
+        }),
+      },
+    })
+
+    const historyLoad = useChatStore.getState().loadHistory(TEST_SESSION_ID)
+    expect(useChatStore.getState().sessions[TEST_SESSION_ID]?.historyStatus).toBe('loading')
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-missing-history',
+      message: 'Agent could not be stopped',
+    })
+    rejectHistory(new Error('History unavailable'))
+    await historyLoad
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.historyStatus).toBe('error')
+    expect(session?.historyError).toBe('History unavailable')
+    expect(session?.pendingBackgroundTaskStopFailures).toEqual({})
+    expect(session?.messages.at(-1)).toMatchObject({
+      type: 'error',
+      code: 'STOP_BACKGROUND_TASK_FAILED',
+      message: 'Agent could not be stopped',
+    })
+  })
+
+  it('does not leave history loading after a failed stale request', async () => {
+    let rejectHistory!: (error: Error) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((_resolve, reject) => {
+      rejectHistory = reject
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({ chatState: 'idle' }),
+      },
+    })
+
+    const historyLoad = useChatStore.getState().loadHistory(TEST_SESSION_ID)
+    expect(useChatStore.getState().sessions[TEST_SESSION_ID]?.historyStatus).toBe('loading')
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'user_message_replay',
+      content: 'A newer externally started turn',
+    })
+
+    rejectHistory(new Error('Stale history failed'))
+    await historyLoad
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.historyStatus).toBe('idle')
+    expect(session?.historyError).toBeNull()
+    expect(session?.messages).toContainEqual(expect.objectContaining({
+      type: 'user_text',
+      content: 'A newer externally started turn',
+    }))
+  })
+
+  it('flushes a cached stop failure when a task start makes history stale', async () => {
+    let resolveHistory!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    let resolveReload!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    vi.mocked(sessionsApi.getMessages)
+      .mockReturnValueOnce(new Promise((resolve) => {
+        resolveHistory = resolve
+      }))
+      .mockReturnValueOnce(new Promise((resolve) => {
+        resolveReload = resolve
+      }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({ chatState: 'idle' }),
+      },
+    })
+
+    const historyLoad = useChatStore.getState().loadHistory(TEST_SESSION_ID)
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-cold-order',
+      message: 'Agent was still starting',
+    })
+    expect(
+      useChatStore.getState().sessions[TEST_SESSION_ID]?.pendingBackgroundTaskStopFailures,
+    ).toEqual({ 'agent-task-cold-order': 'Agent was still starting' })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'task_started',
+      data: {
+        task_id: 'agent-task-cold-order',
+        tool_use_id: 'agent-tool-cold-order',
+        task_type: 'local_agent',
+        description: 'Late task start',
+      },
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    resolveHistory({ messages: [], taskNotifications: [] })
+    await historyLoad
+
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(2)
+    })
+    resolveReload({
+      messages: [{
+        id: 'stale-reload-answer',
+        type: 'assistant',
+        timestamp: '2026-07-10T00:00:00.000Z',
+        content: [{ type: 'text', text: 'stale reload answer' }],
+      }],
+      taskNotifications: [],
+    })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.historyStatus).toBe('idle')
+    expect(session?.pendingBackgroundTaskStopFailures).toEqual({})
+    expect(session?.backgroundAgentTasks?.['agent-task-cold-order']?.status).toBe('running')
+    expect(session?.messages.at(-1)).toMatchObject({
+      type: 'error',
+      code: 'STOP_BACKGROUND_TASK_FAILED',
+      message: 'Agent was still starting',
+    })
+    expect(session?.messages).not.toContainEqual(expect.objectContaining({
+      type: 'assistant_text',
+      content: 'stale reload answer',
+    }))
+  })
+
   it('clears local desktop chat state when the server confirms /clear', () => {
     vi.useFakeTimers()
 
@@ -3833,6 +4292,13 @@ describe('chatStore history mapping', () => {
           statusVerb: 'Thinking',
           slashCommands: [],
           agentTaskNotifications: {},
+          queuedUserMessages: [{
+            id: 'queued-before-clear',
+            content: 'do not replay after clear',
+            displayContent: 'do not replay after clear',
+            attachments: [],
+            createdAt: Date.now(),
+          }],
           elapsedTimer: null,
         },
       },
@@ -3847,9 +4313,19 @@ describe('chatStore history mapping', () => {
       subtype: 'session_cleared',
       message: 'Conversation cleared',
     })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'message_complete',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
 
     const session = useChatStore.getState().sessions[TEST_SESSION_ID]
     expect(session?.messages).toEqual([])
+    expect(session?.queuedUserMessages).toEqual([])
+    expect(sendMock).not.toHaveBeenCalledWith(TEST_SESSION_ID, {
+      type: 'user_message',
+      content: 'do not replay after clear',
+      attachments: [],
+    })
     expect(session?.streamingText).toBe('')
     expect(session?.chatState).toBe('idle')
     expect(session?.tokenUsage).toEqual({ input_tokens: 0, output_tokens: 0 })
@@ -3864,6 +4340,79 @@ describe('chatStore history mapping', () => {
     vi.useRealTimers()
   })
 
+  it('does not restore cleared messages or tasks from an in-flight history load', async () => {
+    let resolveHistory!: (value: {
+      messages: MessageEntry[]
+      taskNotifications: Array<{
+        taskId: string
+        toolUseId: string
+        status: 'completed'
+        summary: string
+        timestamp: string
+      }>
+    }) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((resolve) => {
+      resolveHistory = resolve
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          messages: [{ id: 'old-user', type: 'user_text', content: 'old turn', timestamp: 1 }],
+          backgroundAgentTasks: {
+            'old-agent': {
+              taskId: 'old-agent',
+              toolUseId: 'old-agent-tool',
+              taskType: 'local_agent',
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        }),
+      },
+    })
+
+    const historyLoad = useChatStore.getState().loadHistory(TEST_SESSION_ID)
+    expect(useChatStore.getState().sessions[TEST_SESSION_ID]?.historyStatus).toBe('loading')
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'session_cleared',
+      message: 'Conversation cleared',
+    })
+
+    resolveHistory({
+      messages: [
+        {
+          id: 'stale-user',
+          type: 'user',
+          timestamp: '2026-07-10T00:00:00.000Z',
+          content: 'stale prompt',
+        },
+        {
+          id: 'stale-assistant',
+          type: 'assistant',
+          timestamp: '2026-07-10T00:00:01.000Z',
+          content: [{ type: 'text', text: 'stale answer' }],
+        },
+      ],
+      taskNotifications: [{
+        taskId: 'old-agent',
+        toolUseId: 'old-agent-tool',
+        status: 'completed',
+        summary: 'Stale task completion',
+        timestamp: '2026-07-10T00:00:02.000Z',
+      }],
+    })
+    await historyLoad
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.messages).toEqual([])
+    expect(session?.backgroundAgentTasks).toEqual({})
+    expect(session?.agentTaskNotifications).toEqual({})
+    expect(session?.historyStatus).toBe('ready')
+  })
+
   it('clears local message state for only the requested session', () => {
     useChatStore.setState({
       sessions: {
@@ -4261,6 +4810,716 @@ describe('chatStore history mapping', () => {
     }))
   })
 
+  it('reconciles a persisted stopped SubAgent after its terminal event was missed offline', async () => {
+    vi.mocked(sessionsApi.getMessages).mockClear()
+    vi.mocked(sessionsApi.getMessages).mockResolvedValueOnce({
+      messages: [],
+      taskNotifications: [
+        {
+          taskId: 'agent-task-1',
+          toolUseId: 'agent-tool-1',
+          status: 'stopped',
+          summary: 'Agent was stopped while the renderer was offline',
+          timestamp: '2026-07-10T00:00:00.000Z',
+        },
+      ],
+    })
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          stopAllSubagentsRequested: true,
+          backgroundAgentTasks: {
+            'agent-task-1': {
+              taskId: 'agent-task-1',
+              toolUseId: 'agent-tool-1',
+              status: 'running',
+              taskType: 'local_agent',
+              description: 'Review screenshots',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+
+    await vi.waitFor(() => {
+      expect(
+        useChatStore.getState().sessions[TEST_SESSION_ID]
+          ?.backgroundAgentTasks?.['agent-task-1']?.status,
+      ).toBe('stopped')
+    })
+    expect(sessionsApi.getMessages).toHaveBeenCalledWith(TEST_SESSION_ID)
+    expect(updateTabStatusMock).toHaveBeenLastCalledWith(TEST_SESSION_ID, 'idle')
+  })
+
+  it('keeps a genuinely running SubAgent when idle reconnect history has no terminal event', async () => {
+    vi.mocked(sessionsApi.getMessages).mockClear()
+    vi.mocked(sessionsApi.getMessages).mockResolvedValueOnce({
+      messages: [],
+      taskNotifications: [],
+    })
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          backgroundAgentTasks: {
+            'agent-task-1': {
+              taskId: 'agent-task-1',
+              toolUseId: 'agent-tool-1',
+              status: 'running',
+              taskType: 'local_agent',
+              description: 'Still reviewing screenshots',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledWith(TEST_SESSION_ID)
+      expect(updateTabStatusMock).toHaveBeenLastCalledWith(TEST_SESSION_ID, 'running')
+    })
+    expect(
+      useChatStore.getState().sessions[TEST_SESSION_ID]
+        ?.backgroundAgentTasks?.['agent-task-1']?.status,
+    ).toBe('running')
+  })
+
+  it('does not let an older persisted terminal overwrite a new lifecycle with the same Agent id', async () => {
+    vi.mocked(sessionsApi.getMessages).mockClear()
+    vi.mocked(sessionsApi.getMessages).mockResolvedValueOnce({
+      messages: [],
+      taskNotifications: [
+        {
+          taskId: 'agent-task-reused',
+          toolUseId: 'agent-tool-reused',
+          status: 'stopped',
+          summary: 'Previous lifecycle stopped',
+          timestamp: '2026-07-10T00:00:00.000Z',
+        },
+      ],
+    })
+    const newLifecycleStartedAt = new Date('2026-07-11T00:00:00.000Z').getTime()
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          backgroundAgentTasks: {
+            'agent-task-reused': {
+              taskId: 'agent-task-reused',
+              toolUseId: 'agent-tool-reused',
+              status: 'running',
+              taskType: 'local_agent',
+              description: 'New lifecycle is still reviewing',
+              startedAt: newLifecycleStartedAt,
+              updatedAt: newLifecycleStartedAt,
+            },
+          },
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledWith(TEST_SESSION_ID)
+      expect(updateTabStatusMock).toHaveBeenLastCalledWith(TEST_SESSION_ID, 'running')
+    })
+    expect(
+      useChatStore.getState().sessions[TEST_SESSION_ID]
+        ?.backgroundAgentTasks?.['agent-task-reused']?.status,
+    ).toBe('running')
+  })
+
+  it('lets fresh reconnect reconciliation follow an older in-flight history load', async () => {
+    let resolveOlderHistory!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    vi.mocked(sessionsApi.getMessages).mockClear()
+    vi.mocked(sessionsApi.getMessages)
+      .mockReturnValueOnce(new Promise((resolve) => {
+        resolveOlderHistory = resolve
+      }))
+      .mockResolvedValueOnce({
+        messages: [],
+        taskNotifications: [
+          {
+            taskId: 'agent-task-history-order',
+            toolUseId: 'agent-tool-history-order',
+            status: 'stopped',
+            summary: 'Fresh history observed the stopped Agent',
+            timestamp: '2026-07-12T00:00:00.000Z',
+          },
+        ],
+      })
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          backgroundAgentTasks: {
+            'agent-task-history-order': {
+              taskId: 'agent-task-history-order',
+              toolUseId: 'agent-tool-history-order',
+              status: 'running',
+              taskType: 'local_agent',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        }),
+      },
+    })
+
+    const olderLoad = useChatStore.getState().loadHistory(TEST_SESSION_ID)
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(1)
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    resolveOlderHistory({ messages: [], taskNotifications: [] })
+    await olderLoad
+
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(2)
+      expect(
+        useChatStore.getState().sessions[TEST_SESSION_ID]
+          ?.backgroundAgentTasks?.['agent-task-history-order']?.status,
+      ).toBe('stopped')
+    })
+  })
+
+  it('does not let an older concurrent reload overwrite the latest history snapshot', async () => {
+    let resolveOlderReload!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    let resolveLatestReload!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    vi.mocked(sessionsApi.getMessages)
+      .mockReturnValueOnce(new Promise((resolve) => {
+        resolveOlderReload = resolve
+      }))
+      .mockReturnValueOnce(new Promise((resolve) => {
+        resolveLatestReload = resolve
+      }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          backgroundAgentTasks: {
+            'agent-task-concurrent-reload': {
+              taskId: 'agent-task-concurrent-reload',
+              toolUseId: 'agent-tool-concurrent-reload',
+              taskType: 'local_agent',
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(2)
+    })
+
+    resolveLatestReload({
+      messages: [{
+        id: 'latest-history-answer',
+        type: 'assistant',
+        timestamp: '2026-07-12T00:00:01.000Z',
+        content: [{ type: 'text', text: 'latest history answer' }],
+      }],
+      taskNotifications: [],
+    })
+    await vi.waitFor(() => {
+      expect(useChatStore.getState().sessions[TEST_SESSION_ID]?.messages).toContainEqual(
+        expect.objectContaining({
+          type: 'assistant_text',
+          content: 'latest history answer',
+        }),
+      )
+    })
+
+    resolveOlderReload({
+      messages: [{
+        id: 'older-history-answer',
+        type: 'assistant',
+        timestamp: '2026-07-12T00:00:00.000Z',
+        content: [{ type: 'text', text: 'older history answer' }],
+      }],
+      taskNotifications: [],
+    })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const messages = useChatStore.getState().sessions[TEST_SESSION_ID]?.messages ?? []
+    expect(messages).toContainEqual(expect.objectContaining({
+      type: 'assistant_text',
+      content: 'latest history answer',
+    }))
+    expect(messages).not.toContainEqual(expect.objectContaining({
+      type: 'assistant_text',
+      content: 'older history answer',
+    }))
+  })
+
+  it('does not let delayed idle task reconciliation overwrite a newly sent turn', async () => {
+    let resolveHistory!: (value: {
+      messages: MessageEntry[]
+      taskNotifications: Array<{
+        taskId: string
+        toolUseId: string
+        status: 'stopped'
+        summary: string
+        timestamp: string
+      }>
+    }) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((resolve) => {
+      resolveHistory = resolve
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          stopAllSubagentsRequested: true,
+          messages: [{ id: 'old-user', type: 'user_text', content: 'old turn', timestamp: 1 }],
+          backgroundAgentTasks: {
+            'agent-task-1': {
+              taskId: 'agent-task-1',
+              toolUseId: 'agent-tool-1',
+              status: 'running',
+              taskType: 'local_agent',
+              description: 'Review screenshots',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledWith(TEST_SESSION_ID)
+    })
+    useChatStore.getState().sendMessage(TEST_SESSION_ID, 'new turn')
+
+    resolveHistory({
+      messages: [],
+      taskNotifications: [
+        {
+          taskId: 'agent-task-1',
+          toolUseId: 'agent-tool-1',
+          status: 'stopped',
+          summary: 'Agent was stopped while the renderer was offline',
+          timestamp: '2026-07-10T00:00:00.000Z',
+        },
+      ],
+    })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.chatState).toBe('thinking')
+    expect(session?.messages).toContainEqual(expect.objectContaining({
+      type: 'user_text',
+      content: 'new turn',
+    }))
+    expect(session?.backgroundAgentTasks?.['agent-task-1']?.status).toBe('running')
+    expect(session?.agentTaskNotifications?.['agent-tool-1']).toBeUndefined()
+    if (session?.elapsedTimer) clearInterval(session.elapsedTimer)
+  })
+
+  it('does not let delayed idle reconciliation overwrite an externally completed turn', async () => {
+    let resolveHistory!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((resolve) => {
+      resolveHistory = resolve
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          stopAllSubagentsRequested: true,
+          messages: [{ id: 'old-user', type: 'user_text', content: 'old turn', timestamp: 1 }],
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(1)
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'user_message_replay',
+      content: 'externally started turn',
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'content_start',
+      blockType: 'text',
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'content_delta',
+      text: 'external answer',
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'message_complete',
+      usage: { input_tokens: 3, output_tokens: 2 },
+    })
+
+    resolveHistory({
+      messages: [{
+        id: 'stale-assistant',
+        type: 'assistant',
+        timestamp: '2026-07-10T00:00:00.000Z',
+        content: [{ type: 'text', text: 'stale completed answer' }],
+      }],
+      taskNotifications: [],
+    })
+
+    await vi.waitFor(() => {
+      const messages = useChatStore.getState().sessions[TEST_SESSION_ID]?.messages ?? []
+      expect(messages).toContainEqual(expect.objectContaining({
+        type: 'assistant_text',
+        content: 'external answer',
+      }))
+    })
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.chatState).toBe('idle')
+    expect(session?.messages).toContainEqual(expect.objectContaining({
+      type: 'user_text',
+      content: 'externally started turn',
+    }))
+    expect(session?.messages).not.toContainEqual(expect.objectContaining({
+      type: 'assistant_text',
+      content: 'stale completed answer',
+    }))
+    if (session?.elapsedTimer) clearInterval(session.elapsedTimer)
+  })
+
+  it('protects a live completion from reconciliation started after its user replay', async () => {
+    let resolveHistory!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((resolve) => {
+      resolveHistory = resolve
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          backgroundAgentTasks: {
+            'agent-task-existing': {
+              taskId: 'agent-task-existing',
+              toolUseId: 'agent-tool-existing',
+              taskType: 'local_agent',
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'user_message_replay',
+      content: 'external turn already replayed',
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(1)
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'content_start',
+      blockType: 'text',
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'content_delta',
+      text: 'live completion after replay',
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'message_complete',
+      usage: { input_tokens: 4, output_tokens: 4 },
+    })
+    resolveHistory({
+      messages: [{
+        id: 'stale-after-replay',
+        type: 'assistant',
+        timestamp: '2026-07-10T00:00:00.000Z',
+        content: [{ type: 'text', text: 'stale answer fetched after replay' }],
+      }],
+      taskNotifications: [],
+    })
+
+    await vi.waitFor(() => {
+      expect(useChatStore.getState().sessions[TEST_SESSION_ID]?.messages).toContainEqual(
+        expect.objectContaining({
+          type: 'assistant_text',
+          content: 'live completion after replay',
+        }),
+      )
+    })
+    expect(useChatStore.getState().sessions[TEST_SESSION_ID]?.messages).not.toContainEqual(
+      expect.objectContaining({
+        type: 'assistant_text',
+        content: 'stale answer fetched after replay',
+      }),
+    )
+  })
+
+  it('does not let delayed idle reconciliation overwrite a live API error', async () => {
+    let resolveHistory!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((resolve) => {
+      resolveHistory = resolve
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          stopAllSubagentsRequested: true,
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(1)
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'error',
+      message: 'Model API request failed',
+      code: 'API_ERROR',
+    })
+
+    resolveHistory({
+      messages: [{
+        id: 'stale-before-error',
+        type: 'assistant',
+        timestamp: '2026-07-10T00:00:00.000Z',
+        content: [{ type: 'text', text: 'stale answer before error' }],
+      }],
+      taskNotifications: [],
+    })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.chatState).toBe('idle')
+    expect(session?.messages).toContainEqual(expect.objectContaining({
+      type: 'error',
+      code: 'API_ERROR',
+      message: 'Model API request failed',
+    }))
+    expect(session?.messages).not.toContainEqual(expect.objectContaining({
+      type: 'assistant_text',
+      content: 'stale answer before error',
+    }))
+  })
+
+  it('does not let delayed idle reconciliation overwrite a known stop failure', async () => {
+    let resolveHistory!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((resolve) => {
+      resolveHistory = resolve
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          stopAllSubagentsRequested: true,
+          stoppingBackgroundTaskIds: { 'agent-task-stop-failed': true },
+          backgroundAgentTasks: {
+            'agent-task-stop-failed': {
+              taskId: 'agent-task-stop-failed',
+              toolUseId: 'agent-tool-stop-failed',
+              taskType: 'local_agent',
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(1)
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-stop-failed',
+      message: 'The server could not stop this Agent',
+    })
+
+    resolveHistory({
+      messages: [{
+        id: 'stale-assistant',
+        type: 'assistant',
+        timestamp: '2026-07-10T00:00:00.000Z',
+        content: [{ type: 'text', text: 'stale history' }],
+      }],
+      taskNotifications: [],
+    })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.stoppingBackgroundTaskIds).toEqual({})
+    expect(session?.messages).toContainEqual(expect.objectContaining({
+      type: 'error',
+      code: 'STOP_BACKGROUND_TASK_FAILED',
+      message: 'The server could not stop this Agent',
+    }))
+    expect(session?.messages).not.toContainEqual(expect.objectContaining({
+      type: 'assistant_text',
+      content: 'stale history',
+    }))
+  })
+
+  it('does not let delayed idle reconciliation discard a newly started Agent', async () => {
+    let resolveHistory!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((resolve) => {
+      resolveHistory = resolve
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          stopAllSubagentsRequested: true,
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(1)
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'task_started',
+      data: {
+        task_id: 'agent-task-started-during-reload',
+        tool_use_id: 'agent-tool-started-during-reload',
+        task_type: 'local_agent',
+        description: 'New Agent lifecycle',
+      },
+    })
+
+    resolveHistory({ messages: [], taskNotifications: [] })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.backgroundAgentTasks?.['agent-task-started-during-reload']).toMatchObject({
+      status: 'running',
+      taskType: 'local_agent',
+      description: 'New Agent lifecycle',
+    })
+    expect(session?.stoppingBackgroundTaskIds).toEqual({
+      'agent-task-started-during-reload': true,
+    })
+    expect(updateTabStatusMock).toHaveBeenLastCalledWith(TEST_SESSION_ID, 'running')
+  })
+
+  it('does not let delayed idle reconciliation discard a terminal Agent notification', async () => {
+    let resolveHistory!: (value: { messages: MessageEntry[]; taskNotifications: [] }) => void
+    vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((resolve) => {
+      resolveHistory = resolve
+    }))
+    useChatStore.setState({
+      sessions: {
+        [TEST_SESSION_ID]: makeSession({
+          chatState: 'idle',
+          stopAllSubagentsRequested: true,
+          stoppingBackgroundTaskIds: { 'agent-task-terminal-during-reload': true },
+          backgroundAgentTasks: {
+            'agent-task-terminal-during-reload': {
+              taskId: 'agent-task-terminal-during-reload',
+              toolUseId: 'agent-tool-terminal-during-reload',
+              taskType: 'local_agent',
+              status: 'running',
+              startedAt: 1,
+              updatedAt: 2,
+            },
+          },
+        }),
+      },
+    })
+
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'session_state',
+      turnState: 'idle',
+    })
+    await vi.waitFor(() => {
+      expect(sessionsApi.getMessages).toHaveBeenCalledTimes(1)
+    })
+    useChatStore.getState().handleServerMessage(TEST_SESSION_ID, {
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: {
+        task_id: 'agent-task-terminal-during-reload',
+        tool_use_id: 'agent-tool-terminal-during-reload',
+        task_type: 'local_agent',
+        status: 'stopped',
+        summary: 'Agent stopped while history was loading',
+        result: 'Stopped by user',
+      },
+    })
+
+    resolveHistory({ messages: [], taskNotifications: [] })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const session = useChatStore.getState().sessions[TEST_SESSION_ID]
+    expect(session?.backgroundAgentTasks?.['agent-task-terminal-during-reload']).toMatchObject({
+      status: 'stopped',
+      summary: 'Agent stopped while history was loading',
+      result: 'Stopped by user',
+    })
+    expect(session?.agentTaskNotifications?.['agent-tool-terminal-during-reload']).toMatchObject({
+      status: 'stopped',
+      summary: 'Agent stopped while history was loading',
+      result: 'Stopped by user',
+    })
+    expect(session?.stoppingBackgroundTaskIds).toEqual({})
+    expect(updateTabStatusMock).toHaveBeenLastCalledWith(TEST_SESSION_ID, 'idle')
+  })
+
   it('does not let delayed reconnect history overwrite a newly sent turn', async () => {
     let resolveHistory!: (value: { messages: MessageEntry[] }) => void
     vi.mocked(sessionsApi.getMessages).mockReturnValueOnce(new Promise((resolve) => {
diff --git a/desktop/src/stores/chatStore.ts b/desktop/src/stores/chatStore.ts
index fb6cc7b7..28678533 100644
--- a/desktop/src/stores/chatStore.ts
+++ b/desktop/src/stores/chatStore.ts
@@ -9,7 +9,7 @@ import { useTabStore } from './tabStore'
 import { randomSpinnerVerb } from '../config/spinnerVerbs'
 import { notifyDesktop } from '../lib/desktopNotifications'
 import { deriveSessionTitle, isPlaceholderSessionTitle } from '../lib/sessionTitle'
-import { hasRunningBackgroundTasks } from '../lib/backgroundTasks'
+import { hasRunningBackgroundTasks, hasRunningSubagentTasks } from '../lib/backgroundTasks'
 import { AGENT_LIFECYCLE_TYPES } from '../types/team'
 import type { ComposerAttachment } from '../lib/composerAttachments'
 import type { MessageEntry } from '../types/session'
@@ -135,6 +135,9 @@ export type PerSessionState = {
   agentTaskNotifications: Record<string, AgentTaskNotification>
   backgroundAgentTasks?: Record<string, BackgroundAgentTask>
   stoppingBackgroundTaskIds?: Record<string, boolean>
+  pendingBackgroundTaskStopFailures?: Record<string, string>
+  stopAllSubagentsRequested?: boolean
+  historyMutationEpoch?: number
   suppressNextTaskNotificationResponse?: boolean
   replaceHistoryOnCompletion?: boolean
   activeGoal?: ActiveGoalState | null
@@ -177,6 +180,9 @@ const DEFAULT_SESSION_STATE: PerSessionState = {
   agentTaskNotifications: {},
   backgroundAgentTasks: {},
   stoppingBackgroundTaskIds: {},
+  pendingBackgroundTaskStopFailures: {},
+  stopAllSubagentsRequested: false,
+  historyMutationEpoch: 0,
   suppressNextTaskNotificationResponse: false,
   replaceHistoryOnCompletion: false,
   activeGoal: null,
@@ -308,6 +314,7 @@ type ChatStore = {
     guard?: {
       messages: UIMessage[]
       backgroundAgentTasks?: Record<string, BackgroundAgentTask>
+      preserveUnresolvedBackgroundTasks?: boolean
     },
   ) => Promise<void>
   queueComposerPrefill: (
@@ -800,6 +807,12 @@ function isAgentBackgroundTask(task: Pick<BackgroundAgentTask, 'taskType' | 'sum
   )
 }
 
+function isCancellableSubagentTask(task: BackgroundAgentTask): boolean {
+  return task.status === 'running' && (
+    task.taskType === 'local_agent' || task.taskType === 'remote_agent'
+  )
+}
+
 function shouldSuppressTaskNotificationResponse(session: PerSessionState): boolean {
   if (session.chatState !== 'idle') return false
   const lastMessage = session.messages[session.messages.length - 1]
@@ -1128,6 +1141,7 @@ async function fetchAndMapSessionHistory(sessionId: string) {
 }
 
 const historyLoadsInFlight = new Map<string, Promise<void>>()
+const historyReloadGenerations = new Map<string, number>()
 
 function shouldPrewarmSession(sessionId: string): boolean {
   const knownSession = useSessionStore.getState().sessions.find((session) => session.id === sessionId)
@@ -1176,9 +1190,13 @@ export const useChatStore = create<ChatStore>((set, get) => ({
     wsManager.onConnectionState(sessionId, (connectionState) => {
       if (!get().sessions[sessionId]) return
       set((s) => ({
-        sessions: updateSessionIn(s.sessions, sessionId, () => ({
+        sessions: updateSessionIn(s.sessions, sessionId, (session) => ({
           connectionState,
           connectionSnapshotReady: false,
+          stoppingBackgroundTaskIds:
+            connectionState === 'connected' || session.stopAllSubagentsRequested
+              ? session.stoppingBackgroundTaskIds
+              : {},
         })),
       }))
     })
@@ -1321,6 +1339,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
             ...session,
             messages: newMessages,
             chatState: 'thinking',
+            historyMutationEpoch: (session.historyMutationEpoch ?? 0) + 1,
             elapsedSeconds: 0,
             suppressNextTaskNotificationResponse: false,
             replaceHistoryOnCompletion: false,
@@ -1441,6 +1460,12 @@ export const useChatStore = create<ChatStore>((set, get) => ({
       if (!session) return s
       hasRunningBackgroundAgents = hasRunningBackgroundTasks(session.backgroundAgentTasks)
       if (session.elapsedTimer) clearInterval(session.elapsedTimer)
+      const stoppingBackgroundTaskIds = { ...session.stoppingBackgroundTaskIds }
+      for (const task of Object.values(session.backgroundAgentTasks ?? {})) {
+        if (isCancellableSubagentTask(task)) {
+          stoppingBackgroundTaskIds[task.taskId] = true
+        }
+      }
       const pendingAssistantText = `${session.streamingText}${bufferedText}`
       const messagesWithFlushedText = pendingAssistantText.trim()
         ? appendAssistantTextMessage(session.messages, pendingAssistantText, Date.now())
@@ -1465,6 +1490,8 @@ export const useChatStore = create<ChatStore>((set, get) => ({
             apiRetry: null,
             streamingFallback: null,
             suppressNextTaskNotificationResponse: false,
+            stoppingBackgroundTaskIds,
+            stopAllSubagentsRequested: true,
             elapsedTimer: null,
           },
         },
@@ -1493,6 +1520,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
     const existingLoad = historyLoadsInFlight.get(sessionId)
     if (existingLoad) return existingLoad
 
+    const requestedMutationEpoch = get().sessions[sessionId]?.historyMutationEpoch ?? 0
     let load!: Promise<void>
     load = (async () => {
       try {
@@ -1515,39 +1543,70 @@ export const useChatStore = create<ChatStore>((set, get) => ({
           hasMessagesAfterTaskCompletion,
           tokenUsage,
         } = await fetchAndMapSessionHistory(sessionId)
+        let historyApplied = false
         set((state) => {
           const session = state.sessions[sessionId]
           if (!session) return state
+          if ((session.historyMutationEpoch ?? 0) !== requestedMutationEpoch) {
+            const abortedLoadUpdate = buildAbortedHistoryLoadUpdate(session)
+            return Object.keys(abortedLoadUpdate).length > 0
+              ? {
+                  sessions: updateSessionIn(
+                    state.sessions,
+                    sessionId,
+                    () => abortedLoadUpdate,
+                  ),
+                }
+              : state
+          }
+          historyApplied = true
           if (session.messages.length > 0) {
-            return { sessions: updateSessionIn(state.sessions, sessionId, (s) => ({
-              historyStatus: 'ready',
-              historyError: null,
-              activeGoal: activeGoal ?? s.activeGoal ?? null,
-              agentTaskNotifications: { ...s.agentTaskNotifications, ...restoredNotifications },
-              backgroundAgentTasks: mergeBackgroundAgentTaskRecords(
+            return { sessions: updateSessionIn(state.sessions, sessionId, (s) => {
+              const backgroundAgentTasks = mergeBackgroundAgentTaskRecords(
                 s.backgroundAgentTasks ?? {},
                 restoredBackgroundTasks,
-              ),
-              tokenUsage: tokenUsage ?? s.tokenUsage,
-              messages: mergeRestoredHistoryIntoLiveMessages(
-                mergeBackgroundTaskMessages(s.messages, restoredBackgroundTasks),
+              )
+              const messages = mergeRestoredHistoryIntoLiveMessages(
+                mergeBackgroundTaskMessages(s.messages, backgroundAgentTasks),
                 uiMessages,
-              ),
-            })) }
+              )
+              return {
+                historyStatus: 'ready',
+                historyError: null,
+                activeGoal: activeGoal ?? s.activeGoal ?? null,
+                agentTaskNotifications: { ...restoredNotifications, ...s.agentTaskNotifications },
+                backgroundAgentTasks,
+                tokenUsage: tokenUsage ?? s.tokenUsage,
+                ...reconcilePendingBackgroundTaskStopFailures(
+                  s,
+                  backgroundAgentTasks,
+                  messages,
+                ),
+              }
+            }) }
           }
-          return { sessions: updateSessionIn(state.sessions, sessionId, (s) => ({
-            historyStatus: 'ready',
-            historyError: null,
-            messages: mergeBackgroundTaskMessages(uiMessages, restoredBackgroundTasks),
-            activeGoal,
-            agentTaskNotifications: { ...s.agentTaskNotifications, ...restoredNotifications },
-            backgroundAgentTasks: mergeBackgroundAgentTaskRecords(
+          return { sessions: updateSessionIn(state.sessions, sessionId, (s) => {
+            const backgroundAgentTasks = mergeBackgroundAgentTaskRecords(
               s.backgroundAgentTasks ?? {},
               restoredBackgroundTasks,
-            ),
-            tokenUsage: tokenUsage ?? s.tokenUsage,
-          })) }
+            )
+            const messages = mergeBackgroundTaskMessages(uiMessages, backgroundAgentTasks)
+            return {
+              historyStatus: 'ready',
+              historyError: null,
+              activeGoal,
+              agentTaskNotifications: { ...restoredNotifications, ...s.agentTaskNotifications },
+              backgroundAgentTasks,
+              tokenUsage: tokenUsage ?? s.tokenUsage,
+              ...reconcilePendingBackgroundTaskStopFailures(
+                s,
+                backgroundAgentTasks,
+                messages,
+              ),
+            }
+          }) }
         })
+        if (!historyApplied) return
         if (lastTodos && lastTodos.length > 0) {
           const taskStore = useCLITaskStore.getState()
           if (taskStore.sessionId === sessionId && taskStore.tasks.length === 0) taskStore.setTasksFromTodos(lastTodos, sessionId)
@@ -1562,10 +1621,28 @@ export const useChatStore = create<ChatStore>((set, get) => ({
         set((state) => {
           const session = state.sessions[sessionId]
           if (!session) return state
+          if ((session.historyMutationEpoch ?? 0) !== requestedMutationEpoch) {
+            const abortedLoadUpdate = buildAbortedHistoryLoadUpdate(session)
+            return Object.keys(abortedLoadUpdate).length > 0
+              ? {
+                  sessions: updateSessionIn(
+                    state.sessions,
+                    sessionId,
+                    () => abortedLoadUpdate,
+                  ),
+                }
+              : state
+          }
+          const pendingFailureUpdate = reconcilePendingBackgroundTaskStopFailures(
+            session,
+            session.backgroundAgentTasks ?? {},
+            session.messages,
+          )
           return {
             sessions: updateSessionIn(state.sessions, sessionId, () => ({
               historyStatus: 'error',
               historyError: error instanceof Error ? error.message : String(error),
+              ...pendingFailureUpdate,
             })),
           }
         })
@@ -1581,7 +1658,12 @@ export const useChatStore = create<ChatStore>((set, get) => ({
   },
 
   reloadHistory: async (sessionId, guard) => {
+    const reloadGeneration = (historyReloadGenerations.get(sessionId) ?? 0) + 1
+    historyReloadGenerations.set(sessionId, reloadGeneration)
     try {
+      const requestedMutationEpoch = get().sessions[sessionId]?.historyMutationEpoch ?? 0
+      const pendingLoad = historyLoadsInFlight.get(sessionId)
+      if (pendingLoad) await pendingLoad
       const {
         uiMessages,
         activeGoal,
@@ -1592,30 +1674,41 @@ export const useChatStore = create<ChatStore>((set, get) => ({
         tokenUsage,
       } = await fetchAndMapSessionHistory(sessionId)
 
+      if (historyReloadGenerations.get(sessionId) !== reloadGeneration) return
+
       if (guard) {
         const current = get().sessions[sessionId]
         if (
           !current ||
           current.chatState !== 'idle' ||
-          current.messages !== guard.messages ||
-          current.backgroundAgentTasks !== guard.backgroundAgentTasks
+          (current.historyMutationEpoch ?? 0) !== requestedMutationEpoch
         ) {
           return
         }
       }
 
+      let historyApplied = false
       set((state) => {
         const session = state.sessions[sessionId]
         if (!session) return state
         if (session.elapsedTimer) clearInterval(session.elapsedTimer)
+        const backgroundAgentTasks = guard?.preserveUnresolvedBackgroundTasks
+          ? mergeBackgroundAgentTaskRecords(
+              session.backgroundAgentTasks ?? {},
+              restoredBackgroundTasks,
+            )
+          : restoredBackgroundTasks
+        const messages = mergeBackgroundTaskMessages(uiMessages, backgroundAgentTasks)
+        historyApplied = true
         return {
           sessions: updateSessionIn(state.sessions, sessionId, () => ({
             historyStatus: 'ready',
             historyError: null,
-            messages: mergeBackgroundTaskMessages(uiMessages, restoredBackgroundTasks),
             activeGoal,
-            agentTaskNotifications: restoredNotifications,
-            backgroundAgentTasks: restoredBackgroundTasks,
+            agentTaskNotifications: guard?.preserveUnresolvedBackgroundTasks
+              ? { ...restoredNotifications, ...session.agentTaskNotifications }
+              : restoredNotifications,
+            backgroundAgentTasks,
             tokenUsage: tokenUsage ?? session.tokenUsage,
             chatState: 'idle',
             activeThinkingId: null,
@@ -1631,10 +1724,27 @@ export const useChatStore = create<ChatStore>((set, get) => ({
             statusVerb: '',
             apiRetry: null,
             streamingFallback: null,
+            ...reconcilePendingBackgroundTaskStopFailures(
+              session,
+              backgroundAgentTasks,
+              messages,
+            ),
           })),
         }
       })
 
+      if (historyApplied) {
+        const reloadedSession = get().sessions[sessionId]
+        if (reloadedSession) {
+          const isRunning = reloadedSession.chatState !== 'idle' ||
+            hasRunningBackgroundTasks(reloadedSession.backgroundAgentTasks)
+          useTabStore.getState().updateTabStatus(
+            sessionId,
+            isRunning ? 'running' : 'idle',
+          )
+        }
+      }
+
       if (lastTodos && lastTodos.length > 0) {
         useCLITaskStore.getState().setTasksFromTodos(lastTodos, sessionId)
       } else {
@@ -1644,7 +1754,23 @@ export const useChatStore = create<ChatStore>((set, get) => ({
         useCLITaskStore.getState().markCompletedAndDismissed(sessionId)
       }
     } catch {
-      // Session may not have messages yet
+      // A stop failure can arrive before the task history that identifies it.
+      // If that history request fails, surface the failure instead of leaving it
+      // cached forever waiting for a reconciliation that may never happen.
+      set((state) => {
+        const session = state.sessions[sessionId]
+        if (!session || Object.keys(session.pendingBackgroundTaskStopFailures ?? {}).length === 0) {
+          return state
+        }
+        return {
+          sessions: updateSessionIn(state.sessions, sessionId, (current) =>
+            reconcilePendingBackgroundTaskStopFailures(
+              current,
+              current.backgroundAgentTasks ?? {},
+              current.messages,
+            )),
+        }
+      })
     }
   },
 
@@ -1901,7 +2027,21 @@ export const useChatStore = create<ChatStore>((set, get) => ({
           break
         }
 
-        if (session.chatState === 'idle') break
+        if (session.chatState === 'idle') {
+          if (
+            hasRunningSubagentTasks(session.backgroundAgentTasks) ||
+            session.stopAllSubagentsRequested
+          ) {
+            // A terminal task event may have been persisted while this renderer
+            // was offline. Reconcile it without overwriting a newly started turn.
+            void get().reloadHistory(sessionId, {
+              messages: session.messages,
+              backgroundAgentTasks: session.backgroundAgentTasks,
+              preserveUnresolvedBackgroundTasks: true,
+            })
+          }
+          break
+        }
 
         const text = `${session.streamingText}${consumePendingDelta(sessionId)}`
         clearPendingToolInputDelta(sessionId)
@@ -2031,6 +2171,13 @@ export const useChatStore = create<ChatStore>((set, get) => ({
         if (session.suppressNextTaskNotificationResponse) {
           update(() => ({ suppressNextTaskNotificationResponse: false }))
         }
+        // The server keeps a stopped-turn fence until it attributes a replay
+        // (or a pure local command's first output) to the replacement turn.
+        // Mirror that boundary instead of clearing the SubAgent stop latch on
+        // the optimistic send, which may still be rejected or remain pending.
+        if (session.stopAllSubagentsRequested) {
+          update(() => ({ stopAllSubagentsRequested: false }))
+        }
         const pendingText = `${session.streamingText}${consumePendingDelta(sessionId)}`
         if (msg.blockType !== 'text' && pendingText.trim()) {
           update((s) => ({
@@ -2539,7 +2686,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
           clearPendingToolInputDelta(sessionId)
           if (session.elapsedTimer) clearInterval(session.elapsedTimer)
           const hasRunningBackgroundAgents = hasRunningBackgroundTasks(session.backgroundAgentTasks)
-          update(() => ({
+          update((current) => ({
             tokenUsage: msg.usage,
             chatState: 'idle',
             activeThinkingId: null,
@@ -2554,6 +2701,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
             streamingToolInput: '',
             suppressNextTaskNotificationResponse: false,
             replaceHistoryOnCompletion: false,
+            historyMutationEpoch: (current.historyMutationEpoch ?? 0) + 1,
           }))
           useTabStore.getState().updateTabStatus(sessionId, hasRunningBackgroundAgents ? 'running' : 'idle')
           reconcileCompletedTranscriptHistory(
@@ -2583,7 +2731,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
         const finalMessages = markPendingToolUseMessagesStopped(completionMessages)
         const hasRunningBackgroundAgents = hasRunningBackgroundTasks(session.backgroundAgentTasks)
         if (session.elapsedTimer) clearInterval(session.elapsedTimer)
-        update(() => ({
+        update((current) => ({
           messages: finalMessages,
           tokenUsage: msg.usage,
           chatState: 'idle',
@@ -2596,6 +2744,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
           apiRetry: null,
           streamingFallback: null,
           replaceHistoryOnCompletion: false,
+          historyMutationEpoch: (current.historyMutationEpoch ?? 0) + 1,
         }))
         useTabStore.getState().updateTabStatus(sessionId, hasRunningBackgroundAgents ? 'running' : 'idle')
         const notification = wasAgentRunning && appendedCompletionMessage
@@ -2633,6 +2782,8 @@ export const useChatStore = create<ChatStore>((set, get) => ({
             activeThinkingId: null,
             suppressNextTaskNotificationResponse: false,
             replaceHistoryOnCompletion: false,
+            stopAllSubagentsRequested: false,
+            historyMutationEpoch: (session.historyMutationEpoch ?? 0) + 1,
           }
         })
         break
@@ -2670,6 +2821,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
             apiRetry: null,
             streamingFallback: null,
             suppressNextTaskNotificationResponse: false,
+            historyMutationEpoch: (s.historyMutationEpoch ?? 0) + 1,
           }
         })
         useTabStore.getState().updateTabStatus(sessionId, 'error')
@@ -2686,7 +2838,17 @@ export const useChatStore = create<ChatStore>((set, get) => ({
         update((session) => {
           const stoppingBackgroundTaskIds = { ...session.stoppingBackgroundTaskIds }
           delete stoppingBackgroundTaskIds[msg.taskId]
-          const taskAlreadyFinished = session.backgroundAgentTasks?.[msg.taskId]?.status !== 'running'
+          const task = session.backgroundAgentTasks?.[msg.taskId]
+          if (!task && session.historyStatus === 'loading') {
+            return {
+              stoppingBackgroundTaskIds,
+              pendingBackgroundTaskStopFailures: {
+                ...session.pendingBackgroundTaskStopFailures,
+                [msg.taskId]: msg.message,
+              },
+            }
+          }
+          const taskAlreadyFinished = task !== undefined && task.status !== 'running'
           return {
             stoppingBackgroundTaskIds,
             ...(taskAlreadyFinished ? {} : {
@@ -2700,6 +2862,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
                   timestamp: Date.now(),
                 },
               ],
+              historyMutationEpoch: (session.historyMutationEpoch ?? 0) + 1,
             }),
           }
         })
@@ -2766,6 +2929,12 @@ export const useChatStore = create<ChatStore>((set, get) => ({
             backgroundAgentTasks: {},
             stoppingBackgroundTaskIds: {},
             agentTaskNotifications: {},
+            pendingBackgroundTaskStopFailures: {},
+            stopAllSubagentsRequested: false,
+            queuedUserMessages: [],
+            historyMutationEpoch: (session?.historyMutationEpoch ?? 0) + 1,
+            historyStatus: 'ready',
+            historyError: null,
           }))
           clearPendingDelta(sessionId)
           clearPendingTaskToolUseIds(sessionId)
@@ -2836,6 +3005,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
           if (goalEvent) {
             update((session) => ({
               activeGoal: applyGoalEventToActiveGoal(session.activeGoal ?? null, goalEvent, Date.now()),
+              stopAllSubagentsRequested: false,
               messages: [
                 ...session.messages,
                 {
@@ -2863,7 +3033,20 @@ export const useChatStore = create<ChatStore>((set, get) => ({
               shouldUpdateIdleTabStatus = session.chatState === 'idle'
               hasRunningBackgroundAgentsAfterUpdate = hasRunningBackgroundTasks(backgroundAgentTasks)
               const task = backgroundAgentTasks[taskEvent.taskId]
-              return buildBackgroundTaskSessionUpdate(session, backgroundAgentTasks, task, now)
+              const stoppingBackgroundTaskIds = { ...session.stoppingBackgroundTaskIds }
+              if (
+                msg.subtype === 'task_started' &&
+                session.stopAllSubagentsRequested &&
+                task &&
+                isCancellableSubagentTask(task)
+              ) {
+                stoppingBackgroundTaskIds[task.taskId] = true
+              }
+              return {
+                ...buildBackgroundTaskSessionUpdate(session, backgroundAgentTasks, task, now),
+                stoppingBackgroundTaskIds,
+                historyMutationEpoch: (session.historyMutationEpoch ?? 0) + 1,
+              }
             })
             if (shouldUpdateIdleTabStatus) {
               useTabStore.getState().updateTabStatus(
@@ -2925,6 +3108,7 @@ export const useChatStore = create<ChatStore>((set, get) => ({
                       }
                     : {}),
                 },
+                historyMutationEpoch: (session.historyMutationEpoch ?? 0) + 1,
               }
             })
             if (shouldUpdateIdleTabStatus) {
@@ -3575,11 +3759,82 @@ function mergeBackgroundAgentTaskRecords(
   restored: Record<string, BackgroundAgentTask>,
 ): Record<string, BackgroundAgentTask> {
   return Object.values(restored).reduce(
-    (tasks, task) => upsertBackgroundAgentTask(tasks, task, task.updatedAt),
+    (tasks, task) => {
+      const existing = tasks[task.taskId] ?? (task.toolUseId
+        ? Object.values(tasks).find((candidate) => candidate.toolUseId === task.toolUseId)
+        : undefined)
+      if (
+        existing?.status === 'running' &&
+        task.status !== 'running' &&
+        task.updatedAt < existing.startedAt
+      ) {
+        return tasks
+      }
+      return upsertBackgroundAgentTask(tasks, task, task.updatedAt)
+    },
     current,
   )
 }
 
+function reconcilePendingBackgroundTaskStopFailures(
+  session: PerSessionState,
+  backgroundAgentTasks: Record<string, BackgroundAgentTask>,
+  messages: UIMessage[],
+): Pick<
+  PerSessionState,
+  | 'messages'
+  | 'pendingBackgroundTaskStopFailures'
+  | 'stoppingBackgroundTaskIds'
+  | 'historyMutationEpoch'
+> {
+  const pendingFailures = { ...session.pendingBackgroundTaskStopFailures }
+  const hasPendingFailures = Object.keys(pendingFailures).length > 0
+  const stoppingBackgroundTaskIds = { ...session.stoppingBackgroundTaskIds }
+  let nextMessages = messages
+
+  for (const [taskId, message] of Object.entries(pendingFailures)) {
+    const task = backgroundAgentTasks[taskId]
+    if (!task || task.status === 'running') {
+      nextMessages = [
+        ...nextMessages,
+        {
+          id: nextId(),
+          type: 'error',
+          message,
+          code: 'STOP_BACKGROUND_TASK_FAILED',
+          timestamp: Date.now(),
+        },
+      ]
+    }
+    delete pendingFailures[taskId]
+    delete stoppingBackgroundTaskIds[taskId]
+  }
+
+  return {
+    messages: nextMessages,
+    pendingBackgroundTaskStopFailures: pendingFailures,
+    stoppingBackgroundTaskIds,
+    historyMutationEpoch: (session.historyMutationEpoch ?? 0) + (hasPendingFailures ? 1 : 0),
+  }
+}
+
+function buildAbortedHistoryLoadUpdate(
+  session: PerSessionState,
+): Partial<PerSessionState> {
+  const hasPendingStopFailures =
+    Object.keys(session.pendingBackgroundTaskStopFailures ?? {}).length > 0
+  return {
+    ...(session.historyStatus === 'loading' ? { historyStatus: 'idle' as const } : {}),
+    ...(hasPendingStopFailures
+      ? reconcilePendingBackgroundTaskStopFailures(
+          session,
+          session.backgroundAgentTasks ?? {},
+          session.messages,
+        )
+      : {}),
+  }
+}
+
 const TEAMMATE_CONTENT_REGEX = /<teammate-message\s+teammate_id="([^"]+)"[^>]*>\n?([\s\S]*?)\n?<\/teammate-message>/g
 
 function extractVisibleTeammateMessageContents(text: string): string[] {
diff --git a/src/entrypoints/sdk/coreSchemas.ts b/src/entrypoints/sdk/coreSchemas.ts
index 5d12268f..ce2785af 100644
--- a/src/entrypoints/sdk/coreSchemas.ts
+++ b/src/entrypoints/sdk/coreSchemas.ts
@@ -1769,6 +1769,7 @@ export const SDKTaskStartedMessageSchema = lazySchema(() =>
     tool_use_id: z.string().optional(),
     description: z.string(),
     task_type: z.string().optional(),
+    remote_session_id: z.string().optional(),
     workflow_name: z
       .string()
       .optional()
diff --git a/src/server/__tests__/conversation-service.test.ts b/src/server/__tests__/conversation-service.test.ts
index b14c29b7..342b4fcc 100644
--- a/src/server/__tests__/conversation-service.test.ts
+++ b/src/server/__tests__/conversation-service.test.ts
@@ -544,6 +544,57 @@ describe('ConversationService', () => {
     expect(JSON.parse(sent[1]!).type).toBe('user')
   })
 
+  test('sendMessage does not enqueue a user turn after its owner is cancelled', async () => {
+    const service = new ConversationService() as any
+    const sent: string[] = []
+    installNetworkTestSession(service, 'cancelled-user-turn', sent)
+    let canSend = true
+    let committed = false
+
+    const pendingSend = service.sendMessage(
+      'cancelled-user-turn',
+      'Do not enqueue this after Stop',
+      undefined,
+      {
+        canSend: () => canSend,
+        messageUuid: 'cancelled-turn-uuid',
+        onCommitted: () => {
+          committed = true
+        },
+      },
+    )
+    canSend = false
+
+    expect(await pendingSend).toBe(false)
+    expect(committed).toBe(false)
+    expect(sent.map((line) => JSON.parse(line).type)).not.toContain('user')
+  })
+
+  test('sendMessage commits the caller UUID with the SDK user payload', async () => {
+    const service = new ConversationService() as any
+    const sent: string[] = []
+    installNetworkTestSession(service, 'identified-user-turn', sent)
+    let committed = false
+
+    expect(await service.sendMessage(
+      'identified-user-turn',
+      'Identify this turn',
+      undefined,
+      {
+        messageUuid: 'identified-turn-uuid',
+        onCommitted: () => {
+          committed = true
+        },
+      },
+    )).toBe(true)
+
+    expect(committed).toBe(true)
+    expect(sent.map((line) => JSON.parse(line))).toContainEqual(expect.objectContaining({
+      type: 'user',
+      uuid: 'identified-turn-uuid',
+    }))
+  })
+
   test('sendMessage hot-applies direct to system routing before the next user turn', async () => {
     const originalBridgeUrl = process.env.CC_HAHA_SYSTEM_PROXY_URL
     process.env.CC_HAHA_SYSTEM_PROXY_URL = 'http://127.0.0.1:17890'
@@ -1266,6 +1317,44 @@ describe('ConversationService', () => {
     expect(completionObserved).toBe(true)
   })
 
+  test('rejects a permission request that arrives behind a stopped turn boundary', () => {
+    const service = new ConversationService() as any
+    const outbound: string[] = []
+    const forwarded: any[] = []
+    service.sessions.set('stopped-permission-boundary', {
+      outputCallbacks: [(message: any) => forwarded.push(message)],
+      seenSdkMessageUuids: new Set<string>(),
+      sdkMessages: [],
+      sdkSocket: { send: (message: string) => outbound.push(message) },
+      pendingOutbound: [],
+      initMessage: null,
+      pendingPermissionRequests: new Map(),
+    })
+
+    service.handleSdkPayload('stopped-permission-boundary', JSON.stringify({
+      type: 'control_request',
+      request_id: 'late-permission',
+      request: {
+        subtype: 'can_use_tool',
+        tool_name: 'Bash',
+        input: { command: 'echo stale' },
+      },
+    }), {
+      canAcceptPermissionRequest: () => false,
+    })
+
+    expect(service.getPendingPermissionRequests('stopped-permission-boundary')).toEqual([])
+    expect(forwarded).toEqual([])
+    expect(outbound).toHaveLength(1)
+    expect(JSON.parse(outbound[0]!)).toEqual(expect.objectContaining({
+      type: 'control_response',
+      response: expect.objectContaining({
+        request_id: 'late-permission',
+        response: expect.objectContaining({ behavior: 'deny' }),
+      }),
+    }))
+  })
+
   // CLI 的 WebSocketTransport 每次重连成功都会把整个发送缓冲区重放一遍，并假定
   // 「The server deduplicates by UUID」。以前 server 没实现这个契约：笔记本睡醒后
   // CLI 重连，一整轮早已结束的对话会被重新推上来，前端当成实时输出再渲染一遍
diff --git a/src/server/__tests__/task-notification-persistence.test.ts b/src/server/__tests__/task-notification-persistence.test.ts
index b7bb32b2..5655e5a7 100644
--- a/src/server/__tests__/task-notification-persistence.test.ts
+++ b/src/server/__tests__/task-notification-persistence.test.ts
@@ -68,6 +68,114 @@ describe('background task notification persistence', () => {
     expect(await fs.readFile(transcriptPath, 'utf8')).toContain('"type":"cc-haha-task-notification"')
   })
 
+  it('aborts and drains an in-flight task append before clearing the transcript', async () => {
+    const sessionId = crypto.randomUUID()
+    const projectDir = path.join(configDir, 'projects', '-tmp-clear-task-append')
+    const transcriptPath = path.join(projectDir, `${sessionId}.jsonl`)
+    await fs.mkdir(projectDir, { recursive: true })
+    await fs.writeFile(transcriptPath, `${JSON.stringify({
+      type: 'session-meta',
+      isMeta: true,
+      workDir: '/tmp/clear-task-append',
+      timestamp: '2026-07-18T00:00:00.000Z',
+    })}\n`, 'utf8')
+
+    const realWriteFile = fs.writeFile
+    let markAppendStarted!: () => void
+    const appendStarted = new Promise<void>((resolve) => {
+      markAppendStarted = resolve
+    })
+    spyOn(fs, 'writeFile').mockImplementation((filePath: any, data: any, options: any) => {
+      if (options && typeof options === 'object' && options.flag === 'a') {
+        markAppendStarted()
+        return new Promise<void>((resolve) => {
+          if (options.signal?.aborted) resolve()
+          else options.signal?.addEventListener('abort', () => resolve(), { once: true })
+        })
+      }
+      return realWriteFile(filePath, data, options)
+    })
+
+    const service = new SessionService()
+    const append = service.appendSessionTaskNotification(sessionId, {
+      taskId: 'agent-task-clear-race',
+      toolUseId: 'agent-tool-clear-race',
+      status: 'stopped',
+      summary: 'This old generation must not survive clear',
+      timestamp: '2026-07-18T00:01:00.000Z',
+    })
+    await appendStarted
+
+    await service.clearSessionTranscript(sessionId, '/tmp/clear-task-append')
+    await append
+
+    const cleared = await fs.readFile(transcriptPath, 'utf8')
+    expect(cleared).not.toContain('cc-haha-task-notification')
+    expect(cleared).not.toContain('agent-task-clear-race')
+    expect(cleared).toContain('"type":"session-meta"')
+  })
+
+  it('restores an aborted terminal notification when transcript clear fails', async () => {
+    const sessionId = crypto.randomUUID()
+    const projectDir = path.join(configDir, 'projects', '-tmp-failed-clear-task-append')
+    const transcriptPath = path.join(projectDir, `${sessionId}.jsonl`)
+    await fs.mkdir(projectDir, { recursive: true })
+    await fs.writeFile(transcriptPath, `${JSON.stringify({
+      type: 'session-meta',
+      isMeta: true,
+      workDir: '/tmp/failed-clear-task-append',
+      timestamp: '2026-07-18T00:00:00.000Z',
+    })}\n`, 'utf8')
+
+    const realWriteFile = fs.writeFile
+    let appendAttempts = 0
+    let markAppendStarted!: () => void
+    const appendStarted = new Promise<void>((resolve) => {
+      markAppendStarted = resolve
+    })
+    spyOn(fs, 'writeFile').mockImplementation((filePath: any, data: any, options: any) => {
+      if (options && typeof options === 'object' && options.flag === 'a') {
+        appendAttempts++
+        if (appendAttempts > 1) return realWriteFile(filePath, data, options)
+        markAppendStarted()
+        return new Promise<void>((_resolve, reject) => {
+          const rejectAbort = () => {
+            const error = new Error('The operation was aborted')
+            error.name = 'AbortError'
+            reject(error)
+          }
+          if (options.signal?.aborted) rejectAbort()
+          else options.signal?.addEventListener('abort', rejectAbort, { once: true })
+        })
+      }
+      return Promise.reject(new Error('transcript replacement failed'))
+    })
+
+    const service = new SessionService()
+    const append = service.appendSessionTaskNotification(sessionId, {
+      taskId: 'agent-task-failed-clear-race',
+      toolUseId: 'agent-tool-failed-clear-race',
+      status: 'completed',
+      summary: 'Terminal state must survive a failed clear',
+      timestamp: '2026-07-18T00:01:00.000Z',
+    })
+    void append.catch(() => {})
+    await appendStarted
+
+    await expect(
+      service.clearSessionTranscript(sessionId, '/tmp/failed-clear-task-append'),
+    ).rejects.toThrow('transcript replacement failed')
+    await expect(append).rejects.toThrow('The operation was aborted')
+
+    expect(await service.getSessionTaskNotifications(sessionId)).toContainEqual({
+      taskId: 'agent-task-failed-clear-race',
+      toolUseId: 'agent-tool-failed-clear-race',
+      status: 'completed',
+      summary: 'Terminal state must survive a failed clear',
+      timestamp: '2026-07-18T00:01:00.000Z',
+    })
+  })
+
   it('keeps restoring legacy task-notification transcript turns', async () => {
     const sessionId = crypto.randomUUID()
     const projectDir = path.join(configDir, 'projects', '-tmp-legacy-notification')
diff --git a/src/server/__tests__/websocket-handler.test.ts b/src/server/__tests__/websocket-handler.test.ts
index 20cbd9b0..b3f3001f 100644
--- a/src/server/__tests__/websocket-handler.test.ts
+++ b/src/server/__tests__/websocket-handler.test.ts
@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, mock, spyOn } from 'bun:test'
 import type { ServerWebSocket } from 'bun'
 import {
+  __enqueueRuntimeTransitionForTests,
   __markPrewarmPendingForTests,
   __markActiveTurnForTests,
   __refreshDisconnectedTurnCleanupWatcherForTests,
@@ -10,6 +11,7 @@ import {
   closeSessionConnection,
   getActiveSessionIds,
   handleWebSocket,
+  __registerPendingSessionStartupForTests,
   translateCliMessage,
   type WebSocketData,
 } from '../ws/handler.js'
@@ -20,6 +22,7 @@ import {
 import { conversationService } from '../services/conversationService.js'
 import { computerUseApprovalService } from '../services/computerUseApprovalService.js'
 import { sessionService } from '../services/sessionService.js'
+import * as teleportApi from '../../utils/teleport/api.js'
 
 function makeClientSocket(sessionId: string, clientKind: 'full' | 'pet' = 'full') {
   const sent: string[] = []
@@ -41,6 +44,25 @@ function makeClientSocket(sessionId: string, clientKind: 'full' | 'pet' = 'full'
   } as unknown as ServerWebSocket<WebSocketData> & { sent: string[] }
 }
 
+function makeSdkSocket(sessionId: string, sdkToken: string) {
+  return {
+    data: {
+      sessionId,
+      connectedAt: Date.now(),
+      channel: 'sdk',
+      sdkToken,
+      serverPort: 0,
+      serverHost: '127.0.0.1',
+    },
+    send: mock(() => {}),
+    close: mock(() => {}),
+  } as unknown as ServerWebSocket<WebSocketData>
+}
+
+async function flushMicrotasks(count = 12): Promise<void> {
+  for (let index = 0; index < count; index++) await Promise.resolve()
+}
+
 describe('translateCliMessage usage mapping', () => {
   afterEach(() => {
     __resetWebSocketHandlerStateForTests()
@@ -123,6 +145,41 @@ describe('WebSocket handler session isolation', () => {
     expect(cancelComputerUse).not.toHaveBeenCalled()
   })
 
+  it('rejects an old SDK socket after the same session starts with a new token', () => {
+    const sessionId = `sdk-token-replacement-${crypto.randomUUID()}`
+    let currentToken = 'old-sdk-token'
+    const oldSocket = makeSdkSocket(sessionId, currentToken)
+    const newSocket = makeSdkSocket(sessionId, 'new-sdk-token')
+    spyOn(conversationService, 'authorizeSdkConnection').mockImplementation(
+      (_sessionId, token) => token === currentToken,
+    )
+    spyOn(conversationService, 'attachSdkConnection').mockReturnValue(true)
+    const handleSdkPayload = spyOn(conversationService, 'handleSdkPayload').mockImplementation(
+      () => {},
+    )
+
+    handleWebSocket.open(oldSocket)
+    currentToken = 'new-sdk-token'
+    handleWebSocket.message(oldSocket, JSON.stringify({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-from-old-runtime',
+      task_type: 'local_agent',
+    }))
+
+    expect(oldSocket.close).toHaveBeenCalledWith(1008, 'Stale SDK token')
+    expect(handleSdkPayload).not.toHaveBeenCalled()
+
+    handleWebSocket.open(newSocket)
+    const currentPayload = JSON.stringify({ type: 'system', subtype: 'init' })
+    handleWebSocket.message(newSocket, currentPayload)
+
+    expect(newSocket.close).not.toHaveBeenCalled()
+    expect(handleSdkPayload).toHaveBeenCalledTimes(1)
+    expect(handleSdkPayload.mock.calls[0]?.[0]).toBe(sessionId)
+    expect(handleSdkPayload.mock.calls[0]?.[1]).toBe(currentPayload)
+  })
+
   it('closes and removes an active client socket when a session is deleted', () => {
     const sessionId = `delete-${crypto.randomUUID()}`
     const ws = makeClientSocket(sessionId)
@@ -297,6 +354,52 @@ describe('WebSocket handler session isolation', () => {
     expect(computerUseApprovalService.getPendingRequests(sessionId)).toEqual([])
   })
 
+  it('cancels a stopped turn Computer Use request before another renderer reconnects', async () => {
+    const sessionId = `computer-use-stop-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    const request = {
+      requestId: 'cu-request-stopped',
+      reason: 'Inspect another app',
+      apps: [],
+      requestedFlags: {},
+      screenshotFiltering: 'native' as const,
+    }
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+
+    handleWebSocket.open(first)
+    __markActiveTurnForTests(sessionId)
+    const approval = computerUseApprovalService.requestApproval(sessionId, request)
+    const approvalResult = approval.catch((error: unknown) => error)
+
+    handleWebSocket.message(first, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.open(second)
+
+    expect(computerUseApprovalService.getPendingRequests(sessionId)).toEqual([])
+    expect(second.sent.map((payload) => JSON.parse(payload))).not.toContainEqual(
+      expect.objectContaining({
+        type: 'computer_use_permission_request',
+        requestId: request.requestId,
+      }),
+    )
+    expect(second.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'permission_requests_snapshot',
+      toolRequestIds: [],
+      computerUseRequestIds: [],
+      turnActive: false,
+    })
+    expect(first.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'permission_resolved',
+      requestId: request.requestId,
+      permissionType: 'computer_use',
+      allowed: false,
+    })
+    expect(await approvalResult).toEqual(expect.objectContaining({
+      message: 'Desktop session disconnected during Computer Use approval',
+    }))
+  })
+
   it('marks a registered pre-send user turn active in the reconnect snapshot', () => {
     const sessionId = `pending-turn-reconnect-${crypto.randomUUID()}`
     const ws = makeClientSocket(sessionId)
@@ -405,6 +508,15 @@ describe('WebSocket handler session isolation', () => {
       usage: { input_tokens: 12, output_tokens: 3 },
       result: 'Request interrupted by user',
     })
+    outputCallback?.({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: 'late after interrupt result' }] },
+    })
+    outputCallback?.({
+      type: 'system',
+      subtype: 'status',
+      status: 'compacting',
+    })
     handleWebSocket.message(ws, JSON.stringify({ type: 'sync_state' }))
 
     expect(ws.sent.map((payload) => JSON.parse(payload))).toEqual([
@@ -503,6 +615,42 @@ describe('WebSocket handler session isolation', () => {
     ])
   })
 
+  it('reports a committed replacement active before its replay reaches the server', async () => {
+    const sessionId = `replacement-turn-reconnect-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation(() => {})
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      async (_sid, _content, _attachments, options) => {
+        options?.onCommitted?.()
+        return true
+      },
+    )
+
+    handleWebSocket.open(first)
+    __markActiveTurnForTests(sessionId)
+    handleWebSocket.message(first, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.message(first, JSON.stringify({
+      type: 'user_message',
+      content: 'Replacement committed before replay',
+    }))
+    await flushMicrotasks(30)
+    handleWebSocket.open(second)
+
+    expect(second.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'permission_requests_snapshot',
+      toolRequestIds: [],
+      computerUseRequestIds: [],
+      turnActive: true,
+    })
+  })
+
   it('does not let a stopped turn fallback kill a replacement turn', () => {
     const sessionId = `stopped-turn-replaced-${crypto.randomUUID()}`
     const ws = makeClientSocket(sessionId)
@@ -524,10 +672,2617 @@ describe('WebSocket handler session isolation', () => {
     expect(stopSession).not.toHaveBeenCalled()
   })
 
+  it('stops every active Agent task when generation is stopped', async () => {
+    const sessionId = `stop-agent-fanout-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const sendInterrupt = spyOn(conversationService, 'sendInterrupt').mockImplementation(() => true)
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+    const requestControl = spyOn(conversationService, 'requestControl').mockImplementation(
+      async (_sessionId, request) => {
+        if (request.task_id === 'agent-task-2') {
+          throw new Error('Agent stop failed')
+        }
+        return {}
+      },
+    )
+    const archiveRemoteSession = spyOn(teleportApi, 'archiveRemoteSession').mockResolvedValue()
+
+    handleWebSocket.open(ws)
+    __markActiveTurnForTests(sessionId)
+    for (const [taskId, taskType] of [
+      ['agent-task-1', 'local_agent'],
+      ['agent-task-2', 'local_agent'],
+      ['agent-task-3', 'remote_agent'],
+      ['agent-task-4', 'local_agent'],
+    ] as const) {
+      outputCallbacks[0]?.({
+        type: 'system',
+        subtype: 'task_started',
+        task_id: taskId,
+        tool_use_id: `tool-${taskId}`,
+        description: taskId,
+        task_type: taskType,
+        ...(taskType === 'remote_agent'
+          ? { remote_session_id: 'remote-session-agent-task-3' }
+          : {}),
+      })
+    }
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'bash-collateral-task',
+      tool_use_id: 'bash-collateral-tool',
+      description: 'Shell work sharing the Agent runtime',
+      task_type: 'local_bash',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    expect(sendInterrupt).toHaveBeenCalledWith(sessionId)
+    expect(requestControl).toHaveBeenCalledTimes(4)
+    for (const taskId of [
+      'agent-task-1',
+      'agent-task-2',
+      'agent-task-3',
+      'agent-task-4',
+    ]) {
+      expect(requestControl).toHaveBeenCalledWith(sessionId, {
+        subtype: 'stop_task',
+        task_id: taskId,
+      }, 3_000)
+    }
+    expect(archiveRemoteSession).toHaveBeenCalledWith(
+      'remote-session-agent-task-3',
+      { timeoutMs: 1_500 },
+    )
+    expect(stopSession).toHaveBeenCalledWith(sessionId)
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'agent-task-2',
+      status: 'stopped',
+    }))
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'bash-collateral-task',
+      toolUseId: 'bash-collateral-tool',
+      status: 'stopped',
+    }))
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'agent-task-2',
+        status: 'stopped',
+      }),
+    })
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'bash-collateral-task',
+        status: 'stopped',
+      }),
+    })
+
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_notification',
+      task_id: 'bash-collateral-task',
+      tool_use_id: 'bash-collateral-tool',
+      task_type: 'local_bash',
+      status: 'stopped',
+    })
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'late-bash-after-force-kill',
+      tool_use_id: 'late-bash-after-force-kill-tool',
+      description: 'Late Bash event drained after runtime exit',
+      task_type: 'local_bash',
+    })
+    await flushMicrotasks()
+
+    expect(append.mock.calls.filter(([, notification]) =>
+      notification.taskId === 'bash-collateral-task')).toHaveLength(1)
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'late-bash-after-force-kill',
+      status: 'stopped',
+    }))
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'late-bash-after-force-kill',
+        status: 'stopped',
+      }),
+    })
+  })
+
+  it('does not bulk-stop non-Agent background tasks', async () => {
+    const sessionId = `stop-agent-filter-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+
+    handleWebSocket.open(ws)
+    for (const [taskId, taskType] of [
+      ['agent-task-1', 'local_agent'],
+      ['bash-task-1', 'local_bash'],
+      ['dream-task-1', 'dream'],
+    ] as const) {
+      outputCallbacks[0]?.({
+        type: 'system',
+        subtype: 'task_started',
+        task_id: taskId,
+        tool_use_id: `tool-${taskId}`,
+        description: taskId,
+        task_type: taskType,
+      })
+    }
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await Promise.resolve()
+
+    expect(requestControl.mock.calls).toEqual([
+      [sessionId, { subtype: 'stop_task', task_id: 'agent-task-1' }, 3_000],
+    ])
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_progress',
+      task_id: 'agent-task-1',
+      task_type: 'local_agent',
+      description: 'Late stopped Agent progress',
+    })
+    outputCallbacks[0]?.({
+      type: 'control_request',
+      request_id: 'agent-permission-after-agent-stop',
+      request: {
+        subtype: 'can_use_tool',
+        tool_name: 'Bash',
+        agent_id: 'agent-task-1',
+        input: { command: 'echo stale-agent' },
+      },
+    })
+    outputCallbacks[0]?.({
+      type: 'control_request',
+      request_id: 'non-agent-permission-after-agent-stop',
+      request: {
+        subtype: 'can_use_tool',
+        tool_name: 'Bash',
+        input: { command: 'echo still-running' },
+      },
+    })
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'late-bash-after-stop',
+      task_type: 'local_bash',
+      description: 'Independent Bash remains visible',
+    })
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'permission_request',
+      requestId: 'non-agent-permission-after-agent-stop',
+      toolName: 'Bash',
+      toolUseId: undefined,
+      input: { command: 'echo still-running' },
+      description: undefined,
+    })
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual(
+      expect.objectContaining({
+        type: 'permission_request',
+        requestId: 'agent-permission-after-agent-stop',
+      }),
+    )
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual(
+      expect.objectContaining({
+        type: 'status',
+        state: 'tool_executing',
+        verb: 'Late stopped Agent progress',
+      }),
+    )
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_started',
+      message: 'Independent Bash remains visible',
+      data: expect.objectContaining({
+        task_id: 'late-bash-after-stop',
+        task_type: 'local_bash',
+      }),
+    })
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual({
+      type: 'status',
+      state: 'tool_executing',
+      verb: 'Independent Bash remains visible',
+    })
+  })
+
+  it('stops active Agent tasks after the main turn has already settled', async () => {
+    const sessionId = `stop-agent-after-turn-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const sendInterrupt = spyOn(conversationService, 'sendInterrupt').mockImplementation(() => true)
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+
+    handleWebSocket.open(ws)
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-after-turn',
+      tool_use_id: 'agent-tool-after-turn',
+      description: 'Continue after the main turn',
+      task_type: 'local_agent',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await Promise.resolve()
+
+    expect(sendInterrupt).not.toHaveBeenCalled()
+    expect(requestControl).toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'agent-task-after-turn',
+    }, 3_000)
+  })
+
+  it('does not stop Agent tasks that already emitted a terminal status', async () => {
+    const sessionId = `stop-agent-terminal-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+
+    handleWebSocket.open(ws)
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-completed',
+      tool_use_id: 'agent-tool-completed',
+      description: 'Already complete',
+      task_type: 'local_agent',
+    })
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_notification',
+      task_id: 'agent-task-completed',
+      status: 'completed',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await Promise.resolve()
+
+    expect(requestControl).not.toHaveBeenCalled()
+  })
+
+  it('persists an authoritative stopped bookend when the CLI exited before Stop', async () => {
+    const sessionId = `stop-agent-after-exit-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let cliRunning = true
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    let finishPersistence: (() => void) | null = null
+    spyOn(conversationService, 'hasSession').mockImplementation(() => cliRunning)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const requestControl = spyOn(conversationService, 'requestControl').mockRejectedValue(
+      new Error('CLI session is not running'),
+    )
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockImplementation(
+      () => new Promise<void>((resolve) => {
+        finishPersistence = resolve
+      }),
+    )
+
+    handleWebSocket.open(ws)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-after-exit',
+      tool_use_id: 'agent-tool-after-exit',
+      description: 'Review runtime failures',
+      task_type: 'local_agent',
+    })
+    cliRunning = false
+    outputCallback?.({
+      type: 'result',
+      subtype: 'error',
+      is_error: true,
+      result: 'CLI process exited unexpectedly (code 1): API unavailable',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+    ws.sent.length = 0
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await Promise.resolve()
+
+    expect(requestControl).not.toHaveBeenCalled()
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'agent-task-after-exit',
+      toolUseId: 'agent-tool-after-exit',
+      status: 'stopped',
+    }))
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual(
+      expect.objectContaining({
+        type: 'system_notification',
+        subtype: 'task_notification',
+      }),
+    )
+
+    finishPersistence?.()
+    await Promise.resolve()
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'agent-task-after-exit',
+        tool_use_id: 'agent-tool-after-exit',
+        task_type: 'local_agent',
+        description: 'Review runtime failures',
+        status: 'stopped',
+      }),
+    })
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual(
+      expect.objectContaining({ type: 'background_task_stop_failed' }),
+    )
+  })
+
+  it('bounds persistence retries and keeps a synthetic Agent stop retryable', async () => {
+    const sessionId = `stop-agent-persistence-retry-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let cliRunning = true
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    spyOn(conversationService, 'hasSession').mockImplementation(() => cliRunning)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const append = spyOn(sessionService, 'appendSessionTaskNotification')
+      .mockRejectedValueOnce(new Error('transcript unavailable'))
+      .mockRejectedValueOnce(new Error('transcript unavailable'))
+      .mockRejectedValueOnce(new Error('transcript unavailable'))
+      .mockResolvedValue()
+    spyOn(console, 'warn').mockImplementation(() => {})
+
+    handleWebSocket.open(ws)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-persistence-retry',
+      tool_use_id: 'agent-tool-persistence-retry',
+      description: 'Retry durable stop',
+      task_type: 'local_agent',
+    })
+    cliRunning = false
+    ws.sent.length = 0
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    expect(append).toHaveBeenCalledTimes(3)
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual(
+      expect.objectContaining({
+        type: 'system_notification',
+        subtype: 'task_notification',
+      }),
+    )
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-persistence-retry',
+      message: 'Agent stopped, but its terminal state could not be saved',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    expect(append).toHaveBeenCalledTimes(4)
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'agent-task-persistence-retry',
+        status: 'stopped',
+      }),
+    })
+  })
+
+  it('times out a hung stopped bookend without pinning Agent finalization', async () => {
+    const sessionId = `stop-agent-persistence-timeout-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let cliRunning = true
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(() => 789 as any)
+    spyOn(conversationService, 'hasSession').mockImplementation(() => cliRunning)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockImplementation(
+      () => new Promise<void>(() => {}),
+    )
+    spyOn(console, 'warn').mockImplementation(() => {})
+
+    handleWebSocket.open(ws)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-persistence-timeout',
+      tool_use_id: 'agent-tool-persistence-timeout',
+      description: 'Bound a hung transcript write',
+      task_type: 'local_agent',
+    })
+    cliRunning = false
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+
+    for (let attempt = 0; attempt < 3; attempt++) {
+      await flushMicrotasks(30)
+      expect(append).toHaveBeenCalledTimes(attempt + 1)
+      const persistenceTimeouts = setTimeoutSpy.mock.calls.filter((call) => call[1] === 1_000)
+      expect(persistenceTimeouts).toHaveLength(attempt + 1)
+      const timeout = persistenceTimeouts[attempt]?.[0] as (() => void) | undefined
+      expect(timeout).toBeTypeOf('function')
+      timeout?.()
+    }
+    await flushMicrotasks(30)
+
+    expect(append).toHaveBeenCalledTimes(3)
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-persistence-timeout',
+      message: 'Agent stopped, but its terminal state could not be saved',
+    })
+    expect(setTimeoutSpy.mock.calls.some((call) => call[1] === 250)).toBe(true)
+  })
+
+  it('does not let failed stop finalization pin a disconnected CLI', async () => {
+    const sessionId = `stop-agent-finalization-disconnect-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    let cliRunning = true
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(() => 456 as any)
+    spyOn(conversationService, 'hasSession').mockImplementation(() => cliRunning)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(sessionService, 'appendSessionTaskNotification').mockRejectedValue(
+      new Error('transcript unavailable'),
+    )
+    spyOn(console, 'warn').mockImplementation(() => {})
+    __setDisconnectGraceMsForTests(1_234)
+
+    handleWebSocket.open(first)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-finalization-disconnect',
+      tool_use_id: 'agent-tool-finalization-disconnect',
+      description: 'Stop before renderer disconnects',
+      task_type: 'local_agent',
+    })
+    cliRunning = false
+    handleWebSocket.message(first, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    expect(first.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-finalization-disconnect',
+      message: 'Agent stopped, but its terminal state could not be saved',
+    })
+
+    setTimeoutSpy.mockClear()
+    handleWebSocket.close(first, 1006, 'renderer closed after stop failure')
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(1)
+    expect(setTimeoutSpy.mock.calls[0]?.[1]).toBe(1_234)
+
+    second.sent.length = 0
+    handleWebSocket.open(second)
+    expect(second.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-finalization-disconnect',
+      message: 'Agent stopped, but its terminal state could not be saved',
+    })
+  })
+
+  it('keeps a failed remote archive retryable after disconnected CLI cleanup', async () => {
+    const sessionId = `stop-agent-archive-reconnect-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    let cliRunning = true
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    let nextTimerId = 1
+    const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(
+      () => nextTimerId++ as any,
+    )
+    spyOn(conversationService, 'hasSession').mockImplementation(() => cliRunning)
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {
+      cliRunning = false
+    })
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(conversationService, 'requestControl').mockResolvedValue({})
+    const archiveRemoteSession = spyOn(teleportApi, 'archiveRemoteSession')
+      .mockRejectedValueOnce(new Error('remote archive unavailable'))
+      .mockResolvedValue()
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+    spyOn(console, 'warn').mockImplementation(() => {})
+    __setDisconnectGraceMsForTests(1_234)
+
+    handleWebSocket.open(first)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'remote-agent-archive-reconnect',
+      tool_use_id: 'remote-agent-archive-reconnect-tool',
+      description: 'Retry remote archive after reconnect',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-archive-reconnect',
+    })
+    handleWebSocket.message(first, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    expect(first.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'background_task_stop_failed',
+      taskId: 'remote-agent-archive-reconnect',
+      message: 'remote archive unavailable',
+    })
+
+    handleWebSocket.close(first, 1006, 'renderer closed after archive failure')
+    const expireDisconnectGrace = setTimeoutSpy.mock.calls.find((call) => call[1] === 1_234)?.[0] as
+      | (() => void)
+      | undefined
+    expect(expireDisconnectGrace).toBeTypeOf('function')
+    expireDisconnectGrace?.()
+    expect(stopSession).toHaveBeenCalledWith(sessionId)
+
+    handleWebSocket.open(second)
+    expect(second.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'background_task_stop_failed',
+      taskId: 'remote-agent-archive-reconnect',
+      message: 'remote archive unavailable',
+    })
+
+    second.sent.length = 0
+    handleWebSocket.message(second, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    expect(archiveRemoteSession).toHaveBeenNthCalledWith(
+      2,
+      'remote-session-archive-reconnect',
+      { timeoutMs: 1_500 },
+    )
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'remote-agent-archive-reconnect',
+      status: 'stopped',
+    }))
+    expect(second.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'remote-agent-archive-reconnect',
+        status: 'stopped',
+      }),
+    })
+  })
+
+  it('closes stopped Agent activity when the CLI exit result arrives after Stop', async () => {
+    const sessionId = `stop-agent-runtime-exit-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let cliRunning = true
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    spyOn(conversationService, 'hasSession').mockImplementation(() => cliRunning)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(conversationService, 'requestControl').mockImplementation(
+      () => new Promise<Record<string, unknown>>(() => {}),
+    )
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+    const archiveRemoteSession = spyOn(teleportApi, 'archiveRemoteSession').mockResolvedValue()
+
+    handleWebSocket.open(ws)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-runtime-exit',
+      tool_use_id: 'agent-tool-runtime-exit',
+      description: 'Review provider failures',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-runtime-exit',
+    })
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    cliRunning = false
+    outputCallback?.({
+      type: 'result',
+      subtype: 'error',
+      is_error: true,
+      result: 'CLI process exited unexpectedly (code 1): provider failed',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+    await flushMicrotasks()
+
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'agent-task-runtime-exit',
+      toolUseId: 'agent-tool-runtime-exit',
+      status: 'stopped',
+    }))
+    expect(archiveRemoteSession).toHaveBeenCalledWith(
+      'remote-session-runtime-exit',
+      { timeoutMs: 1_500 },
+    )
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'agent-task-runtime-exit',
+        tool_use_id: 'agent-tool-runtime-exit',
+        status: 'stopped',
+      }),
+    })
+  })
+
+  it('automatically retries a confirmed local stop until remote archive succeeds', async () => {
+    const sessionId = `stop-agent-archive-failed-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const requestControl = spyOn(conversationService, 'requestControl').mockImplementation(
+      async () => {
+        outputCallback?.({
+          type: 'system',
+          subtype: 'task_notification',
+          task_id: 'remote-agent-archive-failed',
+          tool_use_id: 'remote-agent-archive-failed-tool',
+          task_type: 'remote_agent',
+          status: 'stopped',
+        })
+        return {}
+      },
+    )
+    const archiveRemoteSession = spyOn(teleportApi, 'archiveRemoteSession')
+      .mockRejectedValueOnce(new Error('archive request timed out'))
+      .mockResolvedValue()
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+    spyOn(console, 'warn').mockImplementation(() => {})
+
+    handleWebSocket.open(ws)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'remote-agent-archive-failed',
+      tool_use_id: 'remote-agent-archive-failed-tool',
+      description: 'Remote review with failed archive',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-archive-failed',
+    })
+    ws.sent.length = 0
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    expect(requestControl).toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'remote-agent-archive-failed',
+    }, 3_000)
+    expect(append).not.toHaveBeenCalled()
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'background_task_stop_failed',
+      taskId: 'remote-agent-archive-failed',
+      message: 'archive request timed out',
+    })
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'remote-agent-archive-failed',
+        status: 'stopped',
+      }),
+    })
+    const expireForceKill = setTimeoutSpy.mock.calls[0]?.[0] as (() => void) | undefined
+    expireForceKill?.()
+    expect(stopSession).not.toHaveBeenCalled()
+
+    const retryFinalization = setTimeoutSpy.mock.calls.find((call) => call[1] === 250)?.[0] as
+      | (() => void)
+      | undefined
+    expect(retryFinalization).toBeTypeOf('function')
+    retryFinalization?.()
+    await flushMicrotasks()
+
+    expect(requestControl).toHaveBeenCalledTimes(1)
+    expect(archiveRemoteSession).toHaveBeenCalledTimes(2)
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'remote-agent-archive-failed',
+      status: 'stopped',
+    }))
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'remote-agent-archive-failed',
+        status: 'stopped',
+      }),
+    })
+  })
+
+  it('routes an asynchronous Agent stop failure away from a disconnected socket', async () => {
+    const sessionId = `stop-agent-replacement-client-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    let rejectArchive: ((reason?: unknown) => void) | undefined
+    spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(conversationService, 'requestControl').mockResolvedValue({})
+    spyOn(teleportApi, 'archiveRemoteSession').mockImplementation(
+      () => new Promise<void>((_resolve, reject) => {
+        rejectArchive = reject
+      }),
+    )
+    spyOn(console, 'warn').mockImplementation(() => {})
+
+    handleWebSocket.open(first)
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-replacement-client',
+      tool_use_id: 'agent-tool-replacement-client',
+      description: 'Stop across a renderer reconnect',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-replacement-client',
+    })
+    handleWebSocket.message(first, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    handleWebSocket.close(first, 1006, 'renderer restarting during stop')
+    handleWebSocket.open(second)
+    first.sent.length = 0
+    second.sent.length = 0
+
+    rejectArchive?.(new Error('archive confirmation unavailable'))
+    await flushMicrotasks()
+
+    expect(first.sent).toHaveLength(0)
+    expect(second.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-replacement-client',
+      message: 'archive confirmation unavailable',
+    })
+  })
+
+  it('broadcasts a shared Agent stop failure to every requesting renderer', async () => {
+    const sessionId = `stop-agent-concurrent-clients-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    let rejectArchive: ((reason?: unknown) => void) | undefined
+    spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(conversationService, 'requestControl').mockResolvedValue({})
+    spyOn(teleportApi, 'archiveRemoteSession').mockImplementation(
+      () => new Promise<void>((_resolve, reject) => {
+        rejectArchive = reject
+      }),
+    )
+    spyOn(console, 'warn').mockImplementation(() => {})
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-concurrent-clients',
+      tool_use_id: 'agent-tool-concurrent-clients',
+      description: 'Stop from two renderers',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-concurrent-clients',
+    })
+    first.sent.length = 0
+    second.sent.length = 0
+
+    handleWebSocket.message(first, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.message(second, JSON.stringify({ type: 'stop_generation' }))
+    rejectArchive?.(new Error('shared archive confirmation failed'))
+    await flushMicrotasks()
+
+    const failure = {
+      type: 'background_task_stop_failed',
+      taskId: 'agent-task-concurrent-clients',
+      message: 'shared archive confirmation failed',
+    }
+    expect(first.sent.map((payload) => JSON.parse(payload))).toContainEqual(failure)
+    expect(second.sent.map((payload) => JSON.parse(payload))).toContainEqual(failure)
+  })
+
+  it('clears the transcript without waiting for independent strict remote Agent archival', async () => {
+    const sessionId = `stop-agent-clear-generation-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    let resolveArchive: (() => void) | undefined
+    spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getSessionWorkDir').mockReturnValue('/tmp/agent-clear-generation')
+    spyOn(conversationService, 'getSessionPermissionMode').mockReturnValue('default')
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(conversationService, 'clearOutputCallbacks').mockImplementation(() => {})
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const archiveRemoteSession = spyOn(teleportApi, 'archiveRemoteSession').mockImplementation(
+      () => new Promise<void>((resolve) => {
+        resolveArchive = resolve
+      }),
+    )
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+    const clearTranscript = spyOn(sessionService, 'clearSessionTranscript').mockResolvedValue()
+
+    handleWebSocket.open(ws)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'remote-agent-clear-generation',
+      tool_use_id: 'remote-agent-clear-generation-tool',
+      description: 'Finalize before replacing the CLI generation',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-clear-generation',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'user_message', content: '/clear' }))
+    await flushMicrotasks()
+    expect(stopSession).toHaveBeenCalledWith(sessionId)
+    expect(clearTranscript).toHaveBeenCalledWith(
+      sessionId,
+      '/tmp/agent-clear-generation',
+      'default',
+    )
+    expect(archiveRemoteSession).toHaveBeenCalledWith(
+      'remote-session-clear-generation',
+      { timeoutMs: 1_500 },
+    )
+
+    resolveArchive?.()
+    await flushMicrotasks()
+
+    expect(append).not.toHaveBeenCalled()
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual(
+      expect.objectContaining({
+        type: 'system_notification',
+        subtype: 'task_notification',
+      }),
+    )
+  })
+
+  it('does not forward an old terminal event after transcript clear commits', async () => {
+    const sessionId = `clear-terminal-forward-race-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    let resolveAppend!: () => void
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getSessionWorkDir').mockReturnValue('/tmp/clear-terminal-forward-race')
+    spyOn(conversationService, 'getSessionPermissionMode').mockReturnValue('default')
+    spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(conversationService, 'clearOutputCallbacks').mockImplementation(() => {})
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(sessionService, 'clearSessionTranscript').mockResolvedValue()
+    spyOn(sessionService, 'appendSessionTaskNotification').mockImplementation(
+      () => new Promise<void>((resolve) => {
+        resolveAppend = resolve
+      }),
+    )
+
+    handleWebSocket.open(ws)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-terminal-before-clear',
+      tool_use_id: 'agent-terminal-before-clear-tool',
+      task_type: 'local_agent',
+      description: 'Terminal persistence overlaps clear',
+    })
+    ws.sent.length = 0
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_notification',
+      task_id: 'agent-terminal-before-clear',
+      tool_use_id: 'agent-terminal-before-clear-tool',
+      task_type: 'local_agent',
+      status: 'completed',
+      summary: 'Old generation completed',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: '/clear',
+    }))
+    await flushMicrotasks(30)
+    resolveAppend()
+    await flushMicrotasks(30)
+
+    const sent = ws.sent.map((payload) => JSON.parse(payload))
+    expect(sent).toContainEqual({
+      type: 'system_notification',
+      subtype: 'session_cleared',
+      message: 'Conversation cleared',
+    })
+    expect(sent).not.toContainEqual(expect.objectContaining({
+      type: 'system_notification',
+      subtype: 'task_notification',
+    }))
+  })
+
+  it('retries remote Agent archival independently while clearing the session', async () => {
+    const sessionId = `stop-agent-clear-retry-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    spyOn(globalThis, 'setTimeout').mockImplementation((callback) => {
+      queueMicrotask(() => (callback as () => void)())
+      return 1 as any
+    })
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getSessionWorkDir').mockReturnValue('/tmp/agent-clear-retry')
+    spyOn(conversationService, 'getSessionPermissionMode').mockReturnValue('default')
+    spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(conversationService, 'clearOutputCallbacks').mockImplementation(() => {})
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const archiveRemoteSession = spyOn(teleportApi, 'archiveRemoteSession')
+      .mockRejectedValueOnce(new Error('temporary archive failure'))
+      .mockResolvedValue()
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+    const clearTranscript = spyOn(sessionService, 'clearSessionTranscript').mockResolvedValue()
+
+    handleWebSocket.open(ws)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'remote-agent-clear-retry',
+      tool_use_id: 'remote-agent-clear-retry-tool',
+      description: 'Retry archival after clear tears down runtime state',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-clear-retry',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'user_message', content: '/clear' }))
+    await flushMicrotasks(30)
+
+    expect(archiveRemoteSession).toHaveBeenCalledTimes(2)
+    expect(archiveRemoteSession).toHaveBeenNthCalledWith(
+      2,
+      'remote-session-clear-retry',
+      { timeoutMs: 1_500 },
+    )
+    expect(clearTranscript).toHaveBeenCalledWith(
+      sessionId,
+      '/tmp/agent-clear-retry',
+      'default',
+    )
+    expect(append).not.toHaveBeenCalled()
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual(
+      expect.objectContaining({ code: 'AGENT_STOP_UNCONFIRMED' }),
+    )
+  })
+
+  it('reports a late clear archival failure without emitting a turn-terminal error', async () => {
+    const sessionId = `stop-agent-clear-warning-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    const archiveRejectors: Array<(reason?: unknown) => void> = []
+    spyOn(globalThis, 'setTimeout').mockImplementation((callback) => {
+      queueMicrotask(() => (callback as () => void)())
+      return 1 as any
+    })
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getSessionWorkDir').mockReturnValue('/tmp/agent-clear-warning')
+    spyOn(conversationService, 'getSessionPermissionMode').mockReturnValue('default')
+    spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(conversationService, 'clearOutputCallbacks').mockImplementation(() => {})
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(sessionService, 'clearSessionTranscript').mockResolvedValue()
+    const sendMessage = spyOn(conversationService, 'sendMessage').mockResolvedValue(true)
+    spyOn(teleportApi, 'archiveRemoteSession').mockImplementation(
+      () => new Promise<void>((_resolve, reject) => {
+        archiveRejectors.push(reject)
+      }),
+    )
+    spyOn(console, 'warn').mockImplementation(() => {})
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'remote-agent-clear-warning',
+      tool_use_id: 'remote-agent-clear-warning-tool',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-clear-warning',
+      description: 'Archive after transcript clear',
+    })
+    handleWebSocket.message(first, JSON.stringify({
+      type: 'user_message',
+      content: '/clear',
+    }))
+    await flushMicrotasks(30)
+
+    handleWebSocket.message(second, JSON.stringify({
+      type: 'user_message',
+      content: 'New turn after clear',
+    }))
+    await flushMicrotasks(30)
+    expect(sendMessage).toHaveBeenCalledWith(
+      sessionId,
+      'New turn after clear',
+      undefined,
+      expect.objectContaining({
+        canSend: expect.any(Function),
+        messageUuid: expect.any(String),
+        onCommitted: expect.any(Function),
+      }),
+    )
+
+    for (let attempt = 0; attempt < 3; attempt++) {
+      await flushMicrotasks(10)
+      archiveRejectors[attempt]?.(new Error(`archive failure ${attempt + 1}`))
+    }
+    await flushMicrotasks(40)
+
+    for (const client of [first, second]) {
+      const sent = client.sent.map((payload) => JSON.parse(payload))
+      expect(sent).toContainEqual({
+        type: 'background_task_stop_failed',
+        taskId: 'remote-agent-clear-warning',
+        message: 'Conversation cleared, but one or more background Agents could not be fully stopped.',
+      })
+      expect(sent).not.toContainEqual(expect.objectContaining({
+        type: 'error',
+        code: 'AGENT_STOP_UNCONFIRMED',
+      }))
+    }
+  })
+
+  it('drains a user admission already waiting on CLI startup before clear commits', async () => {
+    const sessionId = `clear-pending-startup-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    let resolveStartup!: () => void
+    let runtimeReady = false
+    const pendingStartup = new Promise<void>((resolve) => {
+      resolveStartup = () => {
+        runtimeReady = true
+        resolve()
+      }
+    })
+    __registerPendingSessionStartupForTests(sessionId, pendingStartup)
+    spyOn(conversationService, 'hasSession').mockImplementation(() => runtimeReady)
+    spyOn(conversationService, 'getSessionWorkDir').mockReturnValue('/tmp/clear-pending-startup')
+    spyOn(conversationService, 'getSessionPermissionMode').mockReturnValue('default')
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(conversationService, 'clearOutputCallbacks').mockImplementation(() => {})
+    spyOn(conversationService, 'onOutput').mockImplementation(() => {})
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    const clearTranscript = spyOn(sessionService, 'clearSessionTranscript').mockResolvedValue()
+    const sendMessage = spyOn(conversationService, 'sendMessage').mockResolvedValue(true)
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    handleWebSocket.message(first, JSON.stringify({
+      type: 'user_message',
+      content: 'This admission is waiting for startup',
+    }))
+    await flushMicrotasks(20)
+
+    handleWebSocket.message(second, JSON.stringify({
+      type: 'user_message',
+      content: '/clear',
+    }))
+    await flushMicrotasks(20)
+    expect(clearTranscript).not.toHaveBeenCalled()
+    expect(sendMessage).not.toHaveBeenCalled()
+
+    resolveStartup()
+    await flushMicrotasks(40)
+
+    expect(stopSession).toHaveBeenCalledWith(sessionId)
+    expect(clearTranscript).toHaveBeenCalledWith(
+      sessionId,
+      '/tmp/clear-pending-startup',
+      undefined,
+    )
+    expect(sendMessage).not.toHaveBeenCalled()
+    for (const client of [first, second]) {
+      expect(client.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+        type: 'system_notification',
+        subtype: 'session_cleared',
+        message: 'Conversation cleared',
+      })
+    }
+  })
+
+  it('does not cancel a new turn that queued behind an already-admitted clear', async () => {
+    const sessionId = `clear-queued-replacement-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    let releaseEarlierTransition!: () => void
+    const earlierTransition = new Promise<void>((resolve) => {
+      releaseEarlierTransition = resolve
+    })
+    void __enqueueRuntimeTransitionForTests(sessionId, earlierTransition)
+    const order: string[] = []
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getSessionWorkDir').mockReturnValue('/tmp/clear-queued-replacement')
+    spyOn(conversationService, 'getSessionPermissionMode').mockReturnValue('default')
+    spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(conversationService, 'clearOutputCallbacks').mockImplementation(() => {})
+    spyOn(conversationService, 'onOutput').mockImplementation(() => {})
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(sessionService, 'clearSessionTranscript').mockImplementation(async () => {
+      order.push('clear')
+    })
+    const sendMessage = spyOn(conversationService, 'sendMessage').mockImplementation(async () => {
+      order.push('send')
+      return true
+    })
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    handleWebSocket.message(first, JSON.stringify({
+      type: 'user_message',
+      content: '/clear',
+    }))
+    handleWebSocket.message(second, JSON.stringify({
+      type: 'user_message',
+      content: 'Run after the queued clear',
+    }))
+    await flushMicrotasks(20)
+    expect(sendMessage).not.toHaveBeenCalled()
+
+    releaseEarlierTransition()
+    await flushMicrotasks(60)
+
+    expect(order).toEqual(['clear', 'send'])
+    expect(sendMessage).toHaveBeenCalledWith(
+      sessionId,
+      'Run after the queued clear',
+      undefined,
+      expect.objectContaining({
+        canSend: expect.any(Function),
+        messageUuid: expect.any(String),
+        onCommitted: expect.any(Function),
+      }),
+    )
+  })
+
+  it('serializes a new turn behind transcript clear without waiting for remote archival', async () => {
+    const sessionId = `stop-agent-clear-barrier-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    let resolveClear!: () => void
+    let resolveArchive!: () => void
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getSessionWorkDir').mockReturnValue('/tmp/agent-clear-barrier')
+    spyOn(conversationService, 'getSessionPermissionMode').mockReturnValue('default')
+    spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(conversationService, 'clearOutputCallbacks').mockImplementation(() => {})
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const getCustomTitle = spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    const sendMessage = spyOn(conversationService, 'sendMessage').mockResolvedValue(true)
+    spyOn(sessionService, 'clearSessionTranscript').mockImplementation(
+      () => new Promise<void>((resolve) => {
+        resolveClear = resolve
+      }),
+    )
+    spyOn(teleportApi, 'archiveRemoteSession').mockImplementation(
+      () => new Promise<void>((resolve) => {
+        resolveArchive = resolve
+      }),
+    )
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'remote-agent-clear-barrier',
+      tool_use_id: 'remote-agent-clear-barrier-tool',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-clear-barrier',
+      description: 'Archive independently of the clear barrier',
+    })
+    handleWebSocket.message(first, JSON.stringify({ type: 'user_message', content: '/clear' }))
+    await flushMicrotasks()
+
+    handleWebSocket.message(second, JSON.stringify({
+      type: 'user_message',
+      content: 'Start only after clear commits',
+    }))
+    await flushMicrotasks()
+    expect(getCustomTitle).not.toHaveBeenCalled()
+    expect(sendMessage).not.toHaveBeenCalled()
+
+    resolveClear()
+    await flushMicrotasks(30)
+
+    for (const client of [first, second]) {
+      expect(client.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+        type: 'system_notification',
+        subtype: 'session_cleared',
+        message: 'Conversation cleared',
+      })
+    }
+    expect(getCustomTitle).toHaveBeenCalledWith(sessionId)
+    expect(sendMessage).toHaveBeenCalledWith(
+      sessionId,
+      'Start only after clear commits',
+      undefined,
+      expect.objectContaining({
+        canSend: expect.any(Function),
+        messageUuid: expect.any(String),
+        onCommitted: expect.any(Function),
+      }),
+    )
+    resolveArchive()
+    await flushMicrotasks()
+  })
+
+  it('persists stopped Agent bookends when transcript clear fails', async () => {
+    const sessionId = `stop-agent-clear-failed-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getSessionWorkDir').mockReturnValue('/tmp/agent-clear-failed')
+    spyOn(conversationService, 'getSessionPermissionMode').mockReturnValue('default')
+    spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(conversationService, 'clearOutputCallbacks').mockImplementation(() => {})
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(sessionService, 'clearSessionTranscript').mockRejectedValue(
+      new Error('transcript replacement failed'),
+    )
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'local-agent-clear-failed',
+      tool_use_id: 'local-agent-clear-failed-tool',
+      task_type: 'local_agent',
+      description: 'Retain a terminal state after clear fails',
+    })
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'bash-clear-failed',
+      tool_use_id: 'bash-clear-failed-tool',
+      task_type: 'local_bash',
+      description: 'Shell work in the runtime whose clear fails',
+    })
+    handleWebSocket.message(first, JSON.stringify({ type: 'user_message', content: '/clear' }))
+    await flushMicrotasks(30)
+
+    for (const client of [first, second]) {
+      expect(client.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+        type: 'error',
+        message: 'transcript replacement failed',
+        code: 'SESSION_CLEAR_FAILED',
+      })
+      expect(client.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+        type: 'status',
+        state: 'idle',
+      })
+    }
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'local-agent-clear-failed',
+      status: 'stopped',
+    }))
+    expect(first.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'local-agent-clear-failed',
+        status: 'stopped',
+      }),
+    })
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'bash-clear-failed',
+      toolUseId: 'bash-clear-failed-tool',
+      status: 'stopped',
+    }))
+    expect(first.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'bash-clear-failed',
+        status: 'stopped',
+      }),
+    })
+  })
+
+  it('keeps an archived remote Agent stopped when its local control response is lost', async () => {
+    const sessionId = `stop-agent-archive-control-race-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    let rejectControl: ((reason?: unknown) => void) | undefined
+    spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const requestControl = spyOn(conversationService, 'requestControl').mockImplementation(
+      () => new Promise<Record<string, unknown>>((_resolve, reject) => {
+        rejectControl = reject
+      }),
+    )
+    const archiveRemoteSession = spyOn(teleportApi, 'archiveRemoteSession').mockResolvedValue()
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    const taskStarted = {
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'remote-agent-control-race',
+      tool_use_id: 'remote-agent-control-race-tool',
+      description: 'Remote review with a lost control response',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-control-race',
+    }
+    for (const callback of outputCallbacks) callback(taskStarted)
+    first.sent.length = 0
+    second.sent.length = 0
+
+    handleWebSocket.message(second, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    const cliCompletedAfterArchive = {
+      type: 'system',
+      subtype: 'task_notification',
+      task_id: 'remote-agent-control-race',
+      tool_use_id: 'remote-agent-control-race-tool',
+      task_type: 'remote_agent',
+      status: 'completed',
+      summary: 'Remote task completed successfully',
+    }
+    for (const callback of outputCallbacks) callback(cliCompletedAfterArchive)
+    await flushMicrotasks()
+    rejectControl?.(new Error('Control response was lost'))
+    await flushMicrotasks()
+
+    // Every callback observes the same late CLI event. Repeat it after the
+    // synthetic bookend to prove the session tombstone suppresses all observers.
+    for (const callback of outputCallbacks) callback(cliCompletedAfterArchive)
+    const lateProgressAfterStop = {
+      type: 'system',
+      subtype: 'task_progress',
+      task_id: 'remote-agent-control-race',
+      tool_use_id: 'remote-agent-control-race-tool',
+      task_type: 'remote_agent',
+      description: 'Remote review with a lost control response',
+      summary: 'A stale poll still reported progress',
+    }
+    for (const callback of outputCallbacks) callback(lateProgressAfterStop)
+    await flushMicrotasks()
+
+    expect(requestControl.mock.calls).toEqual([
+      [sessionId, { subtype: 'stop_task', task_id: 'remote-agent-control-race' }, 3_000],
+    ])
+    expect(archiveRemoteSession).toHaveBeenCalledTimes(1)
+    expect(append).toHaveBeenCalledTimes(1)
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'remote-agent-control-race',
+      status: 'stopped',
+    }))
+    for (const ws of [first, second]) {
+      const terminalStatuses = ws.sent
+        .map((payload) => JSON.parse(payload))
+        .filter((payload) =>
+          payload.type === 'system_notification' &&
+          payload.subtype === 'task_notification' &&
+          payload.data?.task_id === 'remote-agent-control-race',
+        )
+        .map((payload) => payload.data.status)
+      expect(terminalStatuses).toEqual(['stopped'])
+      expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual({
+        type: 'system_notification',
+        subtype: 'task_progress',
+        data: expect.objectContaining({ task_id: 'remote-agent-control-race' }),
+      })
+    }
+  })
+
+  it('stops a late Agent exactly once after the interrupted result closes the foreground turn', async () => {
+    const sessionId = `stop-agent-late-start-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    let cliRunning = true
+    spyOn(conversationService, 'hasSession').mockImplementation(() => cliRunning)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const requestControl = spyOn(conversationService, 'requestControl').mockImplementation(
+      async () => {
+        cliRunning = false
+        throw new Error('CLI session is not running')
+      },
+    )
+    spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+    const archiveRemoteSession = spyOn(teleportApi, 'archiveRemoteSession').mockResolvedValue()
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    handleWebSocket.message(first, JSON.stringify({ type: 'stop_generation' }))
+    for (const callback of outputCallbacks) {
+      callback({
+        type: 'result',
+        subtype: 'error',
+        is_error: true,
+        result: 'Interrupted',
+        usage: { input_tokens: 0, output_tokens: 0 },
+      })
+    }
+    first.sent.length = 0
+    second.sent.length = 0
+
+    const lateAgent = {
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'late-agent-task',
+      tool_use_id: 'late-agent-tool',
+      description: 'Late detached review',
+      task_type: 'remote_agent',
+      remote_session_id: 'remote-session-late-agent',
+    }
+    for (const callback of outputCallbacks) callback(lateAgent)
+    await flushMicrotasks()
+
+    expect(requestControl.mock.calls).toEqual([
+      [sessionId, { subtype: 'stop_task', task_id: 'late-agent-task' }, 3_000],
+    ])
+    expect(archiveRemoteSession).toHaveBeenCalledWith(
+      'remote-session-late-agent',
+      { timeoutMs: 1_500 },
+    )
+    for (const ws of [first, second]) {
+      const sent = ws.sent.map((payload) => JSON.parse(payload))
+      expect(sent).not.toContainEqual({
+        type: 'status',
+        state: 'tool_executing',
+        verb: 'Late detached review',
+      })
+      expect(sent).toContainEqual({
+        type: 'system_notification',
+        subtype: 'task_notification',
+        data: expect.objectContaining({
+          task_id: 'late-agent-task',
+          tool_use_id: 'late-agent-tool',
+          status: 'stopped',
+        }),
+      })
+      expect(sent).not.toContainEqual(
+        expect.objectContaining({ type: 'background_task_stop_failed' }),
+      )
+    }
+
+    const lateBash = {
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'late-bash-task',
+      tool_use_id: 'late-bash-tool',
+      description: 'Late shell task',
+      task_type: 'local_bash',
+    }
+    for (const callback of outputCallbacks) callback(lateBash)
+    await Promise.resolve()
+
+    expect(requestControl).toHaveBeenCalledTimes(1)
+  })
+
+  it('force-stops and closes a late Agent when task-scoped control fails', async () => {
+    const sessionId = `stop-agent-late-failure-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const requestControl = spyOn(conversationService, 'requestControl').mockRejectedValue(
+      new Error('Late Agent stop failed'),
+    )
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    handleWebSocket.message(second, JSON.stringify({ type: 'stop_generation' }))
+    first.sent.length = 0
+    second.sent.length = 0
+
+    const lateAgent = {
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'late-agent-failure-task',
+      tool_use_id: 'late-agent-failure-tool',
+      description: 'Late detached review',
+      task_type: 'local_agent',
+    }
+    for (const callback of outputCallbacks) callback(lateAgent)
+    await flushMicrotasks()
+
+    expect(requestControl.mock.calls).toEqual([
+      [sessionId, { subtype: 'stop_task', task_id: 'late-agent-failure-task' }, 3_000],
+    ])
+    expect(stopSession).toHaveBeenCalledWith(sessionId)
+    for (const ws of [first, second]) {
+      expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+        type: 'system_notification',
+        subtype: 'task_notification',
+        data: expect.objectContaining({
+          task_id: 'late-agent-failure-task',
+          status: 'stopped',
+        }),
+      })
+    }
+  })
+
+  it('keeps the Agent stop latch when a replacement user message is rejected', async () => {
+    const sessionId = `stop-agent-invalid-message-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: '/clear unexpected',
+    }))
+    await Promise.resolve()
+
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'late-agent-after-invalid-message',
+      tool_use_id: 'late-agent-after-invalid-message-tool',
+      description: 'Late Agent after rejected message',
+      task_type: 'local_agent',
+    })
+    await Promise.resolve()
+
+    expect(requestControl).toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'late-agent-after-invalid-message',
+    }, 3_000)
+  })
+
+  it('keeps the Agent stop latch while a replacement send is pending or fails', async () => {
+    const sessionId = `stop-agent-pending-message-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    let resolveSend!: (sent: boolean) => void
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      () => new Promise<boolean>((resolve) => {
+        resolveSend = resolve
+      }),
+    )
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+
+    const emitAgentStart = (taskId: string) => {
+      const event = {
+        type: 'system',
+        subtype: 'task_started',
+        task_id: taskId,
+        tool_use_id: `${taskId}-tool`,
+        description: taskId,
+        task_type: 'local_agent',
+      }
+      for (const callback of [...outputCallbacks]) callback(event)
+    }
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: '',
+    }))
+    await flushMicrotasks()
+
+    emitAgentStart('agent-while-send-pending')
+    await flushMicrotasks()
+    expect(requestControl).toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'agent-while-send-pending',
+    }, 3_000)
+
+    resolveSend(false)
+    await flushMicrotasks()
+    emitAgentStart('agent-after-send-failed')
+    await flushMicrotasks()
+    expect(requestControl).toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'agent-after-send-failed',
+    }, 3_000)
+  })
+
+  it('cancels the same pending user admission when Stop arrives before CLI startup', async () => {
+    const sessionId = `stop-pending-admission-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let resolveTitle!: (title: string | null) => void
+    spyOn(conversationService, 'hasSession').mockReturnValue(false)
+    const startSession = spyOn(conversationService, 'startSession').mockResolvedValue()
+    const sendMessage = spyOn(conversationService, 'sendMessage').mockResolvedValue(true)
+    spyOn(sessionService, 'getCustomTitle').mockImplementation(
+      () => new Promise((resolve) => {
+        resolveTitle = resolve
+      }),
+    )
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Do not start this turn after Stop',
+    }))
+    await flushMicrotasks()
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    resolveTitle(null)
+    await flushMicrotasks(30)
+
+    expect(startSession).not.toHaveBeenCalled()
+    expect(sendMessage).not.toHaveBeenCalled()
+  })
+
+  it('broadcasts foreground Stop and its force-kill fallback to every renderer', () => {
+    const sessionId = `stop-multi-renderer-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    let forceKill!: () => void
+    spyOn(globalThis, 'setTimeout').mockImplementation((callback, delay) => {
+      if (delay === 3_000) forceKill = callback as () => void
+      return 1 as any
+    })
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    __markActiveTurnForTests(sessionId)
+    first.sent.length = 0
+    second.sent.length = 0
+
+    handleWebSocket.message(first, JSON.stringify({ type: 'stop_generation' }))
+
+    for (const client of [first, second]) {
+      expect(client.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+        type: 'status',
+        state: 'idle',
+      })
+    }
+    forceKill()
+    expect(stopSession).toHaveBeenCalledWith(sessionId)
+  })
+
+  it('reaps a send that was still awaiting acknowledgement when Stop arrived', async () => {
+    const sessionId = `stop-inflight-send-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let resolveSend!: (sent: boolean) => void
+    const timerCallbacks: Array<() => void> = []
+    spyOn(globalThis, 'setTimeout').mockImplementation((callback) => {
+      timerCallbacks.push(callback as () => void)
+      return 1 as any
+    })
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation(() => {})
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      () => new Promise<boolean>((resolve) => {
+        resolveSend = resolve
+      }),
+    )
+    const sendInterrupt = spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'This send has already entered the runtime',
+    }))
+    await flushMicrotasks(30)
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    expect(sendInterrupt).toHaveBeenCalledWith(sessionId)
+
+    resolveSend(true)
+    await flushMicrotasks(30)
+    expect(stopSession).toHaveBeenCalledWith(sessionId)
+
+    for (const callback of timerCallbacks) callback()
+    expect(stopSession).toHaveBeenCalledWith(sessionId)
+  })
+
+  it('keeps the committed turn boundary callback when Stop wins the await continuation', async () => {
+    const sessionId = `stop-committed-send-continuation-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    let releaseSend!: () => void
+    const sendContinuation = new Promise<void>((resolve) => {
+      releaseSend = resolve
+    })
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      async (_sid, _content, _attachments, options) => {
+        options?.onCommitted?.()
+        await sendContinuation
+        return true
+      },
+    )
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Committed before the handler resumed',
+    }))
+    await flushMicrotasks(30)
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    releaseSend()
+    await flushMicrotasks(30)
+
+    const interruptedResult = {
+      type: 'result',
+      subtype: 'error',
+      is_error: true,
+      result: 'Interrupted',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    }
+    for (const callback of [...outputCallbacks]) callback(interruptedResult)
+    await flushMicrotasks()
+    ws.sent.length = 0
+    handleWebSocket.message(ws, JSON.stringify({ type: 'sync_state' }))
+
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'session_state',
+      turnState: 'idle',
+    })
+  })
+
+  it('does not let an old pending-send fallback kill a replacement admission', async () => {
+    const sessionId = `stop-pending-send-replacement-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let resolveFirstSend!: (sent: boolean) => void
+    let resolveSecondSend!: (sent: boolean) => void
+    let sendCount = 0
+    let forceKill!: () => void
+    spyOn(globalThis, 'setTimeout').mockImplementation((callback, delay) => {
+      if (delay === 3_000) forceKill = callback as () => void
+      return 1 as any
+    })
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation(() => {})
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(() => {
+      sendCount++
+      return new Promise<boolean>((resolve) => {
+        if (sendCount === 1) resolveFirstSend = resolve
+        else resolveSecondSend = resolve
+      })
+    })
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Old turn with pending send acknowledgement',
+    }))
+    await flushMicrotasks(30)
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Replacement turn owns the runtime now',
+    }))
+    await flushMicrotasks(30)
+
+    forceKill()
+    expect(stopSession).not.toHaveBeenCalled()
+
+    resolveFirstSend(true)
+    await flushMicrotasks(20)
+    expect(stopSession).not.toHaveBeenCalled()
+
+    resolveSecondSend(true)
+    await flushMicrotasks(20)
+    expect(stopSession).not.toHaveBeenCalled()
+  })
+
+  it('releases the Agent stop latch only after the replacement replay is attributed', async () => {
+    const sessionId = `stop-agent-successful-message-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    let resolveSend!: (sent: boolean) => void
+    let commitSend!: () => void
+    let replacementUuid = ''
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      (_sid, _content, _attachments, options) => new Promise<boolean>((resolve) => {
+        replacementUuid = options?.messageUuid ?? ''
+        commitSend = options?.onCommitted ?? (() => {})
+        resolveSend = resolve
+      }),
+    )
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+
+    const emitAgentStart = (taskId: string) => {
+      const event = {
+        type: 'system',
+        subtype: 'task_started',
+        task_id: taskId,
+        tool_use_id: `${taskId}-tool`,
+        description: taskId,
+        task_type: 'local_agent',
+      }
+      for (const callback of [...outputCallbacks]) callback(event)
+    }
+    const emitReplay = (content: string, uuid: string) => {
+      const event = {
+        type: 'user',
+        isReplay: true,
+        uuid,
+        message: { role: 'user', content },
+      }
+      for (const callback of [...outputCallbacks]) callback(event)
+    }
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Replacement turn owns this boundary',
+    }))
+    await flushMicrotasks()
+
+    emitAgentStart('agent-before-send-succeeds')
+    await flushMicrotasks()
+    expect(requestControl).toHaveBeenCalledTimes(1)
+
+    commitSend()
+    resolveSend(true)
+    await flushMicrotasks()
+    emitAgentStart('agent-after-send-ack')
+    await flushMicrotasks()
+    expect(requestControl).toHaveBeenCalledTimes(2)
+
+    emitReplay('Replacement turn owns this boundary', crypto.randomUUID())
+    emitAgentStart('agent-after-wrong-replay')
+    await flushMicrotasks()
+    expect(requestControl).toHaveBeenCalledTimes(3)
+
+    emitReplay('Replacement turn owns this boundary', replacementUuid)
+    emitAgentStart('agent-after-matching-replay')
+    await flushMicrotasks()
+    expect(requestControl).toHaveBeenCalledTimes(3)
+  })
+
+  it('does not attribute an interrupted result or stale replay to a replacement turn', async () => {
+    const sessionId = `stop-replacement-boundary-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    const sentUuids: string[] = []
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      async (_sid, _content, _attachments, options) => {
+        sentUuids.push(options?.messageUuid ?? '')
+        options?.onCommitted?.()
+        return true
+      },
+    )
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+    spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    const emit = (event: any) => {
+      for (const callback of [...outputCallbacks]) callback(event)
+    }
+    const emitAgentStart = (taskId: string) => emit({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: taskId,
+      tool_use_id: `${taskId}-tool`,
+      description: taskId,
+      task_type: 'local_agent',
+    })
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Repeat this exact prompt',
+    }))
+    await flushMicrotasks(30)
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Repeat this exact prompt',
+    }))
+    await flushMicrotasks(30)
+    ws.sent.length = 0
+
+    emit({
+      type: 'result',
+      subtype: 'error',
+      is_error: true,
+      result: 'Interrupted',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+    emit({
+      type: 'user',
+      isReplay: true,
+      uuid: sentUuids[0],
+      message: { role: 'user', content: 'Repeat this exact prompt' },
+    })
+    emitAgentStart('agent-before-replacement-replay')
+    await flushMicrotasks()
+
+    const beforeReplacementReplay = ws.sent.map((payload) => JSON.parse(payload))
+    expect(beforeReplacementReplay).not.toContainEqual(expect.objectContaining({ type: 'error' }))
+    expect(beforeReplacementReplay).not.toContainEqual({
+      type: 'message_complete',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+    expect(requestControl).toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'agent-before-replacement-replay',
+    }, 3_000)
+
+    emit({
+      type: 'user',
+      isReplay: true,
+      uuid: sentUuids[1],
+      message: { role: 'user', content: 'Repeat this exact prompt' },
+    })
+    emitAgentStart('agent-owned-by-replacement')
+    emit({
+      type: 'result',
+      subtype: 'success',
+      is_error: false,
+      usage: { input_tokens: 1, output_tokens: 2 },
+    })
+    await flushMicrotasks()
+
+    expect(requestControl).not.toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'agent-owned-by-replacement',
+    }, 3_000)
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'message_complete',
+      usage: {
+        input_tokens: 1,
+        output_tokens: 2,
+      },
+    })
+  })
+
+  it('keeps consecutive Stop results ordered before a third replacement turn', async () => {
+    const sessionId = `stop-replacement-consecutive-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    const sentUuids: string[] = []
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      async (_sid, _content, _attachments, options) => {
+        sentUuids.push(options?.messageUuid ?? '')
+        options?.onCommitted?.()
+        return true
+      },
+    )
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+    spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    const emit = (event: any) => {
+      for (const callback of [...outputCallbacks]) callback(event)
+    }
+    const sendTurn = async () => {
+      handleWebSocket.message(ws, JSON.stringify({
+        type: 'user_message',
+        content: 'Same prompt across every turn',
+      }))
+      await flushMicrotasks(30)
+    }
+
+    handleWebSocket.open(ws)
+    await sendTurn()
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await sendTurn()
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await sendTurn()
+    ws.sent.length = 0
+
+    for (let index = 0; index < 2; index++) {
+      emit({
+        type: 'result',
+        subtype: 'error',
+        is_error: true,
+        result: 'Interrupted',
+        usage: { input_tokens: 0, output_tokens: 0 },
+      })
+    }
+    emit({
+      type: 'user',
+      isReplay: true,
+      uuid: sentUuids[1],
+      message: { role: 'user', content: 'Same prompt across every turn' },
+    })
+    emit({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-before-third-boundary',
+      tool_use_id: 'agent-before-third-boundary-tool',
+      description: 'Agent before third boundary',
+      task_type: 'local_agent',
+    })
+    await flushMicrotasks()
+
+    expect(ws.sent.map((payload) => JSON.parse(payload))).not.toContainEqual(
+      expect.objectContaining({ type: 'message_complete' }),
+    )
+    expect(requestControl).toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'agent-before-third-boundary',
+    }, 3_000)
+
+    emit({
+      type: 'user',
+      isReplay: true,
+      uuid: sentUuids[2],
+      message: { role: 'user', content: 'Same prompt across every turn' },
+    })
+    emit({
+      type: 'result',
+      subtype: 'success',
+      is_error: false,
+      usage: { input_tokens: 1, output_tokens: 1 },
+    })
+    await flushMicrotasks()
+
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'message_complete',
+      usage: { input_tokens: 1, output_tokens: 1 },
+    })
+  })
+
+  it('does not wait for an interrupted result when the old runtime is already gone', async () => {
+    const sessionId = `stop-replacement-no-runtime-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    let cliRunning = false
+    let replacementUuid = ''
+    spyOn(conversationService, 'hasSession').mockImplementation(() => cliRunning)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      async (_sid, _content, _attachments, options) => {
+        replacementUuid = options?.messageUuid ?? ''
+        options?.onCommitted?.()
+        return true
+      },
+    )
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+
+    handleWebSocket.open(ws)
+    __markActiveTurnForTests(sessionId)
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+
+    cliRunning = true
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Replacement on a fresh runtime',
+    }))
+    await flushMicrotasks(30)
+    const replay = {
+      type: 'user',
+      isReplay: true,
+      uuid: replacementUuid,
+      message: { role: 'user', content: 'Replacement on a fresh runtime' },
+    }
+    for (const callback of [...outputCallbacks]) callback(replay)
+    const agentStart = {
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'fresh-runtime-agent',
+      tool_use_id: 'fresh-runtime-agent-tool',
+      description: 'Fresh runtime Agent',
+      task_type: 'local_agent',
+    }
+    for (const callback of [...outputCallbacks]) callback(agentStart)
+    await flushMicrotasks()
+
+    expect(requestControl).not.toHaveBeenCalled()
+  })
+
+  it('uses a matching local slash command as the replacement boundary', async () => {
+    const sessionId = `stop-replacement-local-command-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      async (_sid, _content, _attachments, options) => {
+        options?.onCommitted?.()
+        return true
+      },
+    )
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+
+    const emit = (event: any) => {
+      for (const callback of [...outputCallbacks]) callback(event)
+    }
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Interrupted before a local command',
+    }))
+    await flushMicrotasks(30)
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: '/goal clear',
+    }))
+    await flushMicrotasks(30)
+    ws.sent.length = 0
+
+    emit({
+      type: 'result',
+      subtype: 'error',
+      is_error: true,
+      result: 'Interrupted',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+    emit({
+      type: 'system',
+      subtype: 'local_command',
+      content: '<command-name>/goal</command-name>\n<command-args>clear</command-args>',
+    })
+    emit({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-after-local-command-boundary',
+      tool_use_id: 'agent-after-local-command-boundary-tool',
+      description: 'Agent after local command boundary',
+      task_type: 'local_agent',
+    })
+    emit({
+      type: 'system',
+      subtype: 'local_command_output',
+      content: '<local-command-stdout>Goal cleared.</local-command-stdout>',
+    })
+    emit({
+      type: 'result',
+      subtype: 'success',
+      is_error: false,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+    await flushMicrotasks()
+
+    expect(requestControl).not.toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'agent-after-local-command-boundary',
+    }, 3_000)
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'goal_event',
+      message: 'Goal cleared.',
+      data: expect.objectContaining({
+        action: 'cleared',
+      }),
+    })
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'message_complete',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+  })
+
+  it('completes a local slash replacement after Agent control failure kills the runtime', async () => {
+    const sessionId = `stop-replacement-local-command-agent-failure-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      async (_sid, _content, _attachments, options) => {
+        options?.onCommitted?.()
+        return true
+      },
+    )
+    const requestControl = spyOn(conversationService, 'requestControl').mockRejectedValue(
+      new Error('Agent control channel failed'),
+    )
+    spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    const emit = (event: any) => {
+      for (const callback of [...outputCallbacks]) callback(event)
+    }
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Interrupt a foreground turn with an Agent',
+    }))
+    await flushMicrotasks(30)
+    emit({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-before-control-failure',
+      tool_use_id: 'agent-before-control-failure-tool',
+      description: 'Agent whose control channel fails',
+      task_type: 'local_agent',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks(30)
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: '/goal clear',
+    }))
+    await flushMicrotasks(30)
+    ws.sent.length = 0
+
+    emit({
+      type: 'system',
+      subtype: 'local_command',
+      content: '<command-name>/goal</command-name>\n<command-args>clear</command-args>',
+    })
+    emit({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-after-control-failure-boundary',
+      tool_use_id: 'agent-after-control-failure-boundary-tool',
+      description: 'Agent owned by the local command replacement',
+      task_type: 'local_agent',
+    })
+    emit({
+      type: 'system',
+      subtype: 'local_command_output',
+      content: '<local-command-stdout>Goal cleared.</local-command-stdout>',
+    })
+    emit({
+      type: 'result',
+      subtype: 'success',
+      is_error: false,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+    await flushMicrotasks(30)
+
+    expect(requestControl).toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'agent-before-control-failure',
+    }, 3_000)
+    expect(requestControl).not.toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'agent-after-control-failure-boundary',
+    }, 3_000)
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'message_complete',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+  })
+
+  it('arms idle cleanup after an Agent force-kill removes the cancelled turn', async () => {
+    const sessionId = `stop-agent-force-kill-disconnect-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    spyOn(conversationService, 'requestControl').mockRejectedValue(
+      new Error('Agent control channel failed'),
+    )
+    spyOn(conversationService, 'stopSession').mockImplementation(() => {})
+    spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    handleWebSocket.open(ws)
+    __markActiveTurnForTests(sessionId)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'force-kill-disconnect-agent',
+      tool_use_id: 'force-kill-disconnect-agent-tool',
+      task_type: 'local_agent',
+      description: 'Force runtime exit before renderer disconnects',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks(30)
+    handleWebSocket.close(ws, 1006, 'renderer closed after force-kill')
+
+    expect(setTimeoutSpy.mock.calls.some(([, delay]) => delay === 30_000)).toBe(true)
+  })
+
+  it('counts repeated Stop clicks once for the same foreground turn', async () => {
+    const sessionId = `stop-replacement-same-turn-repeated-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    const sendInterrupt = spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+    spyOn(sessionService, 'getCustomTitle').mockResolvedValue('Existing title')
+    spyOn(conversationService, 'sendMessage').mockImplementation(
+      async (_sid, _content, _attachments, options) => {
+        options?.onCommitted?.()
+        return true
+      },
+    )
+    spyOn(conversationService, 'requestControl').mockResolvedValue({})
+    spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    const emit = (event: any) => {
+      for (const callback of [...outputCallbacks]) callback(event)
+    }
+
+    handleWebSocket.open(ws)
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: 'Interrupt this turn once',
+    }))
+    await flushMicrotasks(30)
+    emit({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-during-repeated-stop',
+      tool_use_id: 'agent-during-repeated-stop-tool',
+      task_type: 'local_agent',
+      description: 'Keep the Agent stop control visible',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks(30)
+    emit({
+      type: 'result',
+      subtype: 'error',
+      is_error: true,
+      result: 'Interrupted',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+    handleWebSocket.message(ws, JSON.stringify({
+      type: 'user_message',
+      content: '/goal clear',
+    }))
+    await flushMicrotasks(30)
+    ws.sent.length = 0
+
+    emit({
+      type: 'system',
+      subtype: 'local_command',
+      content: '<command-name>/goal</command-name>\n<command-args>clear</command-args>',
+    })
+    emit({
+      type: 'system',
+      subtype: 'local_command_output',
+      content: '<local-command-stdout>Goal cleared.</local-command-stdout>',
+    })
+    emit({
+      type: 'result',
+      subtype: 'success',
+      is_error: false,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+    await flushMicrotasks(30)
+
+    expect(sendInterrupt).toHaveBeenCalledTimes(1)
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'message_complete',
+      usage: { input_tokens: 0, output_tokens: 0 },
+    })
+  })
+
+  it('closes Agent activity after the main turn settled when the fallback removes the CLI session', async () => {
+    const sessionId = `stop-agent-force-kill-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    let cliRunning = true
+    let outputCallback: ((cliMsg: any) => void) | null = null
+    const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(() => 1 as any)
+    spyOn(conversationService, 'hasSession').mockImplementation(() => cliRunning)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallback = callback
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(conversationService, 'sendInterrupt').mockImplementation(() => true)
+    spyOn(conversationService, 'requestControl').mockImplementation(
+      () => new Promise<Record<string, unknown>>(() => {}),
+    )
+    const stopSession = spyOn(conversationService, 'stopSession').mockImplementation(() => {
+      cliRunning = false
+    })
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    handleWebSocket.open(ws)
+    outputCallback?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'force-killed-agent',
+      tool_use_id: 'force-killed-agent-tool',
+      description: 'Hung Agent',
+      task_type: 'local_agent',
+    })
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    const expireForceKill = setTimeoutSpy.mock.calls[0]?.[0] as (() => void) | undefined
+    expireForceKill?.()
+    await Promise.resolve()
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(stopSession).toHaveBeenCalledWith(sessionId)
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'force-killed-agent',
+      toolUseId: 'force-killed-agent-tool',
+      status: 'stopped',
+    }))
+    expect(ws.sent.map((payload) => JSON.parse(payload))).toContainEqual({
+      type: 'system_notification',
+      subtype: 'task_notification',
+      data: expect.objectContaining({
+        task_id: 'force-killed-agent',
+        tool_use_id: 'force-killed-agent-tool',
+        status: 'stopped',
+      }),
+    })
+  })
+
   it('forwards background task stop requests to the CLI control channel', async () => {
     const sessionId = `stop-background-${crypto.randomUUID()}`
     const ws = makeClientSocket(sessionId)
     const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+    handleWebSocket.open(ws)
 
     handleWebSocket.message(ws, JSON.stringify({
       type: 'stop_background_task',
@@ -545,6 +3300,7 @@ describe('WebSocket handler session isolation', () => {
     const sessionId = `stop-background-failed-${crypto.randomUUID()}`
     const ws = makeClientSocket(sessionId)
     spyOn(conversationService, 'requestControl').mockRejectedValue(new Error('Task is not running'))
+    handleWebSocket.open(ws)
 
     handleWebSocket.message(ws, JSON.stringify({
       type: 'stop_background_task',
@@ -682,6 +3438,79 @@ describe('WebSocket handler session isolation', () => {
     }
   })
 
+  it('only forwards boundary resolutions while Stop gates late unscoped output', () => {
+    const sessionId = `permission-stop-resolution-${crypto.randomUUID()}`
+    const first = makeClientSocket(sessionId)
+    const second = makeClientSocket(sessionId)
+    const outputCallbacks = new Set<(cliMsg: any) => void>()
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.add(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation((_sid, callback) => {
+      outputCallbacks.delete(callback)
+    })
+    spyOn(conversationService, 'sendInterrupt').mockReturnValue(true)
+
+    handleWebSocket.open(first)
+    handleWebSocket.open(second)
+    __markActiveTurnForTests(sessionId)
+    handleWebSocket.message(first, JSON.stringify({ type: 'stop_generation' }))
+    first.sent.length = 0
+    second.sent.length = 0
+
+    for (const callback of [...outputCallbacks]) {
+      callback({ type: 'system', subtype: 'status', status: null })
+      callback({
+        type: 'control_request',
+        request_id: 'late-permission-after-stop',
+        request: {
+          subtype: 'can_use_tool',
+          tool_name: 'Bash',
+          input: { command: 'echo stale' },
+        },
+      })
+      callback({
+        type: 'system',
+        subtype: 'task_progress',
+        task_id: 'late-agent-progress-after-stop',
+        task_type: 'local_agent',
+        description: 'Stale Agent progress',
+      })
+    }
+
+    const cancellation = {
+      type: 'control_cancel_request',
+      request_id: 'permission-cancelled-by-stop',
+    }
+    for (const callback of [...outputCallbacks]) callback(cancellation)
+
+    for (const ws of [first, second]) {
+      const sent = ws.sent.map((payload) => JSON.parse(payload))
+      expect(sent).not.toContainEqual(expect.objectContaining({
+        type: 'permission_request',
+        requestId: 'late-permission-after-stop',
+      }))
+      expect(sent).not.toContainEqual(expect.objectContaining({
+        type: 'status',
+        state: 'thinking',
+      }))
+      expect(sent).not.toContainEqual(expect.objectContaining({
+        type: 'status',
+        state: 'tool_executing',
+      }))
+      expect(sent).not.toContainEqual(expect.objectContaining({
+        type: 'system_notification',
+        subtype: 'task_progress',
+      }))
+      expect(sent).toContainEqual({
+        type: 'permission_resolved',
+        requestId: 'permission-cancelled-by-stop',
+        permissionType: 'tool',
+      })
+    }
+  })
+
   it('keeps disconnected sessions alive longer while user input is pending', () => {
     const sessionId = `permission-disconnect-${crypto.randomUUID()}`
     const ws = makeClientSocket(sessionId)
@@ -912,6 +3741,125 @@ describe('WebSocket handler session isolation', () => {
     expect(stopSession).toHaveBeenCalledWith(sessionId)
   })
 
+  it('arms disconnected cleanup after a stopped Agent bookend finishes persisting', async () => {
+    const sessionId = `stopped-agent-disconnect-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId, 'pet')
+    const setTimeoutSpy = spyOn(globalThis, 'setTimeout').mockImplementation(() => 789 as any)
+    const clearTimeoutSpy = spyOn(globalThis, 'clearTimeout').mockImplementation(() => {})
+    spyOn(conversationService, 'getPendingPermissionRequests').mockReturnValue([])
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    const requestControl = spyOn(conversationService, 'requestControl').mockResolvedValue({})
+    const archiveRemoteSession = spyOn(teleportApi, 'archiveRemoteSession').mockResolvedValue()
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    let resolveAppend: (() => void) | undefined
+    const append = spyOn(sessionService, 'appendSessionTaskNotification')
+      .mockImplementationOnce(() => new Promise<void>((resolve) => {
+        resolveAppend = resolve
+      }))
+      .mockResolvedValue()
+    __setDisconnectGraceMsForTests(1_234)
+
+    handleWebSocket.open(ws)
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'agent-task-stop-disconnect',
+      tool_use_id: 'agent-tool-stop-disconnect',
+      description: 'Stop while renderer closes',
+      task_type: 'local_agent',
+    })
+    setTimeoutSpy.mockClear()
+
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+    expect(append).toHaveBeenCalledTimes(1)
+
+    handleWebSocket.close(ws, 1000, 'renderer closed during stop persistence')
+    expect(outputCallbacks).toHaveLength(2)
+    setTimeoutSpy.mockClear()
+
+    resolveAppend?.()
+    await flushMicrotasks()
+
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(1)
+    expect(setTimeoutSpy.mock.calls[0]?.[1]).toBe(1_234)
+    expect(outputCallbacks).toHaveLength(3)
+
+    setTimeoutSpy.mockClear()
+    clearTimeoutSpy.mockClear()
+    outputCallbacks.at(-1)?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'late-remote-agent-after-disconnect',
+      tool_use_id: 'late-remote-agent-tool-after-disconnect',
+      description: 'Spawned after the stopped bookend',
+      task_type: 'remote_agent',
+      remote_session_id: 'late-remote-session-after-disconnect',
+    })
+    await flushMicrotasks()
+
+    expect(requestControl).toHaveBeenCalledWith(sessionId, {
+      subtype: 'stop_task',
+      task_id: 'late-remote-agent-after-disconnect',
+    }, 3_000)
+    expect(archiveRemoteSession).toHaveBeenCalledWith(
+      'late-remote-session-after-disconnect',
+      { timeoutMs: 1_500 },
+    )
+    expect(clearTimeoutSpy).toHaveBeenCalledWith(789)
+    expect(setTimeoutSpy.mock.calls.filter((call) => call[1] === 1_234)).toHaveLength(1)
+  })
+
+  it('persists a local Agent terminal event observed only after Stop disconnects', async () => {
+    const sessionId = `stopped-local-agent-disconnect-${crypto.randomUUID()}`
+    const ws = makeClientSocket(sessionId)
+    const outputCallbacks: Array<(cliMsg: any) => void> = []
+    spyOn(globalThis, 'setTimeout').mockImplementation(() => 789 as any)
+    spyOn(conversationService, 'hasSession').mockReturnValue(true)
+    spyOn(conversationService, 'onOutput').mockImplementation((_sid, callback) => {
+      outputCallbacks.push(callback)
+    })
+    spyOn(conversationService, 'removeOutputCallback').mockImplementation(() => {})
+    spyOn(conversationService, 'requestControl').mockImplementation(
+      () => new Promise<Record<string, unknown>>(() => {}),
+    )
+    const append = spyOn(sessionService, 'appendSessionTaskNotification').mockResolvedValue()
+
+    handleWebSocket.open(ws)
+    outputCallbacks[0]?.({
+      type: 'system',
+      subtype: 'task_started',
+      task_id: 'local-agent-terminal-after-disconnect',
+      tool_use_id: 'local-agent-terminal-after-disconnect-tool',
+      description: 'Stop while the renderer disconnects',
+      task_type: 'local_agent',
+    })
+    handleWebSocket.message(ws, JSON.stringify({ type: 'stop_generation' }))
+    await flushMicrotasks()
+
+    handleWebSocket.close(ws, 1006, 'renderer disconnected before local terminal')
+    expect(outputCallbacks.length).toBeGreaterThanOrEqual(2)
+    outputCallbacks.at(-1)?.({
+      type: 'system',
+      subtype: 'task_notification',
+      task_id: 'local-agent-terminal-after-disconnect',
+      tool_use_id: 'local-agent-terminal-after-disconnect-tool',
+      task_type: 'local_agent',
+      status: 'stopped',
+    })
+    await flushMicrotasks()
+
+    expect(append).toHaveBeenCalledWith(sessionId, expect.objectContaining({
+      taskId: 'local-agent-terminal-after-disconnect',
+      toolUseId: 'local-agent-terminal-after-disconnect-tool',
+      status: 'stopped',
+    }))
+  })
+
   it('cancels an armed idle timer when a background task starts late', () => {
     const sessionId = `late-background-task-${crypto.randomUUID()}`
     const ws = makeClientSocket(sessionId, 'pet')
diff --git a/src/server/services/conversationService.ts b/src/server/services/conversationService.ts
index 75ef046d..eb693504 100644
--- a/src/server/services/conversationService.ts
+++ b/src/server/services/conversationService.ts
@@ -152,6 +152,16 @@ type AttachmentRef = {
 
 type UserContentBlock = Record<string, unknown>
 
+type SendMessageOptions = {
+  canSend?: () => boolean
+  messageUuid?: string
+  onCommitted?: () => void
+}
+
+type HandleSdkPayloadOptions = {
+  canAcceptPermissionRequest?: (message: any) => boolean
+}
+
 type MaterializedAttachments = {
   pathPrefix: string
   imageBlocks: UserContentBlock[]
@@ -584,6 +594,7 @@ export class ConversationService {
     sessionId: string,
     content: string,
     attachments?: AttachmentRef[],
+    options?: SendMessageOptions,
   ): Promise<boolean> {
     const userContent = await this.buildUserContent(content, sessionId, attachments)
     let session = this.sessions.get(sessionId)
@@ -594,8 +605,14 @@ export class ConversationService {
     if (session) {
       await this.refreshOfficialOAuthTokenBeforeTurn(sessionId, session)
     }
-    return this.sendSdkMessage(sessionId, {
+    // Building attachments, refreshing network settings, and refreshing OAuth
+    // can all suspend this call. Stop may revoke the owning desktop turn while
+    // one of those awaits is pending, so check ownership at the last possible
+    // point before writing the user message to the SDK socket.
+    if (options?.canSend && !options.canSend()) return false
+    const sent = this.sendSdkMessage(sessionId, {
       type: 'user',
+      ...(options?.messageUuid ? { uuid: options.messageUuid } : {}),
       message: {
         role: 'user',
         content: userContent,
@@ -603,6 +620,8 @@ export class ConversationService {
       parent_tool_use_id: null,
       session_id: '',
     })
+    if (sent) options?.onCommitted?.()
+    return sent
   }
 
   private async refreshNetworkEnvironmentBeforeTurn(
@@ -997,7 +1016,11 @@ export class ConversationService {
     return false
   }
 
-  handleSdkPayload(sessionId: string, rawPayload: string): void {
+  handleSdkPayload(
+    sessionId: string,
+    rawPayload: string,
+    options?: HandleSdkPayloadOptions,
+  ): void {
     const session = this.sessions.get(sessionId)
     if (!session) return
 
@@ -1010,6 +1033,18 @@ export class ConversationService {
       try {
         const msg = JSON.parse(line)
         if (this.isReplayedSdkMessage(session, msg)) continue
+        if (
+          msg?.type === 'control_request' &&
+          msg.request?.subtype === 'can_use_tool' &&
+          typeof msg.request_id === 'string' &&
+          options?.canAcceptPermissionRequest?.(msg) === false
+        ) {
+          // Stop may win while a permission request is already queued on the
+          // SDK transport. Reject it at the service boundary so it is neither
+          // persisted as pending nor replayed to a reconnecting renderer.
+          this.respondToPermission(sessionId, msg.request_id, false)
+          continue
+        }
         this.retainSdkMessage(session, msg, Buffer.byteLength(line, 'utf-8'))
         const sdkError = this.extractSdkErrorEvent(msg)
         if (sdkError) {
diff --git a/src/server/services/sessionService.ts b/src/server/services/sessionService.ts
index ddf9097b..00b615a4 100644
--- a/src/server/services/sessionService.ts
+++ b/src/server/services/sessionService.ts
@@ -442,6 +442,17 @@ function getSharedSessionMutationState(
 
 export class SessionService {
   private providerService = new ProviderService()
+  private readonly pendingTaskNotificationWrites = new Map<
+    string,
+    Set<{
+      controller: AbortController
+      promise: Promise<void>
+      notification: SessionTaskNotification
+      persisted: boolean
+    }>
+  >()
+  private readonly taskNotificationMutationEpochs = new Map<string, number>()
+  private readonly clearingTaskNotificationSessions = new Set<string>()
 
   private readonly localIndexGateway: LocalIndexGateway
   private readonly now: () => number
@@ -1256,8 +1267,20 @@ export class SessionService {
     }
   }
 
-  private async appendJsonlEntry(filePath: string, entry: Record<string, unknown>): Promise<void> {
+  private async appendJsonlEntry(
+    filePath: string,
+    entry: Record<string, unknown>,
+    signal?: AbortSignal,
+  ): Promise<void> {
     const line = JSON.stringify(entry) + '\n'
+    if (signal) {
+      await fs.writeFile(filePath, line, {
+        encoding: 'utf-8',
+        flag: 'a',
+        signal,
+      })
+      return
+    }
     await fs.appendFile(filePath, line, 'utf-8')
   }
 
@@ -3721,58 +3744,83 @@ export class SessionService {
     fallbackWorkDir?: string,
     preservedPermissionMode?: string,
   ): Promise<void> {
-    let found = await this.findSessionFile(sessionId)
-    if (!found && fallbackWorkDir) {
-      const resolvedPath = path.resolve(normalizeDriveRootPathForPlatform(fallbackWorkDir))
-      const absWorkDir = await fs.realpath(resolvedPath).catch(() => resolvedPath)
-      const dirPath = path.join(this.getProjectsDir(), this.sanitizePath(absWorkDir))
-      await fs.mkdir(dirPath, { recursive: true })
-      found = {
-        filePath: path.join(dirPath, `${sessionId}.jsonl`),
-        projectDir: this.sanitizePath(absWorkDir),
+    const nextEpoch = (this.taskNotificationMutationEpochs.get(sessionId) ?? 0) + 1
+    this.taskNotificationMutationEpochs.set(sessionId, nextEpoch)
+    this.clearingTaskNotificationSessions.add(sessionId)
+    const pendingWrites = [...(this.pendingTaskNotificationWrites.get(sessionId) ?? [])]
+    for (const pending of pendingWrites) pending.controller.abort()
+
+    try {
+      await Promise.allSettled(pendingWrites.map((pending) => pending.promise))
+
+      let found = await this.findSessionFile(sessionId)
+      if (!found && fallbackWorkDir) {
+        const resolvedPath = path.resolve(normalizeDriveRootPathForPlatform(fallbackWorkDir))
+        const absWorkDir = await fs.realpath(resolvedPath).catch(() => resolvedPath)
+        const dirPath = path.join(this.getProjectsDir(), this.sanitizePath(absWorkDir))
+        await fs.mkdir(dirPath, { recursive: true })
+        found = {
+          filePath: path.join(dirPath, `${sessionId}.jsonl`),
+          projectDir: this.sanitizePath(absWorkDir),
+        }
+      }
+      if (!found) {
+        throw ApiError.notFound(`Session not found: ${sessionId}`)
       }
-    }
-    if (!found) {
-      throw ApiError.notFound(`Session not found: ${sessionId}`)
-    }
 
-    const entries = await this.readJsonlFile(found.filePath)
-    const workDir = this.resolveWorkDirFromEntries(entries, found.projectDir) || fallbackWorkDir || process.cwd()
-    const repository = this.resolveRepositoryFromEntries(entries)
-    const permissionMode = (
-      preservedPermissionMode &&
-      VALID_SESSION_PERMISSION_MODES.has(preservedPermissionMode)
-    )
-      ? preservedPermissionMode
-      : this.resolvePermissionModeFromEntries(entries)
-    const now = new Date().toISOString()
+      const entries = await this.readJsonlFile(found.filePath)
+      const workDir = this.resolveWorkDirFromEntries(entries, found.projectDir) || fallbackWorkDir || process.cwd()
+      const repository = this.resolveRepositoryFromEntries(entries)
+      const permissionMode = (
+        preservedPermissionMode &&
+        VALID_SESSION_PERMISSION_MODES.has(preservedPermissionMode)
+      )
+        ? preservedPermissionMode
+        : this.resolvePermissionModeFromEntries(entries)
+      const now = new Date().toISOString()
 
-    const initialEntry = {
-      type: 'file-history-snapshot',
-      messageId: crypto.randomUUID(),
-      snapshot: {
+      const initialEntry = {
+        type: 'file-history-snapshot',
         messageId: crypto.randomUUID(),
-        trackedFileBackups: {},
+        snapshot: {
+          messageId: crypto.randomUUID(),
+          trackedFileBackups: {},
+          timestamp: now,
+        },
+        isSnapshotUpdate: false,
+      }
+
+      const metaEntry = {
+        type: 'session-meta',
+        isMeta: true,
+        workDir,
+        repository,
+        ...(permissionMode ? { permissionMode } : {}),
         timestamp: now,
-      },
-      isSnapshotUpdate: false,
-    }
+      }
 
-    const metaEntry = {
-      type: 'session-meta',
-      isMeta: true,
-      workDir,
-      repository,
-      ...(permissionMode ? { permissionMode } : {}),
-      timestamp: now,
+      await fs.writeFile(
+        found.filePath,
+        `${JSON.stringify(initialEntry)}\n${JSON.stringify(metaEntry)}\n`,
+        'utf-8',
+      )
+      this.invalidateSessionListCache()
+    } catch (error) {
+      // Clear aborts old-generation appends so none can land after a successful
+      // transcript replacement. If replacement itself fails, restore any
+      // terminal notification that the barrier interrupted; otherwise a
+      // previously persisted running Agent can reappear after restart.
+      this.clearingTaskNotificationSessions.delete(sessionId)
+      await Promise.allSettled(
+        pendingWrites
+          .filter((pending) => !pending.persisted)
+          .map((pending) =>
+            this.appendSessionTaskNotification(sessionId, pending.notification)),
+      )
+      throw error
+    } finally {
+      this.clearingTaskNotificationSessions.delete(sessionId)
     }
-
-    await fs.writeFile(
-      found.filePath,
-      `${JSON.stringify(initialEntry)}\n${JSON.stringify(metaEntry)}\n`,
-      'utf-8',
-    )
-    this.invalidateSessionListCache()
   }
 
   async appendSessionMetadata(
@@ -3988,17 +4036,50 @@ export class SessionService {
       notification.timestamp ?? new Date(this.now()).toISOString(),
     )
     if (!normalized) return
+    if (this.clearingTaskNotificationSessions.has(sessionId)) return
 
-    const found = await this.findSessionFile(sessionId)
-    if (!found) return
+    const epoch = this.taskNotificationMutationEpochs.get(sessionId) ?? 0
+    const controller = new AbortController()
+    const pending = {
+      controller,
+      promise: Promise.resolve(),
+      notification: normalized,
+      persisted: false,
+    }
+    const write = (async () => {
+      const found = await this.findSessionFile(sessionId)
+      if (
+        !found ||
+        controller.signal.aborted ||
+        this.clearingTaskNotificationSessions.has(sessionId) ||
+        (this.taskNotificationMutationEpochs.get(sessionId) ?? 0) !== epoch
+      ) {
+        return
+      }
 
-    await this.appendJsonlEntry(found.filePath, {
-      type: PERSISTED_TASK_NOTIFICATION_ENTRY_TYPE,
-      isMeta: true,
-      taskNotification: normalized,
-      timestamp: normalized.timestamp,
-    })
-    this.invalidateSessionListCache()
+      await this.appendJsonlEntry(found.filePath, {
+        type: PERSISTED_TASK_NOTIFICATION_ENTRY_TYPE,
+        isMeta: true,
+        taskNotification: normalized,
+        timestamp: normalized.timestamp,
+      }, controller.signal)
+      pending.persisted = true
+      this.invalidateSessionListCache()
+    })()
+    pending.promise = write
+
+    let writes = this.pendingTaskNotificationWrites.get(sessionId)
+    if (!writes) {
+      writes = new Set()
+      this.pendingTaskNotificationWrites.set(sessionId, writes)
+    }
+    writes.add(pending)
+    try {
+      await write
+    } finally {
+      writes.delete(pending)
+      if (writes.size === 0) this.pendingTaskNotificationWrites.delete(sessionId)
+    }
   }
 
   async getSessionTaskNotifications(
diff --git a/src/server/ws/handler.ts b/src/server/ws/handler.ts
index 089610ec..f45950c5 100644
--- a/src/server/ws/handler.ts
+++ b/src/server/ws/handler.ts
@@ -47,6 +47,7 @@ import {
   type TitleConversationTurn,
 } from '../services/titleService.js'
 import { parseSlashCommand } from '../../utils/slashCommandParsing.js'
+import { archiveRemoteSession } from '../../utils/teleport/api.js'
 import {
   COMMAND_NAME_TAG,
   LOCAL_COMMAND_STDERR_TAG,
@@ -107,29 +108,6 @@ const sessionDisconnectWatchers = new Map<string, () => void>()
  */
 const sessionStopRequested = new Set<string>()
 
-function isStoppedTurnForegroundMessage(message: ServerMessage): boolean {
-  switch (message.type) {
-    case 'content_start':
-    case 'content_delta':
-    case 'tool_use_complete':
-    case 'tool_result':
-    case 'permission_request':
-    case 'computer_use_permission_request':
-    case 'user_message_replay':
-    case 'thinking':
-    case 'api_retry':
-    case 'streaming_fallback':
-    case 'error':
-      return true
-    case 'status':
-      return message.state !== 'idle'
-    case 'session_state':
-      return message.turnState === 'running'
-    default:
-      return false
-  }
-}
-
 /**
  * Track user message count and title state per session for auto-title generation.
  */
@@ -151,11 +129,52 @@ type RuntimeOverride = {
 
 type ActiveUserTurnState = {
   messageSent: boolean
+  sendStarted?: boolean
+  interruptBoundaryPending?: boolean
+  replacementAfterStop?: boolean
+  expectedReplayUuid?: string
+  expectedLocalCommand?: NonNullable<ReturnType<typeof parseSlashCommand>>
+  cancelled?: boolean
+}
+
+type AgentTaskType = 'local_agent' | 'remote_agent'
+
+type ActiveNonAgentTaskState = {
+  taskId: string
+  taskType?: string
+  toolUseId: string
+  description?: string
+}
+
+type ActiveAgentTaskState = {
+  taskId: string
+  taskType: AgentTaskType
+  toolUseId: string
+  remoteSessionId?: string
+  description?: string
+  stopIntent: boolean
+  stopRequested: boolean
+  localStopConfirmed: boolean
+  bookendPending: boolean
+  finalizationRetryCount: number
+  finalizationRetryTimer?: ReturnType<typeof setTimeout>
+  finalization?: Promise<boolean>
+  remoteArchive?: Promise<boolean>
+  remoteArchiveError?: string
+  stopFailureMessage?: string
 }
 
 const runtimeOverrides = new Map<string, RuntimeOverride>()
 const activeUserTurns = new Map<string, ActiveUserTurnState>()
 const activeBackgroundTaskIds = new Map<string, Set<string>>()
+const activeAgentTasks = new Map<string, Map<string, ActiveAgentTaskState>>()
+const activeNonAgentTasks = new Map<string, Map<string, ActiveNonAgentTaskState>>()
+const authoritativeStoppedTaskIds = new Map<string, Set<string>>()
+const agentStopRequestedSessions = new Set<string>()
+const runtimeExitStoppedSessions = new Set<string>()
+const pendingInterruptedTurnResults = new Map<string, number>()
+const interruptedTurnResultMessages = new WeakMap<object, string>()
+const sessionClearInProgress = new Set<string>()
 const deferredRuntimeRestarts = new Map<string, RuntimeOverride>()
 const deferredPermissionModes = new Map<string, PermissionMode>()
 
@@ -208,19 +227,35 @@ function settleSessionChatActivity(sessionId: string, cliMsg: any): void {
 type CliBackgroundTaskLifecycle = {
   taskId: string
   running: boolean
+  taskType?: string
+  toolUseId?: string
+  remoteSessionId?: string
+  description?: string
+  status?: string
+  suppressForward?: boolean
 }
 
 function getCliBackgroundTaskLifecycle(cliMsg: any): CliBackgroundTaskLifecycle | null {
   if (cliMsg?.type !== 'system') return null
   const taskId = typeof cliMsg.task_id === 'string' ? cliMsg.task_id.trim() : ''
   if (!taskId) return null
+  const optionalString = (value: unknown) =>
+    typeof value === 'string' && value.trim() ? value.trim() : undefined
+  const taskType = typeof cliMsg.task_type === 'string' && cliMsg.task_type.trim()
+    ? cliMsg.task_type.trim()
+    : undefined
+  const toolUseId = optionalString(cliMsg.tool_use_id)
+  const remoteSessionId = optionalString(cliMsg.remote_session_id)
+  const description = optionalString(cliMsg.description) ??
+    optionalString(cliMsg.message) ??
+    optionalString(cliMsg.title)
 
   if (cliMsg.subtype === 'task_started') {
-    return { taskId, running: true }
+    return { taskId, running: true, taskType, toolUseId, remoteSessionId, description }
   }
 
   if (cliMsg.subtype === 'task_notification' && cliMsg.status === 'running') {
-    return { taskId, running: true }
+    return { taskId, running: true, taskType, toolUseId, remoteSessionId, description }
   }
 
   if (
@@ -230,19 +265,111 @@ function getCliBackgroundTaskLifecycle(cliMsg: any): CliBackgroundTaskLifecycle
       cliMsg.status === 'stopped' ||
       cliMsg.status === 'killed')
   ) {
-    return { taskId, running: false }
+    return { taskId, running: false, status: cliMsg.status }
   }
 
   return null
 }
 
+function isAgentTaskType(taskType: string | undefined): taskType is AgentTaskType {
+  return taskType === 'local_agent' || taskType === 'remote_agent'
+}
+
+function untrackCliBackgroundTask(sessionId: string, taskId: string): void {
+  const taskIds = activeBackgroundTaskIds.get(sessionId)
+  taskIds?.delete(taskId)
+  if (taskIds?.size === 0) activeBackgroundTaskIds.delete(sessionId)
+
+  const sessionAgentTasks = activeAgentTasks.get(sessionId)
+  const agentTask = sessionAgentTasks?.get(taskId)
+  if (agentTask?.finalizationRetryTimer !== undefined) {
+    clearTimeout(agentTask.finalizationRetryTimer)
+  }
+  sessionAgentTasks?.delete(taskId)
+  if (sessionAgentTasks?.size === 0) activeAgentTasks.delete(sessionId)
+
+  const sessionNonAgentTasks = activeNonAgentTasks.get(sessionId)
+  sessionNonAgentTasks?.delete(taskId)
+  if (sessionNonAgentTasks?.size === 0) activeNonAgentTasks.delete(sessionId)
+}
+
+function clearAgentRuntimeState(
+  sessionId: string,
+  options?: { preserveRetryableStops?: boolean },
+): void {
+  const retryableStops = options?.preserveRetryableStops
+    ? new Map(
+        [...(activeAgentTasks.get(sessionId)?.entries() ?? [])].filter(([, task]) =>
+          task.stopIntent && task.localStopConfirmed && Boolean(task.stopFailureMessage),
+        ),
+      )
+    : new Map<string, ActiveAgentTaskState>()
+
+  for (const task of activeAgentTasks.get(sessionId)?.values() ?? []) {
+    clearAgentStopFinalizationRetry(task)
+  }
+  activeBackgroundTaskIds.delete(sessionId)
+  activeAgentTasks.delete(sessionId)
+  activeNonAgentTasks.delete(sessionId)
+  authoritativeStoppedTaskIds.delete(sessionId)
+  agentStopRequestedSessions.delete(sessionId)
+  runtimeExitStoppedSessions.delete(sessionId)
+
+  if (retryableStops.size > 0) {
+    activeAgentTasks.set(sessionId, retryableStops)
+    activeBackgroundTaskIds.set(sessionId, new Set(retryableStops.keys()))
+    agentStopRequestedSessions.add(sessionId)
+  }
+}
+
+function markTaskAuthoritativelyStopped(sessionId: string, taskId: string): void {
+  let taskIds = authoritativeStoppedTaskIds.get(sessionId)
+  if (!taskIds) {
+    taskIds = new Set()
+    authoritativeStoppedTaskIds.set(sessionId, taskIds)
+  }
+  taskIds.add(taskId)
+}
+
 function trackCliBackgroundTaskLifecycle(
   sessionId: string,
   cliMsg: any,
 ): CliBackgroundTaskLifecycle | null {
+  const rawTaskId = cliMsg?.type === 'system' && typeof cliMsg.task_id === 'string'
+    ? cliMsg.task_id.trim()
+    : ''
+  if (rawTaskId && authoritativeStoppedTaskIds.get(sessionId)?.has(rawTaskId)) {
+    // The lifecycle parser intentionally ignores progress and tool-activity
+    // messages. Check the raw task id first so no late task-scoped event can
+    // revive an Agent after its durable stopped bookend has been published.
+    return {
+      taskId: rawTaskId,
+      running: false,
+      status: 'stopped',
+      suppressForward: true,
+    }
+  }
+
   const lifecycle = getCliBackgroundTaskLifecycle(cliMsg)
   if (!lifecycle) return null
 
+  const existingAgentTask = activeAgentTasks.get(sessionId)?.get(lifecycle.taskId)
+  if (
+    lifecycle.running &&
+    existingAgentTask?.stopIntent &&
+    existingAgentTask.localStopConfirmed
+  ) {
+    // Once the local task has acknowledged Stop, any queued start/progress
+    // event is stale. Do not let it revive Activity or cancel idle cleanup
+    // while strict archive/bookend finalization is being retried.
+    return {
+      ...lifecycle,
+      running: false,
+      status: 'stopped',
+      suppressForward: true,
+    }
+  }
+
   if (lifecycle.running) {
     let taskIds = activeBackgroundTaskIds.get(sessionId)
     if (!taskIds) {
@@ -250,17 +377,73 @@ function trackCliBackgroundTaskLifecycle(
       activeBackgroundTaskIds.set(sessionId, taskIds)
     }
     taskIds.add(lifecycle.taskId)
+    if (isAgentTaskType(lifecycle.taskType)) {
+      let sessionAgentTasks = activeAgentTasks.get(sessionId)
+      if (!sessionAgentTasks) {
+        sessionAgentTasks = new Map()
+        activeAgentTasks.set(sessionId, sessionAgentTasks)
+      }
+      const existing = sessionAgentTasks.get(lifecycle.taskId)
+      if (existing) {
+        existing.toolUseId = lifecycle.toolUseId ?? existing.toolUseId
+        if (lifecycle.remoteSessionId) existing.remoteSessionId = lifecycle.remoteSessionId
+        if (lifecycle.description) existing.description = lifecycle.description
+      } else {
+        sessionAgentTasks.set(lifecycle.taskId, {
+          taskId: lifecycle.taskId,
+          taskType: lifecycle.taskType,
+          toolUseId: lifecycle.toolUseId ?? lifecycle.taskId,
+          ...(lifecycle.remoteSessionId
+            ? { remoteSessionId: lifecycle.remoteSessionId }
+            : {}),
+          ...(lifecycle.description ? { description: lifecycle.description } : {}),
+          stopIntent: false,
+          stopRequested: false,
+          localStopConfirmed: false,
+          bookendPending: false,
+          finalizationRetryCount: 0,
+        })
+      }
+    } else {
+      let sessionNonAgentTasks = activeNonAgentTasks.get(sessionId)
+      if (!sessionNonAgentTasks) {
+        sessionNonAgentTasks = new Map()
+        activeNonAgentTasks.set(sessionId, sessionNonAgentTasks)
+      }
+      sessionNonAgentTasks.set(lifecycle.taskId, {
+        taskId: lifecycle.taskId,
+        ...(lifecycle.taskType ? { taskType: lifecycle.taskType } : {}),
+        toolUseId: lifecycle.toolUseId ?? lifecycle.taskId,
+        ...(lifecycle.description ? { description: lifecycle.description } : {}),
+      })
+    }
     return lifecycle
   }
 
-  const taskIds = activeBackgroundTaskIds.get(sessionId)
-  taskIds?.delete(lifecycle.taskId)
-  if (taskIds?.size === 0) activeBackgroundTaskIds.delete(sessionId)
+  const sessionAgentTasks = activeAgentTasks.get(sessionId)
+  const agentTask = sessionAgentTasks?.get(lifecycle.taskId)
+  if (agentTask?.stopIntent) {
+    // A terminal event proves the local Agent process/poller has stopped. Turn
+    // it into the same durable synthetic bookend used by the control response
+    // so a renderer that disconnected during Stop can reconcile from history.
+    // Remote Agents additionally remain gated on strict archive confirmation.
+    agentTask.localStopConfirmed = true
+    void emitAuthoritativeAgentStopped(sessionId, agentTask)
+    return { ...lifecycle, suppressForward: true }
+  }
+
+  untrackCliBackgroundTask(sessionId, lifecycle.taskId)
   return lifecycle
 }
 
 function hasActiveBackgroundTasks(sessionId: string): boolean {
-  return (activeBackgroundTaskIds.get(sessionId)?.size ?? 0) > 0
+  const taskIds = activeBackgroundTaskIds.get(sessionId)
+  if (!taskIds || taskIds.size === 0) return false
+  const sessionAgentTasks = activeAgentTasks.get(sessionId)
+  return [...taskIds].some((taskId) => {
+    const agentTask = sessionAgentTasks?.get(taskId)
+    return !agentTask || !agentTask.localStopConfirmed || agentTask.bookendPending
+  })
 }
 
 export function getSessionChatActivityState(sessionId: string): SessionChatActivityState {
@@ -377,6 +560,7 @@ const clientOutputCallbacks = new Map<
   }
 >()
 const taskNotificationPersistence = new Map<string, Map<string, Promise<void>>>()
+const sessionTranscriptEpochs = new Map<string, number>()
 
 export const handleWebSocket = {
   open(ws: ServerWebSocket<WebSocketData>) {
@@ -429,15 +613,24 @@ export const handleWebSocket = {
       type: 'permission_requests_snapshot',
       toolRequestIds,
       computerUseRequestIds,
-      turnActive:
-        hasPendingOrActiveUserTurn(sessionId) && !sessionStopRequested.has(sessionId),
+      turnActive: hasLiveUserTurnForClient(sessionId),
     })
+    replayAgentStopFailures(ws, sessionId)
   },
 
   message(ws: ServerWebSocket<WebSocketData>, rawMessage: string | Buffer) {
     if (ws.data.channel === 'sdk') {
+      const { sessionId, sdkToken } = ws.data
+      if (!conversationService.authorizeSdkConnection(sessionId, sdkToken)) {
+        console.warn(`[WS] Rejected stale SDK message for session: ${sessionId}`)
+        ws.close(1008, 'Stale SDK token')
+        return
+      }
       const payload = typeof rawMessage === 'string' ? rawMessage : rawMessage.toString()
-      conversationService.handleSdkPayload(ws.data.sessionId, payload)
+      conversationService.handleSdkPayload(sessionId, payload, {
+        canAcceptPermissionRequest: (message) =>
+          canAcceptPermissionRequestDuringStop(sessionId, message),
+      })
       return
     }
 
@@ -471,7 +664,10 @@ export const handleWebSocket = {
             // A queued/newer turn may have replaced this handler while an
             // earlier await was pending. Only the handler that still owns the
             // active-turn token may terminate the desktop state.
-            if (activeUserTurns.get(sessionId) === activeTurn) {
+            if (
+              activeUserTurns.get(sessionId) === activeTurn &&
+              !activeTurn.cancelled
+            ) {
               failSessionChatActivity(sessionId)
               clearActiveUserTurn(sessionId, activeTurn)
               const titleState = sessionTitleState.get(sessionId)
@@ -511,9 +707,7 @@ export const handleWebSocket = {
         case 'sync_state':
           sendMessage(ws, {
             type: 'session_state',
-            turnState:
-              hasPendingOrActiveUserTurn(ws.data.sessionId) &&
-              !sessionStopRequested.has(ws.data.sessionId)
+            turnState: hasLiveUserTurnForClient(ws.data.sessionId)
               ? 'running'
               : 'idle',
           })
@@ -613,18 +807,27 @@ async function handleUserMessage(
     return
   }
 
-  // A validated replacement turn supersedes any stopped-turn output fence.
-  sessionStopRequested.delete(sessionId)
+  // Keep a stopped-turn fence until the replacement replay proves that later
+  // output belongs to this turn, while allowing validated input to start its
+  // own activity lifecycle.
   beginSessionChatActivity(sessionId)
   clearPrewarmState(sessionId)
 
   // Send thinking status
   sendMessage(ws, { type: 'status', state: 'thinking', verb: 'Thinking' })
 
+  activeTurn.expectedReplayUuid = crypto.randomUUID()
+  activeTurn.expectedLocalCommand = desktopSlashCommand ?? undefined
+  activeTurn.replacementAfterStop =
+    sessionStopRequested.has(sessionId) || agentStopRequestedSessions.has(sessionId)
   activeUserTurns.set(sessionId, activeTurn)
 
   const initialRuntimeTransition = await waitForRuntimeTransitionBeforeUserTurn(ws, sessionId)
-  if (!initialRuntimeTransition.ok) {
+  if (
+    !initialRuntimeTransition.ok ||
+    activeUserTurns.get(sessionId) !== activeTurn ||
+    activeTurn.cancelled
+  ) {
     clearActiveUserTurn(sessionId, activeTurn)
     return
   }
@@ -635,9 +838,11 @@ async function handleUserMessage(
   // Track and emit the first placeholder title before CLI startup/streaming.
   let titleState = sessionTitleState.get(sessionId)
   if (!titleState) {
+    const hasCustomTitle = !!(await sessionService.getCustomTitle(sessionId))
+    if (activeUserTurns.get(sessionId) !== activeTurn || activeTurn.cancelled) return
     titleState = {
       userMessageCount: 0,
-      hasCustomTitle: !!(await sessionService.getCustomTitle(sessionId)),
+      hasCustomTitle,
       firstUserMessage: '',
       completedTurns: [],
       startedGenerationKeys: new Set<string>(),
@@ -665,13 +870,16 @@ async function handleUserMessage(
   try {
     await ensureCliSessionStarted(ws, sessionId, 'user_message')
   } catch (err) {
+    if (activeUserTurns.get(sessionId) !== activeTurn || activeTurn.cancelled) return
     const errMsg = err instanceof Error ? err.message : String(err)
     const code =
       err instanceof ConversationStartupError ? err.code : 'CLI_START_FAILED'
     console.error(`[WS] CLI start failed for ${sessionId}: ${errMsg}`)
+    const diagnosticMessage = await buildSessionStartupDiagnosticMessage(sessionId, errMsg)
+    if (activeUserTurns.get(sessionId) !== activeTurn || activeTurn.cancelled) return
     sendMessage(ws, {
       type: 'error',
-      message: await buildSessionStartupDiagnosticMessage(sessionId, errMsg),
+      message: diagnosticMessage,
       code,
       retryable:
         err instanceof ConversationStartupError ? err.retryable : false,
@@ -682,8 +890,17 @@ async function handleUserMessage(
     return
   }
 
+  if (activeUserTurns.get(sessionId) !== activeTurn || activeTurn.cancelled) {
+    stopRuntimeStartedByCancelledAdmission(sessionId, activeTurn)
+    return
+  }
+
   const startupRuntimeTransition = await waitForRuntimeTransitionBeforeUserTurn(ws, sessionId)
-  if (startupRuntimeTransition.ok) {
+  if (
+    startupRuntimeTransition.ok &&
+    activeUserTurns.get(sessionId) === activeTurn &&
+    !activeTurn.cancelled
+  ) {
     if (startupRuntimeTransition.waited) {
       sendMessage(ws, { type: 'status', state: 'thinking', verb: 'Thinking' })
     }
@@ -700,7 +917,7 @@ async function handleUserMessage(
     createCurrentTurnLocalCommandForwarder(desktopSlashCommand)
   const removeTitleOutputCallback = titleTurnNumber === null
     ? null
-    : bindTitleSessionOutput(ws, sessionId, () => userMessageSent)
+    : bindTitleSessionOutput(ws, sessionId, activeTurn, () => userMessageSent)
 
   bindAllClientSessionOutputs(sessionId, {
     shouldForward: (cliMsg) => {
@@ -719,11 +936,33 @@ async function handleUserMessage(
   // permission request that arrives after the disconnect.
   refreshDisconnectedTurnCleanupWatcher(sessionId)
 
+  activeTurn.sendStarted = true
   const sent = await conversationService.sendMessage(
     sessionId,
     message.content,
-    message.attachments
+    message.attachments,
+    {
+      canSend: () =>
+        activeUserTurns.get(sessionId) === activeTurn && !activeTurn.cancelled,
+      messageUuid: activeTurn.expectedReplayUuid,
+      onCommitted: () => {
+        activeTurn.messageSent = true
+      },
+    },
   )
+  if (activeUserTurns.get(sessionId) !== activeTurn || activeTurn.cancelled) {
+    // Once onCommitted has run the SDK owns this turn and will still emit its
+    // terminal result. Keep the completion callback long enough to consume
+    // that boundary; only an admission revoked before the socket write is safe
+    // to detach immediately.
+    if (!activeTurn.messageSent) removeActiveTurnOutputCallback()
+    removeTitleOutputCallback?.()
+    discardActiveTitleTurn(sessionId, titleTurnNumber)
+    if (!activeTurn.messageSent) {
+      stopRuntimeStartedByCancelledAdmission(sessionId, activeTurn)
+    }
+    return
+  }
   if (!sent) {
     removeActiveTurnOutputCallback()
     clearActiveUserTurn(sessionId, activeTurn)
@@ -749,12 +988,137 @@ function clearActiveUserTurn(sessionId: string, activeTurn: ActiveUserTurnState)
   }
 }
 
+function matchesActiveTurnReplay(activeTurn: ActiveUserTurnState, cliMsg: any): boolean {
+  return cliMsg?.type === 'user' &&
+    cliMsg.isReplay === true &&
+    typeof cliMsg.uuid === 'string' &&
+    cliMsg.uuid === activeTurn.expectedReplayUuid
+}
+
+function matchesActiveTurnLocalCommand(
+  activeTurn: ActiveUserTurnState,
+  cliMsg: any,
+): boolean {
+  return Boolean(
+    activeTurn.expectedLocalCommand &&
+    isMatchingCurrentTurnLocalCommand(cliMsg, activeTurn.expectedLocalCommand),
+  )
+}
+
+function addPendingInterruptedTurnResult(sessionId: string): void {
+  pendingInterruptedTurnResults.set(
+    sessionId,
+    (pendingInterruptedTurnResults.get(sessionId) ?? 0) + 1,
+  )
+}
+
+function removePendingInterruptedTurnResult(sessionId: string): void {
+  const count = pendingInterruptedTurnResults.get(sessionId) ?? 0
+  if (count <= 1) {
+    pendingInterruptedTurnResults.delete(sessionId)
+    return
+  }
+  pendingInterruptedTurnResults.set(sessionId, count - 1)
+}
+
+function forceStopSharedRuntimeForAgentCancellation(sessionId: string): void {
+  // A killed runtime cannot emit the foreground turn's interrupted result.
+  // Remove that boundary before admitting a replacement (including a local
+  // slash command), otherwise its result can be consumed as the dead turn's.
+  pendingInterruptedTurnResults.delete(sessionId)
+  runtimeExitStoppedSessions.add(sessionId)
+  conversationService.stopSession(sessionId)
+  const stoppedTurn = activeUserTurns.get(sessionId)
+  if (
+    stoppedTurn?.cancelled &&
+    stoppedTurn.replacementAfterStop !== true
+  ) {
+    clearActiveUserTurn(sessionId, stoppedTurn)
+  }
+  void emitStoppedForNonAgentTasksAfterRuntimeExit(sessionId)
+}
+
+function consumeInterruptedTurnResult(sessionId: string, cliMsg: any): boolean {
+  if (!cliMsg || typeof cliMsg !== 'object' || cliMsg.type !== 'result') return false
+  if (interruptedTurnResultMessages.get(cliMsg) === sessionId) return true
+  if (!pendingInterruptedTurnResults.has(sessionId)) return false
+  removePendingInterruptedTurnResult(sessionId)
+  interruptedTurnResultMessages.set(cliMsg, sessionId)
+  return true
+}
+
+function acknowledgeActiveTurnReplay(sessionId: string, cliMsg: any): boolean {
+  const activeTurn = activeUserTurns.get(sessionId)
+  const replayMatches = activeTurn
+    ? matchesActiveTurnReplay(activeTurn, cliMsg)
+    : false
+  const localCommandMatches = activeTurn && !pendingInterruptedTurnResults.has(sessionId)
+    ? matchesActiveTurnLocalCommand(activeTurn, cliMsg)
+    : false
+  if (
+    !activeTurn ||
+    activeTurn.cancelled ||
+    activeTurn.replacementAfterStop !== true ||
+    activeTurn.sendStarted !== true ||
+    (!replayMatches && !localCommandMatches)
+  ) {
+    return false
+  }
+
+  // The SDK preserves the outbound user-message UUID on normal replays. Pure
+  // local slash commands instead expose their parsed command marker after the
+  // interrupted result boundary. Either signal proves output now belongs to
+  // this replacement turn.
+  activeTurn.replacementAfterStop = false
+  activeTurn.messageSent = true
+  pendingInterruptedTurnResults.delete(sessionId)
+  sessionStopRequested.delete(sessionId)
+  agentStopRequestedSessions.delete(sessionId)
+  runtimeExitStoppedSessions.delete(sessionId)
+  return true
+}
+
+function stopRuntimeStartedByCancelledAdmission(
+  sessionId: string,
+  activeTurn: ActiveUserTurnState,
+): void {
+  if (
+    activeTurn.cancelled &&
+    !activeUserTurns.has(sessionId) &&
+    conversationService.hasSession(sessionId)
+  ) {
+    conversationService.stopSession(sessionId)
+  }
+}
+
 function bindActiveUserTurnCompletion(
   ws: ServerWebSocket<WebSocketData>,
   sessionId: string,
   activeTurn: ActiveUserTurnState,
 ): () => void {
   const callback = (cliMsg: any) => {
+    const interruptedResult = consumeInterruptedTurnResult(sessionId, cliMsg)
+    if (activeTurn.cancelled) {
+      if (cliMsg?.type === 'result') {
+        const stillOwnsTurn = activeUserTurns.get(sessionId) === activeTurn
+        if (
+          stillOwnsTurn &&
+          interruptedResult &&
+          pendingInterruptedTurnResults.has(sessionId)
+        ) {
+          return
+        }
+        conversationService.removeOutputCallback(sessionId, callback)
+        if (stillOwnsTurn) {
+          settleSessionChatActivity(sessionId, cliMsg)
+          clearActiveUserTurn(sessionId, activeTurn)
+        }
+      }
+      return
+    }
+
+    acknowledgeActiveTurnReplay(sessionId, cliMsg)
+    if (activeTurn.replacementAfterStop || interruptedResult) return
     if (
       cliMsg?.type !== 'result' ||
       (!activeTurn.messageSent && !cliMsg.is_error)
@@ -819,6 +1183,17 @@ function applyDeferredRuntimeRestartAfterActiveTurn(
 
 async function handleDesktopClearCommand(
   ws: ServerWebSocket<WebSocketData>,
+) {
+  const turnToCancel = activeUserTurns.get(ws.data.sessionId)
+  if (turnToCancel) turnToCancel.cancelled = true
+  await enqueueRuntimeTransition(ws.data.sessionId, () =>
+    performDesktopClearCommand(ws, turnToCancel),
+  )
+}
+
+async function performDesktopClearCommand(
+  ws: ServerWebSocket<WebSocketData>,
+  turnToCancel: ActiveUserTurnState | undefined,
 ) {
   const { sessionId } = ws.data
 
@@ -826,34 +1201,81 @@ async function handleDesktopClearCommand(
   const permissionMode = conversationService.hasSession(sessionId)
     ? conversationService.getSessionPermissionMode(sessionId)
     : undefined
+  const agentTasks = [...(activeAgentTasks.get(sessionId)?.values() ?? [])]
+  markActiveAgentsStopping(sessionId)
+  sessionClearInProgress.add(sessionId)
+  if (turnToCancel) clearActiveUserTurn(sessionId, turnToCancel)
+  const activeTitleState = sessionTitleState.get(sessionId)
+  if (activeTitleState) activeTitleState.activeTurn = undefined
+  const pendingStartup = sessionStartupPromises.get(sessionId)
   conversationService.stopSession(sessionId)
+  pendingInterruptedTurnResults.delete(sessionId)
+  // Clearing replaces the transcript, so do not enqueue terminal bookends that
+  // could finish after the replacement write and repopulate the cleared file.
+  // Detach callbacks before clearing, then archive the captured remote handles
+  // on an independent bounded retry path after the transcript replacement.
   conversationService.clearOutputCallbacks(sessionId)
-  sessionSlashCommands.delete(sessionId)
-  sessionTitleState.delete(sessionId)
-  cleanupStreamState(sessionId)
+  clearPrewarmState(sessionId)
+
+  if (pendingStartup) {
+    await pendingStartup.catch(() => undefined)
+    // The startup may have created a runtime after the first stopSession call.
+    // Keep the clear transition locked until that stale admission is drained.
+    conversationService.stopSession(sessionId)
+    conversationService.clearOutputCallbacks(sessionId)
+    clearPrewarmState(sessionId)
+  }
 
   try {
     await sessionService.clearSessionTranscript(sessionId, workDir || undefined, permissionMode)
   } catch (err) {
+    sessionClearInProgress.delete(sessionId)
+    resumeAgentFinalizationAfterFailedClear(sessionId, agentTasks)
+    runtimeExitStoppedSessions.add(sessionId)
+    await emitStoppedForNonAgentTasksAfterRuntimeExit(sessionId)
     const errMsg = err instanceof Error ? err.message : String(err)
-    sendMessage(ws, {
+    sendToSession(sessionId, {
       type: 'error',
       message: errMsg,
       code: 'SESSION_CLEAR_FAILED',
     })
-    sendMessage(ws, { type: 'status', state: 'idle' })
+    sendToSession(sessionId, { type: 'status', state: 'idle' })
     return
   }
 
-  sendMessage(ws, {
+  sessionTranscriptEpochs.set(
+    sessionId,
+    (sessionTranscriptEpochs.get(sessionId) ?? 0) + 1,
+  )
+
+  clearAgentRuntimeState(sessionId)
+  taskNotificationPersistence.delete(sessionId)
+  sessionSlashCommands.delete(sessionId)
+  sessionTitleState.delete(sessionId)
+  cleanupStreamState(sessionId)
+  sessionClearInProgress.delete(sessionId)
+
+  sendToSession(sessionId, {
     type: 'system_notification',
     subtype: 'session_cleared',
     message: 'Conversation cleared',
   })
-  sendMessage(ws, {
+  sendToSession(sessionId, {
     type: 'message_complete',
     usage: { input_tokens: 0, output_tokens: 0 },
   })
+  void stopAgentsForSessionClear(sessionId, agentTasks).then((agentStopResults) => {
+    agentStopResults.forEach((stopped, index) => {
+      if (stopped) return
+      const task = agentTasks[index]
+      if (!task) return
+      sendToSession(sessionId, {
+        type: 'background_task_stop_failed',
+        taskId: task.taskId,
+        message: 'Conversation cleared, but one or more background Agents could not be fully stopped.',
+      })
+    })
+  })
 }
 
 async function handlePrewarmSession(ws: ServerWebSocket<WebSocketData>) {
@@ -1144,7 +1566,11 @@ async function restartSessionWithPermissionMode(
 ): Promise<void> {
   try {
     const workDir = conversationService.getSessionWorkDir(sessionId)
+    markActiveAgentsStopping(sessionId)
+    runtimeExitStoppedSessions.add(sessionId)
     conversationService.stopSession(sessionId)
+    await emitAuthoritativeStoppedForActiveAgents(sessionId)
+    await emitStoppedForNonAgentTasksAfterRuntimeExit(sessionId)
 
     // Launch with the requested mode in-memory. Persist it only after startup
     // succeeds so a failed bypass restart cannot leave dangerous metadata.
@@ -1154,6 +1580,9 @@ async function restartSessionWithPermissionMode(
     }
     const sdkUrl = buildSdkWebSocketUrl(ws, sessionId)
     await conversationService.startSession(sessionId, workDir, sdkUrl, runtimeSettings)
+    if (!agentStopRequestedSessions.has(sessionId)) {
+      runtimeExitStoppedSessions.delete(sessionId)
+    }
 
     await commitConfirmedPermissionMode(sessionId, mode, workDir)
     sendToSession(sessionId, { type: 'status', state: 'idle' })
@@ -1236,11 +1665,16 @@ async function restartSessionWithRuntimeConfig(
 ): Promise<void> {
   try {
     const workDir = conversationService.getSessionWorkDir(sessionId)
+    markActiveAgentsStopping(sessionId)
+    runtimeExitStoppedSessions.add(sessionId)
     conversationService.stopSession(sessionId)
+    await emitAuthoritativeStoppedForActiveAgents(sessionId)
+    await emitStoppedForNonAgentTasksAfterRuntimeExit(sessionId)
 
     const runtimeSettings = await getRuntimeSettings(sessionId)
     const sdkUrl = buildSdkWebSocketUrl(ws, sessionId)
     await conversationService.startSession(sessionId, workDir, sdkUrl, runtimeSettings)
+    runtimeExitStoppedSessions.delete(sessionId)
 
     sendMessage(ws, { type: 'status', state: 'idle' })
     console.log(`[WS] Restarted CLI for ${sessionId} with runtime override`)
@@ -1269,26 +1703,93 @@ async function restartSessionWithRuntimeConfig(
 function handleStopGeneration(ws: ServerWebSocket<WebSocketData>) {
   const { sessionId } = ws.data
   const stoppedTurn = activeUserTurns.get(sessionId)
+  const agentTasks = [...(activeAgentTasks.get(sessionId)?.values() ?? [])]
   console.log(`[WS] Stop generation requested for session: ${sessionId}`)
 
-  sessionStopRequested.add(sessionId)
+  if (stoppedTurn) {
+    sessionStopRequested.add(sessionId)
+  }
+  if (stoppedTurn || agentTasks.length > 0) {
+    const computerUseRequestIds = computerUseApprovalService
+      .getPendingRequests(sessionId)
+      .map((request) => request.requestId)
+    computerUseApprovalService.cancelSession(sessionId)
+    for (const requestId of computerUseRequestIds) {
+      sendToSession(sessionId, {
+        type: 'permission_resolved',
+        requestId,
+        permissionType: 'computer_use',
+        allowed: false,
+      })
+    }
+  }
+  agentStopRequestedSessions.add(sessionId)
   legacyQueuedSessionChats.delete(sessionId)
   terminalSessionChatStates.delete(sessionId)
   interruptedSessionChats.add(sessionId)
 
-  if (stoppedTurn && conversationService.hasSession(sessionId)) {
-    // First try graceful interrupt via SDK control message
-    conversationService.sendInterrupt(sessionId)
+  // A turn can be registered while title metadata, CLI startup, or the send
+  // acknowledgement is still pending. Revoke that admission token so the
+  // suspended handler cannot resume after Stop and enqueue work (or clear the
+  // Agent stop latch) behind the user's explicit cancellation.
+  if (stoppedTurn && !stoppedTurn.messageSent) {
+    stoppedTurn.cancelled = true
+    stoppedTurn.replacementAfterStop = false
+    clearActiveUserTurn(sessionId, stoppedTurn)
+  } else if (stoppedTurn) {
+    stoppedTurn.cancelled = true
+    stoppedTurn.replacementAfterStop = false
+  }
 
+  void Promise.allSettled(
+    agentTasks.map((task) => requestStopTrackedAgentTask(sessionId, task, ws)),
+  )
+
+  if (
+    stoppedTurn &&
+    conversationService.hasSession(sessionId) &&
+    (!stoppedTurn.messageSent || !stoppedTurn.interruptBoundaryPending)
+  ) {
+    // First try graceful interrupt via SDK control message
+    if (stoppedTurn.messageSent) addPendingInterruptedTurnResult(sessionId)
+    const interruptSent = conversationService.sendInterrupt(sessionId)
+    if (stoppedTurn.messageSent) {
+      if (interruptSent) {
+        stoppedTurn.interruptBoundaryPending = true
+      } else {
+        removePendingInterruptedTurnResult(sessionId)
+      }
+    }
+  }
+
+  if ((stoppedTurn || agentTasks.length > 0) && conversationService.hasSession(sessionId)) {
     // Force-kill if still running after 3 seconds
     setTimeout(() => {
+      const stoppedForegroundStillCurrent = Boolean(
+        stoppedTurn &&
+        stoppedTurn.cancelled &&
+        (
+          activeUserTurns.get(sessionId) === stoppedTurn ||
+          (
+            stoppedTurn.sendStarted === true &&
+            !stoppedTurn.messageSent &&
+            !activeUserTurns.has(sessionId)
+          )
+        ),
+      )
+      const stoppedAgentsStillActive =
+        agentStopRequestedSessions.has(sessionId) &&
+        activeUserTurns.get(sessionId)?.replacementAfterStop !== true &&
+        [...(activeAgentTasks.get(sessionId)?.values() ?? [])].some(
+          (task) => !task.localStopConfirmed,
+        )
       if (
-        sessionStopRequested.has(sessionId) &&
-        activeUserTurns.get(sessionId) === stoppedTurn &&
+        (stoppedForegroundStillCurrent || stoppedAgentsStillActive) &&
         conversationService.hasSession(sessionId)
       ) {
         console.log(`[WS] Force-killing CLI subprocess for session: ${sessionId}`)
-        conversationService.stopSession(sessionId)
+        forceStopSharedRuntimeForAgentCancellation(sessionId)
+        void emitAuthoritativeStoppedForActiveAgents(sessionId)
       }
     }, 3_000)
   }
@@ -1312,20 +1813,500 @@ async function handleStopBackgroundTask(
     return
   }
 
+  await requestStopBackgroundTask(ws, taskId)
+}
+
+async function requestStopBackgroundTask(
+  ws: ServerWebSocket<WebSocketData>,
+  taskId: string,
+): Promise<void> {
+  const { sessionId } = ws.data
+  const trackedAgent = activeAgentTasks.get(sessionId)?.get(taskId)
+  if (trackedAgent) {
+    await requestStopTrackedAgentTask(sessionId, trackedAgent, ws)
+    return
+  }
+
   try {
     await conversationService.requestControl(sessionId, {
       subtype: 'stop_task',
       task_id: taskId,
     })
   } catch (error) {
+    reportBackgroundTaskStopFailure(sessionId, ws, taskId, error)
+  }
+}
+
+const AGENT_STOP_CONTROL_TIMEOUT_MS = 3_000
+const AUTHORITATIVE_STOP_PERSIST_ATTEMPTS = 3
+const AUTHORITATIVE_STOP_PERSIST_TIMEOUT_MS = 1_000
+const AGENT_STOP_FINALIZATION_RETRY_DELAYS_MS = [250, 500] as const
+
+async function requestStopTrackedAgentTask(
+  sessionId: string,
+  task: ActiveAgentTaskState,
+  ws?: ServerWebSocket<WebSocketData>,
+): Promise<void> {
+  const current = activeAgentTasks.get(sessionId)?.get(task.taskId)
+  if (!current) return
+  current.stopIntent = true
+  if (current.stopRequested) {
+    if (!conversationService.hasSession(sessionId)) {
+      current.localStopConfirmed = true
+      await emitAuthoritativeAgentStopped(sessionId, current, ws)
+    }
+    return
+  }
+
+  clearAgentStopFinalizationRetry(current)
+  current.finalizationRetryCount = 0
+  current.stopFailureMessage = undefined
+  current.stopRequested = true
+  if (current.localStopConfirmed) {
+    await emitAuthoritativeAgentStopped(sessionId, current, ws)
+    return
+  }
+
+  // Start strict remote cancellation immediately instead of waiting for the
+  // CLI control channel. The CLI stop closes the local poller; the archive
+  // result remains the authority for whether a remote Agent is terminal.
+  const remoteArchiveAttempt = current.taskType === 'remote_agent'
+    ? ensureRemoteAgentArchive(sessionId, current)
+    : undefined
+
+  if (!conversationService.hasSession(sessionId)) {
+    current.localStopConfirmed = true
+    await emitAuthoritativeAgentStopped(sessionId, current, ws)
+    return
+  }
+
+  let controlError: unknown
+  try {
+    await conversationService.requestControl(sessionId, {
+      subtype: 'stop_task',
+      task_id: current.taskId,
+    }, AGENT_STOP_CONTROL_TIMEOUT_MS)
+  } catch (error) {
+    controlError = error
+  }
+
+  const latest = activeAgentTasks.get(sessionId)?.get(current.taskId)
+  if (latest !== current) return
+  if (controlError === undefined || !conversationService.hasSession(sessionId)) {
+    current.localStopConfirmed = true
+  }
+
+  if (current.taskType === 'remote_agent') {
+    // A force-kill or a newer retry may have replaced this archive attempt.
+    if (current.remoteArchive !== remoteArchiveAttempt) return
+    const finalized = await emitAuthoritativeAgentStopped(sessionId, current, ws)
+    if (
+      !finalized &&
+      !current.localStopConfirmed &&
+      shouldForceStopLatchedAgent(sessionId) &&
+      activeAgentTasks.get(sessionId)?.get(current.taskId) === current &&
+      conversationService.hasSession(sessionId)
+    ) {
+      forceStopSharedRuntimeForAgentCancellation(sessionId)
+      current.localStopConfirmed = true
+    }
+    return
+  }
+
+  if (current.localStopConfirmed) {
+    await emitAuthoritativeAgentStopped(sessionId, current, ws)
+    return
+  }
+
+  if (
+    shouldForceStopLatchedAgent(sessionId) &&
+    conversationService.hasSession(sessionId)
+  ) {
+    forceStopSharedRuntimeForAgentCancellation(sessionId)
+    current.localStopConfirmed = true
+    await emitAuthoritativeAgentStopped(sessionId, current, ws)
+    return
+  }
+
+  current.stopRequested = false
+  reportAgentStopFailure(sessionId, ws, current, controlError)
+}
+
+function shouldForceStopLatchedAgent(sessionId: string): boolean {
+  return agentStopRequestedSessions.has(sessionId) &&
+    activeUserTurns.get(sessionId)?.replacementAfterStop !== true
+}
+
+function ensureRemoteAgentArchive(
+  sessionId: string,
+  task: ActiveAgentTaskState,
+): Promise<boolean> {
+  if (task.taskType !== 'remote_agent') return Promise.resolve(true)
+  if (task.remoteArchive) return task.remoteArchive
+  if (!task.remoteSessionId) {
+    task.remoteArchiveError = 'Remote session id is missing'
+    console.warn(`[WS] Cannot archive remote Agent ${task.taskId} for ${sessionId}: ${task.remoteArchiveError}`)
+    task.remoteArchive = Promise.resolve(false)
+    return task.remoteArchive
+  }
+
+  task.remoteArchiveError = undefined
+  task.remoteArchive = archiveRemoteSession(task.remoteSessionId, { timeoutMs: 1_500 })
+    .then(() => true)
+    .catch((error) => {
+      task.remoteArchiveError = error instanceof Error ? error.message : String(error)
+      console.warn(
+        `[WS] Failed to archive remote Agent ${task.taskId} for ${sessionId}: ${task.remoteArchiveError}`,
+      )
+      return false
+    })
+  return task.remoteArchive
+}
+
+function reportBackgroundTaskStopFailure(
+  sessionId: string,
+  ws: ServerWebSocket<WebSocketData> | undefined,
+  taskId: string,
+  error: unknown,
+): void {
+  const message = error instanceof Error ? error.message : String(error)
+  console.warn(
+    `[WS] Failed to stop background task ${taskId} for ${sessionId}: ${message}`,
+  )
+  const payload: ServerMessage = {
+    type: 'background_task_stop_failed',
+    taskId,
+    message,
+  }
+  if (ws && activeSessions.get(sessionId)?.has(ws)) {
+    sendMessage(ws, payload)
+    return
+  }
+  for (const client of activeSessions.get(sessionId) ?? []) {
+    sendMessage(client, payload)
+  }
+}
+
+function reportAgentStopFailure(
+  sessionId: string,
+  _ws: ServerWebSocket<WebSocketData> | undefined,
+  task: ActiveAgentTaskState,
+  error: unknown,
+): void {
+  task.stopFailureMessage = error instanceof Error ? error.message : String(error)
+  // Every renderer that issued a concurrent Stop has optimistic local state.
+  // Broadcast Agent failures session-wide so no secondary view remains stuck
+  // in Stopping while the first request owns the shared finalization attempt.
+  reportBackgroundTaskStopFailure(sessionId, undefined, task.taskId, error)
+}
+
+function replayAgentStopFailures(
+  ws: ServerWebSocket<WebSocketData>,
+  sessionId: string,
+): void {
+  for (const task of activeAgentTasks.get(sessionId)?.values() ?? []) {
+    if (!task.stopFailureMessage) continue
     sendMessage(ws, {
       type: 'background_task_stop_failed',
-      taskId,
-      message: error instanceof Error ? error.message : String(error),
+      taskId: task.taskId,
+      message: task.stopFailureMessage,
     })
   }
 }
 
+function clearAgentStopFinalizationRetry(task: ActiveAgentTaskState): void {
+  if (task.finalizationRetryTimer === undefined) return
+  clearTimeout(task.finalizationRetryTimer)
+  task.finalizationRetryTimer = undefined
+}
+
+function scheduleAgentStopFinalizationRetry(
+  sessionId: string,
+  task: ActiveAgentTaskState,
+): void {
+  if (!task.localStopConfirmed || task.finalizationRetryTimer !== undefined) return
+  const delayMs = AGENT_STOP_FINALIZATION_RETRY_DELAYS_MS[task.finalizationRetryCount]
+  if (delayMs !== undefined) {
+    task.finalizationRetryCount += 1
+    task.finalizationRetryTimer = setTimeout(() => {
+      task.finalizationRetryTimer = undefined
+      const current = activeAgentTasks.get(sessionId)?.get(task.taskId)
+      if (
+        current !== task ||
+        !current.stopIntent ||
+        !current.localStopConfirmed ||
+        current.bookendPending
+      ) {
+        return
+      }
+      current.stopFailureMessage = undefined
+      void emitAuthoritativeAgentStopped(sessionId, current)
+    }, delayMs)
+    if (typeof task.finalizationRetryTimer === 'object') {
+      task.finalizationRetryTimer.unref?.()
+    }
+  }
+  scheduleDisconnectedSessionCleanupIfIdle(sessionId)
+}
+
+function stopLateAgentTaskIfRequested(
+  sessionId: string,
+  lifecycle: CliBackgroundTaskLifecycle | null,
+): void {
+  if (
+    !lifecycle?.running ||
+    !isAgentTaskType(lifecycle.taskType) ||
+    !agentStopRequestedSessions.has(sessionId)
+  ) {
+    return
+  }
+  const task = activeAgentTasks.get(sessionId)?.get(lifecycle.taskId)
+  // The output callback that observes a late task is not necessarily the
+  // client that clicked Stop. Omit a socket so failures broadcast to every
+  // connected view and each renderer can clear its optimistic Stopping state.
+  if (task) void requestStopTrackedAgentTask(sessionId, task)
+}
+
+function closeLateNonAgentTaskAfterRuntimeExit(
+  sessionId: string,
+  lifecycle: CliBackgroundTaskLifecycle | null,
+): void {
+  if (
+    !lifecycle?.running ||
+    isAgentTaskType(lifecycle.taskType) ||
+    !runtimeExitStoppedSessions.has(sessionId)
+  ) {
+    return
+  }
+  void emitStoppedForNonAgentTasksAfterRuntimeExit(sessionId)
+}
+
+function emitAuthoritativeAgentStopped(
+  sessionId: string,
+  task: ActiveAgentTaskState,
+  ws?: ServerWebSocket<WebSocketData>,
+): Promise<boolean> {
+  const current = activeAgentTasks.get(sessionId)?.get(task.taskId)
+  if (!current) return Promise.resolve(false)
+  if (sessionClearInProgress.has(sessionId)) return Promise.resolve(false)
+  if (current.finalization) return current.finalization
+  if (current.bookendPending) return Promise.resolve(false)
+  current.bookendPending = true
+
+  const finalization = (async (): Promise<boolean> => {
+    const remoteArchiveAttempt = current.taskType === 'remote_agent'
+      ? ensureRemoteAgentArchive(sessionId, current)
+      : undefined
+    const stopConfirmed = remoteArchiveAttempt
+      ? await remoteArchiveAttempt
+      : true
+
+    if (activeAgentTasks.get(sessionId)?.get(current.taskId) !== current) return false
+    if (
+      remoteArchiveAttempt &&
+      current.remoteArchive !== remoteArchiveAttempt
+    ) {
+      current.bookendPending = false
+      return false
+    }
+
+    if (!stopConfirmed) {
+      current.bookendPending = false
+      current.stopRequested = false
+      current.remoteArchive = undefined
+      reportAgentStopFailure(
+        sessionId,
+        ws,
+        current,
+        new Error(current.remoteArchiveError ?? 'Remote Agent stop could not be confirmed'),
+      )
+      scheduleAgentStopFinalizationRetry(sessionId, current)
+      return false
+    }
+
+    if (current.taskType === 'remote_agent') {
+      current.localStopConfirmed = true
+    }
+
+    const cliMsg = {
+      type: 'system',
+      subtype: 'task_notification',
+      task_id: current.taskId,
+      tool_use_id: current.toolUseId,
+      task_type: current.taskType,
+      ...(current.description ? { description: current.description } : {}),
+      status: 'stopped',
+      summary: current.description
+        ? `${current.description} stopped`
+        : 'Background Agent stopped',
+      timestamp: new Date().toISOString(),
+    }
+
+    let persisted = false
+    for (let attempt = 0; attempt < AUTHORITATIVE_STOP_PERSIST_ATTEMPTS; attempt++) {
+      if (
+        sessionClearInProgress.has(sessionId) ||
+        activeAgentTasks.get(sessionId)?.get(current.taskId) !== current
+      ) {
+        current.bookendPending = false
+        return false
+      }
+      const persistence = persistCliTaskNotification(sessionId, cliMsg, {
+        propagateFailure: true,
+        timeoutMs: AUTHORITATIVE_STOP_PERSIST_TIMEOUT_MS,
+      })
+      if (!persistence) {
+        persisted = true
+        break
+      }
+      try {
+        await persistence
+        persisted = true
+        break
+      } catch {
+        // The persistence cache drops rejected writes, so the next bounded
+        // attempt performs a real retry rather than awaiting the same promise.
+      }
+    }
+
+    if (activeAgentTasks.get(sessionId)?.get(current.taskId) !== current) return false
+    if (!persisted) {
+      current.bookendPending = false
+      current.stopRequested = false
+      reportAgentStopFailure(
+        sessionId,
+        ws,
+        current,
+        new Error('Agent stopped, but its terminal state could not be saved'),
+      )
+      scheduleAgentStopFinalizationRetry(sessionId, current)
+      return false
+    }
+
+    current.stopFailureMessage = undefined
+    markTaskAuthoritativelyStopped(sessionId, current.taskId)
+    untrackCliBackgroundTask(sessionId, current.taskId)
+    forwardCliMessageToSessionClients(sessionId, cliMsg)
+    scheduleDisconnectedSessionCleanupIfIdle(sessionId)
+    return true
+  })().catch((error): boolean => {
+    if (activeAgentTasks.get(sessionId)?.get(current.taskId) !== current) return false
+    current.bookendPending = false
+    current.stopRequested = false
+    reportAgentStopFailure(sessionId, ws, current, error)
+    scheduleAgentStopFinalizationRetry(sessionId, current)
+    return false
+  })
+
+  current.finalization = finalization
+  void finalization.then(() => {
+    if (current.finalization === finalization) current.finalization = undefined
+  })
+  return finalization
+}
+
+function resumeAgentFinalizationAfterFailedClear(
+  sessionId: string,
+  tasks: ActiveAgentTaskState[],
+): void {
+  const pendingFinalizations = tasks.flatMap((task) =>
+    task.finalization ? [task.finalization] : [])
+  void Promise.allSettled(pendingFinalizations).then(() => {
+    for (const task of tasks) {
+      const current = activeAgentTasks.get(sessionId)?.get(task.taskId)
+      if (current !== task) continue
+      clearAgentStopFinalizationRetry(current)
+      current.stopIntent = true
+      current.stopRequested = true
+      current.localStopConfirmed = true
+      current.bookendPending = false
+      current.stopFailureMessage = undefined
+      void emitAuthoritativeAgentStopped(sessionId, current)
+    }
+  })
+}
+
+function emitAuthoritativeStoppedForActiveAgents(sessionId: string): Promise<boolean[]> {
+  const tasks = [...(activeAgentTasks.get(sessionId)?.values() ?? [])]
+  return Promise.all(tasks.map((task) => {
+    task.stopIntent = true
+    task.stopRequested = true
+    task.localStopConfirmed = true
+    return emitAuthoritativeAgentStopped(sessionId, task)
+  }))
+}
+
+function emitStoppedForNonAgentTasksAfterRuntimeExit(sessionId: string): Promise<void[]> {
+  const tasks = [...(activeNonAgentTasks.get(sessionId)?.values() ?? [])]
+  return Promise.all(tasks.map(async (task) => {
+    if (activeNonAgentTasks.get(sessionId)?.get(task.taskId) !== task) return
+    // Killing the shared CLI also terminates Bash/Dream/workflow work. Claim
+    // each task before awaiting persistence so concurrent force-stop paths
+    // cannot publish duplicate terminal bookends.
+    markTaskAuthoritativelyStopped(sessionId, task.taskId)
+    untrackCliBackgroundTask(sessionId, task.taskId)
+    const cliMsg = {
+      type: 'system',
+      subtype: 'task_notification',
+      task_id: task.taskId,
+      tool_use_id: task.toolUseId,
+      ...(task.taskType ? { task_type: task.taskType } : {}),
+      ...(task.description ? { description: task.description } : {}),
+      status: 'stopped',
+      summary: `${task.description ?? task.taskId} stopped because the runtime exited`,
+      timestamp: new Date().toISOString(),
+    }
+    await (persistCliTaskNotification(sessionId, cliMsg) ?? Promise.resolve())
+    forwardCliMessageToSessionClients(sessionId, cliMsg)
+  }))
+}
+
+async function stopAgentsForSessionClear(
+  sessionId: string,
+  tasks: ActiveAgentTaskState[],
+): Promise<boolean[]> {
+  return Promise.all(tasks.map(async (task) => {
+    if (task.taskType === 'local_agent') return true
+    if (!task.remoteSessionId) {
+      console.warn(
+        `[WS] Cannot archive remote Agent ${task.taskId} for ${sessionId}: Remote session id is missing`,
+      )
+      return false
+    }
+
+    for (let attempt = 0; attempt <= AGENT_STOP_FINALIZATION_RETRY_DELAYS_MS.length; attempt++) {
+      const archived = await ensureRemoteAgentArchive(sessionId, task)
+      if (archived) return true
+
+      task.remoteArchive = undefined
+      const retryDelayMs = AGENT_STOP_FINALIZATION_RETRY_DELAYS_MS[attempt]
+      if (retryDelayMs === undefined) break
+      await new Promise<void>((resolve) => setTimeout(resolve, retryDelayMs))
+    }
+    return false
+  }))
+}
+
+function markActiveAgentsStopping(sessionId: string): void {
+  for (const task of activeAgentTasks.get(sessionId)?.values() ?? []) {
+    task.stopIntent = true
+    task.stopRequested = true
+  }
+}
+
+function closeStoppedAgentsAfterRuntimeExit(sessionId: string, cliMsg: any): void {
+  if (
+    cliMsg?.type === 'result' &&
+    cliMsg.is_error &&
+    agentStopRequestedSessions.has(sessionId) &&
+    !conversationService.hasSession(sessionId)
+  ) {
+    runtimeExitStoppedSessions.add(sessionId)
+    void emitAuthoritativeStoppedForActiveAgents(sessionId)
+    void emitStoppedForNonAgentTasksAfterRuntimeExit(sessionId)
+  }
+}
+
 // ============================================================================
 // Title generation
 // ============================================================================
@@ -1433,9 +2414,29 @@ function sendSessionTitleUpdated(
 function bindTitleSessionOutput(
   ws: ServerWebSocket<WebSocketData>,
   sessionId: string,
+  activeTurn: ActiveUserTurnState,
   shouldProcess: () => boolean,
 ): () => void {
   const callback = (cliMsg: any) => {
+    const interruptedResult = consumeInterruptedTurnResult(sessionId, cliMsg)
+    acknowledgeActiveTurnReplay(sessionId, cliMsg)
+    if (
+      activeUserTurns.get(sessionId) !== activeTurn ||
+      activeTurn.cancelled
+    ) {
+      if (cliMsg?.type === 'result') {
+        const stillOwnsTurn = activeUserTurns.get(sessionId) === activeTurn
+        if (
+          !stillOwnsTurn ||
+          !interruptedResult ||
+          !pendingInterruptedTurnResults.has(sessionId)
+        ) {
+          conversationService.removeOutputCallback(sessionId, callback)
+        }
+      }
+      return
+    }
+    if (activeTurn.replacementAfterStop || interruptedResult) return
     if (!shouldProcess() && !(cliMsg?.type === 'result' && cliMsg?.is_error)) {
       return
     }
@@ -1614,15 +2615,21 @@ function cleanupStreamState(sessionId: string) {
   sessionStreamStates.delete(sessionId)
 }
 
-function cleanupSessionRuntimeState(sessionId: string) {
+function cleanupSessionRuntimeState(
+  sessionId: string,
+  options?: { preserveRetryableAgentStops?: boolean },
+) {
   cancelSessionDisconnectWatcher(sessionId)
+  clearAgentRuntimeState(sessionId, {
+    preserveRetryableStops: options?.preserveRetryableAgentStops,
+  })
   cleanupStreamState(sessionId)
   sessionSlashCommands.delete(sessionId)
   sessionTitleState.delete(sessionId)
   runtimeOverrides.delete(sessionId)
   activeUserTurns.delete(sessionId)
   sessionStopRequested.delete(sessionId)
-  activeBackgroundTaskIds.delete(sessionId)
+  pendingInterruptedTurnResults.delete(sessionId)
   terminalSessionChatStates.delete(sessionId)
   legacyQueuedSessionChats.delete(sessionId)
   interruptedSessionChats.delete(sessionId)
@@ -1811,6 +2818,7 @@ async function ensureCliSessionStarted(
     await sendRepositoryStartupStatus(ws, sessionId, reason)
     console.log(`[WS] Starting CLI for ${sessionId} due to ${reason}`)
     await conversationService.startSession(sessionId, workDir, sdkUrl, startupSettings)
+    runtimeExitStoppedSessions.delete(sessionId)
   })()
 
   sessionStartupPromises.set(sessionId, startup)
@@ -2144,7 +3152,10 @@ export function translateCliMessage(cliMsg: any, sessionId: string): ServerMessa
       if (cliMsg.is_error) {
         // If the user requested stop, this "error" is just the interrupt
         // result — don't show it as an error in the chat UI.
-        if (sessionStopRequested.has(sessionId)) {
+        if (
+          interruptedTurnResultMessages.get(cliMsg) === sessionId ||
+          sessionStopRequested.has(sessionId)
+        ) {
           return [{ type: 'message_complete', usage }]
         }
 
@@ -2290,8 +3301,17 @@ export function translateCliMessage(cliMsg: any, sessionId: string): ServerMessa
           data: cliMsg,
         }
         // AutoDream is detached maintenance work. Keep it visible in Activity,
-        // but do not revive the already-completed foreground turn.
-        if (cliMsg.task_type === 'dream') return [notification]
+        // but do not revive the already-completed foreground turn. A late Agent
+        // spawned after Stop is also visible until its stop bookend arrives.
+        // The same applies to independent non-Agent task lifecycle after Stop:
+        // Activity still needs the event, but chat must remain idle.
+        if (
+          cliMsg.task_type === 'dream' ||
+          sessionStopRequested.has(sessionId) ||
+          agentStopRequestedSessions.has(sessionId)
+        ) {
+          return [notification]
+        }
         return [
           notification,
           {
@@ -2479,6 +3499,11 @@ function hasPendingOrActiveUserTurn(sessionId: string): boolean {
   return activeUserTurns.has(sessionId)
 }
 
+function hasLiveUserTurnForClient(sessionId: string): boolean {
+  const activeTurn = activeUserTurns.get(sessionId)
+  return Boolean(activeTurn && !activeTurn.cancelled)
+}
+
 /**
  * Start the idle grace timer for a disconnected, idle session. If no client
  * reconnects before it fires, the CLI subprocess is stopped.
@@ -2507,11 +3532,25 @@ function scheduleDisconnectCleanup(sessionId: string): void {
 
     console.log(`[WS] Session ${sessionId} not reconnected after ${cleanupDelayMs}ms, stopping CLI subprocess`)
     conversationService.stopSession(sessionId)
-    cleanupSessionRuntimeState(sessionId)
+    cleanupSessionRuntimeState(sessionId, { preserveRetryableAgentStops: true })
   }, cleanupDelayMs)
   sessionCleanupTimers.set(sessionId, cleanupTimer)
 }
 
+function scheduleDisconnectedSessionCleanupIfIdle(sessionId: string): void {
+  if (
+    hasActiveClients(sessionId) ||
+    hasPendingOrActiveUserTurn(sessionId) ||
+    hasActiveBackgroundTasks(sessionId)
+  ) {
+    return
+  }
+
+  cancelSessionDisconnectWatcher(sessionId)
+  scheduleDisconnectCleanup(sessionId)
+  watchTurnCompletionForCleanup(sessionId)
+}
+
 /**
  * Keep a session with active foreground/background work alive after the last
  * client leaves, and start the idle grace timer only once all work completes
@@ -2522,6 +3561,9 @@ function watchTurnCompletionForCleanup(sessionId: string): void {
 
   const onComplete = (cliMsg: any) => {
     const taskLifecycle = trackCliBackgroundTaskLifecycle(sessionId, cliMsg)
+    stopLateAgentTaskIfRequested(sessionId, taskLifecycle)
+    closeLateNonAgentTaskAfterRuntimeExit(sessionId, taskLifecycle)
+    closeStoppedAgentsAfterRuntimeExit(sessionId, cliMsg)
     if (taskLifecycle?.running && !hasActiveClients(sessionId)) {
       // A pending permission uses a hard 30-minute disconnect bound. A late
       // background task may outlive (or never emit) its terminal notification,
@@ -2946,9 +3988,33 @@ function normalizeCliTaskNotification(cliMsg: any): SessionTaskNotification | nu
   }
 }
 
+function boundTaskNotificationPersistence(
+  persistence: Promise<void>,
+  timeoutMs: number,
+): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`Timed out saving task notification after ${timeoutMs}ms`))
+    }, timeoutMs)
+    if (typeof timer === 'object') timer.unref?.()
+
+    persistence.then(
+      () => {
+        clearTimeout(timer)
+        resolve()
+      },
+      (error) => {
+        clearTimeout(timer)
+        reject(error)
+      },
+    )
+  })
+}
+
 function persistCliTaskNotification(
   sessionId: string,
   cliMsg: any,
+  options?: { propagateFailure?: boolean; timeoutMs?: number },
 ): Promise<void> | null {
   const notification = normalizeCliTaskNotification(cliMsg)
   if (!notification) return null
@@ -2964,7 +4030,11 @@ function persistCliTaskNotification(
   const existing = sessionWrites.get(eventKey)
   if (existing) return existing
 
-  const write = sessionService.appendSessionTaskNotification(sessionId, notification)
+  const persistence = sessionService.appendSessionTaskNotification(sessionId, notification)
+  const boundedPersistence = options?.timeoutMs === undefined
+    ? persistence
+    : boundTaskNotificationPersistence(persistence, options.timeoutMs)
+  const write = boundedPersistence
     .catch((error) => {
       sessionWrites?.delete(eventKey)
       console.warn(
@@ -2972,6 +4042,7 @@ function persistCliTaskNotification(
           error instanceof Error ? error.message : String(error)
         }`,
       )
+      if (options?.propagateFailure) throw error
     })
   sessionWrites.set(eventKey, write)
   return write
@@ -2979,6 +4050,48 @@ function persistCliTaskNotification(
 
 export const __persistCliTaskNotificationForTests = persistCliTaskNotification
 
+function persistThenForwardCliMessage(
+  sessionId: string,
+  cliMsg: any,
+  forward: () => void,
+): void {
+  const persistence = persistCliTaskNotification(sessionId, cliMsg)
+  if (!persistence) {
+    forward()
+    return
+  }
+
+  void persistence
+    .then(forward)
+    .catch((error) => {
+      console.warn(
+        `[WS] Failed to forward persisted task notification for ${sessionId}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      )
+    })
+}
+
+function forwardCliMessageToClient(
+  sessionId: string,
+  ws: ServerWebSocket<WebSocketData>,
+  cliMsg: any,
+): void {
+  handleCliPermissionModeBroadcast(sessionId, cliMsg)
+  const serverMsgs = translateCliMessage(cliMsg, sessionId)
+  for (const msg of serverMsgs) sendMessage(ws, msg)
+}
+
+function forwardCliMessageToSessionClients(sessionId: string, cliMsg: any): void {
+  const clients = activeSessions.get(sessionId)
+  if (!clients || clients.size === 0) return
+  handleCliPermissionModeBroadcast(sessionId, cliMsg)
+  const serverMsgs = translateCliMessage(cliMsg, sessionId)
+  for (const ws of clients) {
+    for (const msg of serverMsgs) sendMessage(ws, msg)
+  }
+}
+
 function bindAllClientSessionOutputs(
   sessionId: string,
   options?: {
@@ -3004,7 +4117,32 @@ function bindClientSessionOutput(
   removeClientOutputCallback(ws)
 
   const callback = (cliMsg: any) => {
-    trackCliBackgroundTaskLifecycle(sessionId, cliMsg)
+    consumeInterruptedTurnResult(sessionId, cliMsg)
+    acknowledgeActiveTurnReplay(sessionId, cliMsg)
+    const transcriptEpoch = sessionTranscriptEpochs.get(sessionId) ?? 0
+    const taskLifecycle = trackCliBackgroundTaskLifecycle(sessionId, cliMsg)
+    stopLateAgentTaskIfRequested(sessionId, taskLifecycle)
+    closeLateNonAgentTaskAfterRuntimeExit(sessionId, taskLifecycle)
+    closeStoppedAgentsAfterRuntimeExit(sessionId, cliMsg)
+    if (taskLifecycle?.suppressForward) return
+    const replacementAwaitingBoundary =
+      activeUserTurns.get(sessionId)?.replacementAfterStop === true
+    const stoppedTurnTerminalResult =
+      cliMsg?.type === 'result' &&
+      sessionStopRequested.has(sessionId) &&
+      !replacementAwaitingBoundary &&
+      !pendingInterruptedTurnResults.has(sessionId)
+    if (
+      shouldSuppressCliOutputDuringStop(sessionId, cliMsg, taskLifecycle) &&
+      !stoppedTurnTerminalResult
+    ) {
+      // Until the interrupted result and the replacement's own replay establish
+      // an ordering boundary, unscoped output may still belong to the old
+      // generation. Once that boundary settles, only its terminal result may
+      // pass to every renderer. Task lifecycle must pass so Stop can close
+      // Agents, and permission resolutions must pass so open prompts can close.
+      return
+    }
     if (options?.shouldForward && !options.shouldForward(cliMsg)) {
       return
     }
@@ -3018,37 +4156,58 @@ function bindClientSessionOutput(
     }
 
     const forward = () => {
-      handleCliPermissionModeBroadcast(sessionId, cliMsg)
-      const stopRequested = sessionStopRequested.has(sessionId)
-      const serverMsgs = translateCliMessage(cliMsg, sessionId)
-      for (const msg of serverMsgs) {
-        if (stopRequested && isStoppedTurnForegroundMessage(msg)) continue
-        sendMessage(ws, msg)
-      }
+      if ((sessionTranscriptEpochs.get(sessionId) ?? 0) !== transcriptEpoch) return
+      if (!activeSessions.get(sessionId)?.has(ws)) return
+      forwardCliMessageToClient(sessionId, ws, cliMsg)
     }
 
-    const persistence = persistCliTaskNotification(sessionId, cliMsg)
-    if (persistence) {
-      void persistence
-        .then(() => {
-          if (activeSessions.get(sessionId)?.has(ws)) forward()
-        })
-        .catch((error) => {
-          console.warn(
-            `[WS] Failed to forward persisted task notification for ${sessionId}: ${
-              error instanceof Error ? error.message : String(error)
-            }`,
-          )
-        })
-      return
-    }
-    forward()
+    persistThenForwardCliMessage(sessionId, cliMsg, forward)
   }
 
   clientOutputCallbacks.set(ws, { sessionId, callback })
   conversationService.onOutput(sessionId, callback)
 }
 
+function hasStoppedTurnBoundary(sessionId: string): boolean {
+  return sessionStopRequested.has(sessionId) ||
+    activeUserTurns.get(sessionId)?.replacementAfterStop === true
+}
+
+function isAgentScopedPermissionRequest(cliMsg: any): boolean {
+  return cliMsg?.type === 'control_request' &&
+    cliMsg.request?.subtype === 'can_use_tool' &&
+    typeof cliMsg.request.agent_id === 'string' &&
+    cliMsg.request.agent_id.trim().length > 0
+}
+
+function canAcceptPermissionRequestDuringStop(sessionId: string, cliMsg: any): boolean {
+  if (hasStoppedTurnBoundary(sessionId)) return false
+  if (!agentStopRequestedSessions.has(sessionId)) return true
+  return !isAgentScopedPermissionRequest(cliMsg)
+}
+
+function shouldSuppressCliOutputDuringStop(
+  sessionId: string,
+  cliMsg: any,
+  taskLifecycle: CliBackgroundTaskLifecycle | null,
+): boolean {
+  if (taskLifecycle !== null) return false
+  if (cliMsg?.type === 'control_cancel_request' || cliMsg?.type === 'control_response') {
+    return false
+  }
+  if (hasStoppedTurnBoundary(sessionId)) return true
+  if (!agentStopRequestedSessions.has(sessionId)) return false
+  if (cliMsg?.type === 'control_request') {
+    return isAgentScopedPermissionRequest(cliMsg)
+  }
+  if (cliMsg?.type === 'system' && cliMsg.subtype === 'task_progress') {
+    const taskId = typeof cliMsg.task_id === 'string' ? cliMsg.task_id.trim() : ''
+    return isAgentTaskType(cliMsg.task_type) ||
+      Boolean(taskId && activeAgentTasks.get(sessionId)?.has(taskId))
+  }
+  return true
+}
+
 function getCliPermissionModeBroadcast(cliMsg: any): PermissionMode | null {
   if (
     cliMsg?.type === 'system' &&
@@ -3478,10 +4637,14 @@ export function __resetWebSocketHandlerStateForTests(): void {
   for (const timer of sessionCleanupTimers.values()) clearTimeout(timer)
   for (const timer of prewarmIdleTimers.values()) clearTimeout(timer)
   for (const remove of sessionDisconnectWatchers.values()) remove()
+  for (const tasks of activeAgentTasks.values()) {
+    for (const task of tasks.values()) clearAgentStopFinalizationRetry(task)
+  }
   activeSessions.clear()
   activePetClient = null
   clientOutputCallbacks.clear()
   taskNotificationPersistence.clear()
+  sessionTranscriptEpochs.clear()
   sessionCleanupTimers.clear()
   sessionDisconnectWatchers.clear()
   prewarmPendingSessions.clear()
@@ -3489,10 +4652,19 @@ export function __resetWebSocketHandlerStateForTests(): void {
   prewarmIdleTimers.clear()
   activeUserTurns.clear()
   activeBackgroundTaskIds.clear()
+  activeAgentTasks.clear()
+  activeNonAgentTasks.clear()
+  authoritativeStoppedTaskIds.clear()
+  agentStopRequestedSessions.clear()
+  runtimeExitStoppedSessions.clear()
+  pendingInterruptedTurnResults.clear()
+  sessionClearInProgress.clear()
   sessionStopRequested.clear()
   terminalSessionChatStates.clear()
   legacyQueuedSessionChats.clear()
   interruptedSessionChats.clear()
+  runtimeTransitionPromises.clear()
+  sessionStartupPromises.clear()
 }
 
 export function __markPrewarmPendingForTests(sessionId: string): void {
@@ -3514,6 +4686,28 @@ export function __registerPendingUserTurnForTests(sessionId: string): void {
   activeUserTurns.set(sessionId, { messageSent: false })
 }
 
+/** Test hook: hold user admission in the shared CLI-startup seam. */
+export function __registerPendingSessionStartupForTests(
+  sessionId: string,
+  startup: Promise<void>,
+): void {
+  sessionStartupPromises.set(sessionId, startup)
+  const clearStartup = () => {
+    if (sessionStartupPromises.get(sessionId) === startup) {
+      sessionStartupPromises.delete(sessionId)
+    }
+  }
+  void startup.then(clearStartup, clearStartup)
+}
+
+/** Test hook: put a deterministic barrier ahead of user/clear admission. */
+export function __enqueueRuntimeTransitionForTests(
+  sessionId: string,
+  transition: Promise<void>,
+): Promise<void> {
+  return enqueueRuntimeTransition(sessionId, () => transition)
+}
+
 /** Test hook: settle a registered turn through the same CLI-result seam. */
 export function __settleActiveTurnForTests(sessionId: string, cliMsg: any): void {
   settleSessionChatActivity(sessionId, cliMsg)
diff --git a/src/utils/sdkEventQueue.ts b/src/utils/sdkEventQueue.ts
index c18d2d63..432b732c 100644
--- a/src/utils/sdkEventQueue.ts
+++ b/src/utils/sdkEventQueue.ts
@@ -10,6 +10,7 @@ type TaskStartedEvent = {
   tool_use_id?: string
   description: string
   task_type?: string
+  remote_session_id?: string
   workflow_name?: string
   prompt?: string
 }
diff --git a/src/utils/task/framework.test.ts b/src/utils/task/framework.test.ts
new file mode 100644
index 00000000..f38f0bd7
--- /dev/null
+++ b/src/utils/task/framework.test.ts
@@ -0,0 +1,47 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import {
+  resetStateForTests,
+  setIsInteractive,
+  switchSession,
+} from '../../bootstrap/state.js'
+import type { AppState } from '../../state/AppState.js'
+import type { RemoteAgentTaskState } from '../../tasks/RemoteAgentTask/RemoteAgentTask.js'
+import type { SessionId } from '../../types/ids.js'
+import { drainSdkEvents } from '../sdkEventQueue.js'
+import { registerTask } from './framework.js'
+
+beforeEach(() => {
+  resetStateForTests()
+  setIsInteractive(false)
+  switchSession('remote-agent-task-started' as SessionId)
+  drainSdkEvents()
+})
+
+afterEach(() => {
+  drainSdkEvents()
+  resetStateForTests()
+})
+
+test('includes the remote session id in remote Agent start events', () => {
+  let state = { tasks: {} } as AppState
+  const task = {
+    id: 'remote-task-1',
+    type: 'remote_agent',
+    status: 'running',
+    description: 'Review provider failures',
+    sessionId: 'remote-session-1',
+    toolUseId: 'remote-tool-1',
+  } as RemoteAgentTaskState
+
+  registerTask(task, (updater) => {
+    state = updater(state)
+  })
+
+  expect(drainSdkEvents()).toContainEqual(expect.objectContaining({
+    type: 'system',
+    subtype: 'task_started',
+    task_id: 'remote-task-1',
+    task_type: 'remote_agent',
+    remote_session_id: 'remote-session-1',
+  }))
+})
diff --git a/src/utils/task/framework.ts b/src/utils/task/framework.ts
index 7bb50996..ef451f3d 100644
--- a/src/utils/task/framework.ts
+++ b/src/utils/task/framework.ts
@@ -108,6 +108,8 @@ export function registerTask(task: TaskState, setAppState: SetAppState): void {
     tool_use_id: task.toolUseId,
     description: task.description,
     task_type: task.type,
+    remote_session_id:
+      task.type === 'remote_agent' ? task.sessionId : undefined,
     workflow_name:
       'workflowName' in task
         ? (task.workflowName as string | undefined)
diff --git a/src/utils/teleport/api.test.ts b/src/utils/teleport/api.test.ts
new file mode 100644
index 00000000..e7920550
--- /dev/null
+++ b/src/utils/teleport/api.test.ts
@@ -0,0 +1,110 @@
+import { afterEach, expect, mock, spyOn, test } from 'bun:test'
+import axios from 'axios'
+import * as oauthConfig from '../../constants/oauth.js'
+import * as oauthClient from '../../services/oauth/client.js'
+import * as auth from '../auth.js'
+import { archiveRemoteSession } from './api.js'
+
+function mockArchiveAuth(options?: { token?: string; orgUUID?: string }) {
+  const refresh = spyOn(auth, 'checkAndRefreshOAuthTokenIfNeeded').mockResolvedValue(false)
+  spyOn(auth, 'getClaudeAIOAuthTokens').mockReturnValue(
+    options?.token === undefined
+      ? undefined
+      : { accessToken: options.token } as ReturnType<typeof auth.getClaudeAIOAuthTokens>,
+  )
+  const organization = spyOn(oauthClient, 'getOrganizationUUID')
+    .mockResolvedValue(options?.orgUUID ?? null)
+  spyOn(oauthConfig, 'getOauthConfig').mockReturnValue({
+    BASE_API_URL: 'https://api.example.test',
+  } as ReturnType<typeof oauthConfig.getOauthConfig>)
+  return { refresh, organization }
+}
+
+afterEach(() => {
+  mock.restore()
+})
+
+test('archives remote sessions only after a 200 or idempotent 409 response', async () => {
+  mockArchiveAuth({ token: 'access-token', orgUUID: 'org-1' })
+  const post = spyOn(axios, 'post')
+    .mockResolvedValueOnce({ status: 200 })
+    .mockResolvedValueOnce({ status: 409 })
+
+  await archiveRemoteSession('session-1', { timeoutMs: 1_500 })
+  await archiveRemoteSession('session-2', { timeoutMs: 1_500 })
+
+  expect(post).toHaveBeenCalledTimes(2)
+  expect(post.mock.calls[0]?.[0]).toBe(
+    'https://api.example.test/v1/sessions/session-1/archive',
+  )
+  expect(post.mock.calls[0]?.[2]).toEqual(expect.objectContaining({
+    timeout: 1_500,
+    headers: expect.objectContaining({
+      Authorization: 'Bearer access-token',
+      'x-organization-uuid': 'org-1',
+    }),
+  }))
+})
+
+test('rejects an archive that cannot be authenticated or confirmed', async () => {
+  mockArchiveAuth({ token: 'access-token', orgUUID: 'org-1' })
+  const post = spyOn(axios, 'post')
+  for (const status of [401, 403, 500]) {
+    post.mockResolvedValueOnce({ status })
+    await expect(archiveRemoteSession(`session-${status}`)).rejects.toThrow(
+      `Failed to archive remote session: HTTP ${status}`,
+    )
+  }
+
+  post.mockRejectedValueOnce(new Error('request timed out'))
+  await expect(archiveRemoteSession('session-timeout')).rejects.toThrow(
+    'request timed out',
+  )
+})
+
+test('bounds the whole archive flow when token refresh does not settle', async () => {
+  const { refresh } = mockArchiveAuth({ token: 'access-token', orgUUID: 'org-1' })
+  refresh.mockImplementation(
+    () => new Promise<boolean>(() => {}),
+  )
+  const post = spyOn(axios, 'post').mockResolvedValue({ status: 200 })
+
+  await expect(archiveRemoteSession('session-auth-timeout', { timeoutMs: 20 })).rejects.toThrow(
+    'Remote session archive timed out after 20ms',
+  )
+  expect(post).not.toHaveBeenCalled()
+})
+
+test('bounds the whole archive flow when organization lookup does not settle', async () => {
+  const { organization } = mockArchiveAuth({ token: 'access-token', orgUUID: 'org-1' })
+  organization.mockImplementation(() => new Promise<string | null>(() => {}))
+  const post = spyOn(axios, 'post').mockResolvedValue({ status: 200 })
+
+  await expect(archiveRemoteSession('session-org-timeout', { timeoutMs: 20 })).rejects.toThrow(
+    'Remote session archive timed out after 20ms',
+  )
+  expect(post).not.toHaveBeenCalled()
+})
+
+test('rejects missing credentials and unsafe remote session ids without a request', async () => {
+  mockArchiveAuth({ orgUUID: 'org-1' })
+  const post = spyOn(axios, 'post').mockResolvedValue({ status: 200 })
+
+  await expect(archiveRemoteSession('session-1')).rejects.toThrow(
+    'Claude Code web sessions require authentication',
+  )
+  await expect(archiveRemoteSession('../session-2')).rejects.toThrow(
+    'Invalid remote session id',
+  )
+  expect(post).not.toHaveBeenCalled()
+})
+
+test('rejects a missing organization before making the archive request', async () => {
+  mockArchiveAuth({ token: 'access-token' })
+  const post = spyOn(axios, 'post').mockResolvedValue({ status: 200 })
+
+  await expect(archiveRemoteSession('session-1')).rejects.toThrow(
+    'Unable to get organization UUID',
+  )
+  expect(post).not.toHaveBeenCalled()
+})
diff --git a/src/utils/teleport/api.ts b/src/utils/teleport/api.ts
index c3a666e2..0446c14e 100644
--- a/src/utils/teleport/api.ts
+++ b/src/utils/teleport/api.ts
@@ -3,7 +3,10 @@ import { randomUUID } from 'crypto'
 import { getOauthConfig } from 'src/constants/oauth.js'
 import { getOrganizationUUID } from 'src/services/oauth/client.js'
 import z from 'zod/v4'
-import { getClaudeAIOAuthTokens } from '../auth.js'
+import {
+  checkAndRefreshOAuthTokenIfNeeded,
+  getClaudeAIOAuthTokens,
+} from '../auth.js'
 import { logForDebugging } from '../debug.js'
 import { parseGitHubRepository } from '../detectRepository.js'
 import { errorMessage, toError } from '../errors.js'
@@ -197,6 +200,74 @@ export async function prepareApiRequest(): Promise<{
   return { accessToken, orgUUID }
 }
 
+const REMOTE_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/
+
+/**
+ * Archive a remote Agent session and reject unless the API confirms it.
+ * 409 is success because the archive operation is intentionally idempotent.
+ */
+export async function archiveRemoteSession(
+  sessionId: string,
+  options?: { timeoutMs?: number },
+): Promise<void> {
+  if (!REMOTE_SESSION_ID_PATTERN.test(sessionId)) {
+    throw new Error('Invalid remote session id')
+  }
+
+  const timeoutMs = options?.timeoutMs ?? 10_000
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error('Remote session archive timeout must be positive')
+  }
+
+  const deadline = Date.now() + timeoutMs
+  const controller = new AbortController()
+  const timeoutError = () => new Error(
+    `Remote session archive timed out after ${timeoutMs}ms`,
+  )
+  const ensureWithinDeadline = () => {
+    if (controller.signal.aborted || Date.now() >= deadline) throw timeoutError()
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | undefined
+  const deadlinePromise = new Promise<never>((_, reject) => {
+    timeout = setTimeout(() => {
+      reject(timeoutError())
+      controller.abort()
+    }, timeoutMs)
+    if (typeof timeout === 'object') timeout.unref?.()
+  })
+  const archive = (async () => {
+    await checkAndRefreshOAuthTokenIfNeeded()
+    ensureWithinDeadline()
+    const { accessToken, orgUUID } = await prepareApiRequest()
+    ensureWithinDeadline()
+    const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}/archive`
+    const response = await axios.post(url, {}, {
+      headers: {
+        ...getOAuthHeaders(accessToken),
+        'anthropic-beta': CCR_BYOC_BETA,
+        'x-organization-uuid': orgUUID,
+      },
+      timeout: timeoutMs,
+      signal: controller.signal,
+      validateStatus: () => true,
+    })
+
+    if (response.status === 200 || response.status === 409) {
+      logForDebugging(`[archiveRemoteSession] archived ${sessionId}`)
+      return
+    }
+
+    throw new Error(`Failed to archive remote session: HTTP ${response.status}`)
+  })()
+
+  try {
+    await Promise.race([archive, deadlinePromise])
+  } finally {
+    if (timeout !== undefined) clearTimeout(timeout)
+  }
+}
+
 /**
  * Fetches code sessions from the new Sessions API (/v1/sessions)
  * @returns Array of code sessions