diff --git a/src/cli/runtime/websocket-transport.test.ts b/src/cli/runtime/websocket-transport.test.ts
index 4c178b71fd8..ed4330c8f1a 100644
--- a/src/cli/runtime/websocket-transport.test.ts
+++ b/src/cli/runtime/websocket-transport.test.ts
@@ -18,6 +18,7 @@ import { launchOrcaApp } from './launch'
 import { addEnvironmentFromPairingCode } from './environments'
 import { RuntimeClientError } from './types'
 import {
+  AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
   AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
   AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY,
   AUTOMATION_OWNER_FENCING_RUNTIME_CAPABILITY,
@@ -72,6 +73,7 @@ describe('CLI remote WebSocket transport', () => {
       expect.objectContaining({
         clientCapabilities: [
           AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
+          AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
           SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY,
           SESSION_TABS_AUTHORITATIVE_INVENTORY_RUNTIME_CAPABILITY,
           AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY,
diff --git a/src/main/claude/claude-background-task-tracker.test.ts b/src/main/claude/claude-background-task-tracker.test.ts
index df89a64a968..43912bfa560 100644
--- a/src/main/claude/claude-background-task-tracker.test.ts
+++ b/src/main/claude/claude-background-task-tracker.test.ts
@@ -21,6 +21,24 @@ function trackerAt(times: number[]): ClaudeBackgroundTaskTracker {
   return new ClaudeBackgroundTaskTracker(() => times[Math.min(index++, times.length - 1)])
 }
 
+/** The identity and stoppability of each published row, which is what the
+ *  foreground cases below are about; `startedAt` and `state` have their own
+ *  tests and would only make these brittle. */
+function rows(tracker: ClaudeBackgroundTaskTracker): { id: string; stoppable?: boolean }[] {
+  return (tracker.state?.tasks ?? []).map((task) => ({
+    id: task.id,
+    ...(task.stoppable === undefined ? {} : { stoppable: task.stoppable })
+  }))
+}
+
+function started(id: string, backgrounded: boolean): Record<string, unknown> {
+  return system('task_started', {
+    task_id: id,
+    task_type: 'local_agent',
+    is_backgrounded: backgrounded
+  })
+}
+
 describe('ClaudeBackgroundTaskTracker', () => {
   it('classifies SDK task types without inferring them from descriptions', () => {
     expect(classifyClaudeBackgroundTaskKind('local_agent')).toBe('agent')
@@ -581,4 +599,137 @@ describe('ClaudeBackgroundTaskTracker', () => {
     expect(tracker.clear()).toBe(true)
     expect(tracker.state).toBeNull()
   })
+  it('marks a foreground row not stoppable and leaves a backgrounded row alone', () => {
+    // `stopTask` has no foreground target, so the row must not offer a Stop that
+    // resolves to an empty list and silently reports nothing cancelled. A
+    // backgrounded row stays untouched on the wire: absent means stoppable.
+    const tracker = new ClaudeBackgroundTaskTracker()
+    tracker.observe({ type: 'user' }, true)
+    tracker.observe(started('fore-1', false))
+    tracker.observe(started('back-1', true))
+
+    expect(rows(tracker)).toEqual([{ id: 'fore-1', stoppable: false }, { id: 'back-1' }])
+    expect(tracker.stoppableTaskIds).toEqual(['back-1'])
+  })
+
+  it('keeps live foreground work across an aggregate roster that never lists it', () => {
+    // `background_tasks_changed` enumerates BACKGROUNDED work only, so it is
+    // authoritative over that class alone. Treating it as the whole world wiped
+    // every in-flight foreground row and then dropped every later start.
+    const tracker = new ClaudeBackgroundTaskTracker()
+    tracker.observe({ type: 'user' }, true)
+    tracker.observe(started('fore-1', false))
+    tracker.observe(
+      aggregate([{ task_id: 'back-1', task_type: 'local_bash', description: 'bash' }])
+    )
+
+    // A retained row also keeps the place the user is already reading it in.
+    expect(rows(tracker)).toEqual([{ id: 'fore-1', stoppable: false }, { id: 'back-1' }])
+
+    // A foreground start after the roster is new work, not a stale echo.
+    tracker.observe(started('fore-2', false))
+    expect(rows(tracker)).toEqual([
+      { id: 'fore-1', stoppable: false },
+      { id: 'back-1' },
+      { id: 'fore-2', stoppable: false }
+    ])
+
+    // Turn end still retires the foreground rows and only those.
+    tracker.observe(result())
+    expect(rows(tracker)).toEqual([{ id: 'back-1' }])
+  })
+
+  it('drops a backgrounded start the roster no longer lists but bounds what it retains', () => {
+    const tracker = new ClaudeBackgroundTaskTracker()
+    tracker.observe({ type: 'user' }, true)
+    for (let index = 0; index < 300; index += 1) {
+      tracker.observe(started(`fore-${index}`, false))
+    }
+    tracker.observe(
+      aggregate([{ task_id: 'back-1', task_type: 'local_bash', description: 'bash' }])
+    )
+
+    const ids = rows(tracker).map((row) => row.id)
+    // 255 retained foreground rows plus the roster's own entry: retention is
+    // real and still counts against the cap.
+    expect(ids).toHaveLength(256)
+    // When the cap bites, the STALEST retained row goes, not the newest.
+    expect(ids).toContain('fore-299')
+    expect(ids).not.toContain('fore-44')
+    expect(ids).toContain('back-1')
+
+    // Aggregate authority over its OWN class is unchanged.
+    tracker.observe(started('stale', true))
+    expect(tracker.stoppableTaskIds).toEqual(['back-1'])
+  })
+
+  it('keeps a finished foreground id dead across a roster that never listed it', () => {
+    // The start guard only convicts BACKGROUNDED starts now, so terminal
+    // evidence is the only thing left defending a finished foreground id — and
+    // the roster carries no evidence about one, so it must not wipe it.
+    const tracker = new ClaudeBackgroundTaskTracker()
+    tracker.observe({ type: 'user' }, true)
+    tracker.observe(started('fore-1', false))
+    tracker.observe(system('task_notification', { task_id: 'fore-1', status: 'completed' }))
+    expect(tracker.state).toBeNull()
+
+    tracker.observe(
+      aggregate([{ task_id: 'back-1', task_type: 'local_bash', description: 'bash' }])
+    )
+    tracker.observe(started('fore-1', false))
+
+    expect(rows(tracker)).toEqual([{ id: 'back-1' }])
+  })
+
+  it('retires a phantom foreground row when the next turn starts', () => {
+    // A foreground `task_started` with no turn open has no `result` coming to
+    // retire it, so it would sit in the strip — with no stop of its own — and
+    // refuse a conversation command. Turn start is the same evidence `result`
+    // is, and settling on it is cleanup only: nothing gates visibility on it.
+    const tracker = new ClaudeBackgroundTaskTracker()
+    tracker.observe(started('phantom', false))
+    expect(rows(tracker)).toEqual([{ id: 'phantom', stoppable: false }])
+
+    tracker.observe({ type: 'user' }, true)
+    expect(tracker.state).toBeNull()
+  })
+
+  it('settles a previous turn the way the subagent roster settles it', () => {
+    // On this same frame the roster's `settleTurn` moves a still-working
+    // FOREGROUND child to `unverifiable` and leaves a backgrounded one alone.
+    // The strip has no `unverifiable` row, so keeping one would assert `live`
+    // for work Orca has already stopped vouching for.
+    const tracker = new ClaudeBackgroundTaskTracker()
+    tracker.observe({ type: 'user' }, true)
+    tracker.observe(started('fore', false))
+    tracker.observe(started('back', true))
+
+    // No `result` for that turn; the next one starting is its only end.
+    tracker.observe({ type: 'user' }, true)
+    expect(rows(tracker)).toEqual([{ id: 'back' }])
+  })
+
+  it('empties only between one task retiring and the next starting', () => {
+    // The strip's mid-turn unmount in a sequential fan-out is TRUTHFUL: A leaves
+    // on the provider's own terminal frame, B does not exist yet, and nothing
+    // sweeps A early. Foreground work is not retained as a settled row either,
+    // so an empty roster means no task is running.
+    const tracker = new ClaudeBackgroundTaskTracker()
+    tracker.observe({ type: 'user' }, true)
+    tracker.observe(started('A', false))
+    expect(rows(tracker)).toEqual([{ id: 'A', stoppable: false }])
+    tracker.observe(system('task_notification', { task_id: 'A', status: 'completed' }))
+    expect(tracker.state).toBeNull()
+    tracker.observe(started('B', false))
+    expect(rows(tracker)).toEqual([{ id: 'B', stoppable: false }])
+
+    // Backgrounded work spanning the same gap holds the roster open, so an
+    // empty one is never work the strip is hiding.
+    const spanned = new ClaudeBackgroundTaskTracker()
+    spanned.observe({ type: 'user' }, true)
+    spanned.observe(started('bg', true))
+    spanned.observe(started('A', false))
+    spanned.observe(system('task_notification', { task_id: 'A', status: 'completed' }))
+    expect(rows(spanned)).toEqual([{ id: 'bg' }])
+  })
 })
diff --git a/src/main/claude/claude-background-task-tracker.ts b/src/main/claude/claude-background-task-tracker.ts
index 68c7f4f1185..14f4271b7d8 100644
--- a/src/main/claude/claude-background-task-tracker.ts
+++ b/src/main/claude/claude-background-task-tracker.ts
@@ -66,6 +66,16 @@ export class ClaudeBackgroundTaskTracker {
     // Background work publishes through a foreground turn: the strip stays
     // honest mid-fan-out and the client alone decides when the idle-only
     // monitoring label may speak.
+    //
+    // A new turn is the same evidence `result` is: nothing the previous turn
+    // left foreground is still that turn's work. CLEANUP ONLY — a row's
+    // visibility never consults `startsTurn`, which is Orca's own
+    // dispatch-correlation bookkeeping and false by design for undispatched
+    // turns, so a missed one degrades to the old behaviour and can never hide
+    // live work.
+    if (startsTurn || message.type === 'result') {
+      this.settleForegroundTasks()
+    }
     if (message.type === 'system') {
       if (!this.observeSystemFrame(message) && !startsTurn) {
         return false
@@ -84,6 +94,17 @@ export class ClaudeBackgroundTaskTracker {
     return this.refreshMonitoring()
   }
 
+  /** `result` is the outcome of every task the provider marked foreground, so
+   *  they stop being live work. Backgrounded tasks outlive the turn and are
+   *  never swept here — only their own terminal frame retires them. */
+  private settleForegroundTasks(): void {
+    for (const task of this.tasks.values()) {
+      if (!task.backgrounded) {
+        task.liveInTurn = false
+      }
+    }
+  }
+
   private settle(
     id: string,
     state: AgentSessionBackgroundTaskRunState,
@@ -131,12 +152,17 @@ export class ClaudeBackgroundTaskTracker {
       this.finish(id)
       return true
     }
-    if (this.aggregateRosterObserved && !this.tasks.has(id)) {
+    const kind = classifyClaudeBackgroundTaskKind(message.task_type)
+    const backgrounded =
+      message.is_backgrounded === true || kind === 'workflow' || kind === 'monitor'
+    // The aggregate roster enumerates BACKGROUND work only, so it is authoritative
+    // over that class alone. A foreground start it could never have listed is not
+    // stale evidence, and dropping it here silently killed foreground rows.
+    if (this.aggregateRosterObserved && backgrounded && !this.tasks.has(id)) {
       return false
     }
-    const kind = classifyClaudeBackgroundTaskKind(message.task_type)
     this.upsert(id, {
-      backgrounded: message.is_backgrounded === true || kind === 'workflow' || kind === 'monitor',
+      backgrounded,
       kind,
       description: taskDescription(message.description),
       name: taskName(message),
@@ -189,9 +215,9 @@ export class ClaudeBackgroundTaskTracker {
     const prior = new Map(this.tasks)
     this.aggregateRosterObserved = true
     this.tasks.clear()
-    this.terminalTaskIds.clear()
+    const roster = new Map<string, TrackedClaudeBackgroundTask>()
     for (const valueTask of value) {
-      if (this.tasks.size >= MAX_TRACKED_TASKS) {
+      if (roster.size >= MAX_TRACKED_TASKS) {
         break
       }
       const task = record(valueTask)
@@ -202,12 +228,16 @@ export class ClaudeBackgroundTaskTracker {
       if (!id) {
         continue
       }
-      // An authoritative live roster supersedes an earlier terminal edge.
-      const retained = this.retention.resume(id)
-      const existing = prior.get(id) ?? retained
+      // An authoritative live roster supersedes an earlier terminal edge — for
+      // the ids it actually lists. Wiping the whole set left a finished
+      // FOREGROUND id undefended, since the start guard now convicts only
+      // backgrounded starts.
+      this.terminalTaskIds.delete(id)
+      const existing = prior.get(id) ?? this.retention.resume(id)
       const kind = classifyClaudeBackgroundTaskKind(task.task_type)
-      this.tasks.set(id, {
+      roster.set(id, {
         backgrounded: true,
+        liveInTurn: true,
         kind: kind !== 'unknown' ? kind : (existing?.kind ?? 'unknown'),
         description: taskDescription(task.description) ?? existing?.description,
         name: taskName(task) ?? existing?.name,
@@ -216,6 +246,28 @@ export class ClaudeBackgroundTaskTracker {
         totalTokens: existing?.totalTokens
       })
     }
+    // Live foreground work is not in a BACKGROUND roster and is not superseded
+    // by one. Budget counted up front so eviction drops the STALEST retained
+    // rows rather than the newest, and roster entries are never starved.
+    const retainable = [...prior].filter(
+      ([id, task]) => !task.backgrounded && task.liveInTurn && !roster.has(id)
+    )
+    let evict = Math.max(0, roster.size + retainable.length - MAX_TRACKED_TASKS)
+    // Retained rows keep their own relative order and stay ahead of the roster,
+    // so a live row the user is reading does not drop below it when a roster
+    // frame lands. Within the roster the PROVIDER's order wins — including for
+    // a task it reports live again, which belongs where the provider lists it
+    // rather than appended after the rows that outlived it.
+    for (const [id, task] of retainable) {
+      if (evict > 0) {
+        evict -= 1
+        continue
+      }
+      this.tasks.set(id, task)
+    }
+    for (const [id, task] of roster) {
+      this.tasks.set(id, task)
+    }
     for (const [id, task] of prior) {
       if (task.backgrounded && !this.tasks.has(id)) {
         this.retention.rememberRemoved(id, task)
@@ -223,7 +275,7 @@ export class ClaudeBackgroundTaskTracker {
     }
   }
 
-  private upsert(id: string, task: TrackedClaudeBackgroundTask): void {
+  private upsert(id: string, task: Omit<TrackedClaudeBackgroundTask, 'liveInTurn'>): void {
     if (!this.tasks.has(id) && this.tasks.size >= MAX_TRACKED_TASKS) {
       let foregroundId: string | undefined
       for (const [candidateId, candidate] of this.tasks) {
@@ -242,6 +294,8 @@ export class ClaudeBackgroundTaskTracker {
     if (existing) {
       this.tasks.set(id, {
         backgrounded: existing.backgrounded || task.backgrounded,
+        // A settled foreground task is not revived by a late edge frame.
+        liveInTurn: existing.liveInTurn,
         kind: task.kind !== 'unknown' ? task.kind : existing.kind,
         description: task.description ?? existing.description,
         name: task.name ?? existing.name,
@@ -251,7 +305,7 @@ export class ClaudeBackgroundTaskTracker {
       })
       return
     }
-    this.tasks.set(id, task)
+    this.tasks.set(id, { ...task, liveInTurn: true })
   }
 
   private finish(id: string): void {
@@ -284,7 +338,7 @@ export class ClaudeBackgroundTaskTracker {
   private backgroundTaskDetails(): AgentSessionBackgroundTask[] {
     const details: AgentSessionBackgroundTask[] = []
     for (const [id, task] of this.tasks) {
-      if (!task.backgrounded) {
+      if (!task.backgrounded && !task.liveInTurn) {
         continue
       }
       details.push(claudeBackgroundTaskDetail(id, task))
diff --git a/src/main/claude/claude-settled-background-tasks.ts b/src/main/claude/claude-settled-background-tasks.ts
index 91e975d07bb..73064becec4 100644
--- a/src/main/claude/claude-settled-background-tasks.ts
+++ b/src/main/claude/claude-settled-background-tasks.ts
@@ -17,6 +17,10 @@ const MAX_RETAINED_TASKS = 256
 
 export type TrackedClaudeBackgroundTask = {
   backgrounded: boolean
+  /** Foreground work is turn-scoped: the provider's `result` (or the next turn
+   *  starting) is its outcome, so it stays visible only until that frame.
+   *  Backgrounded work ignores this and is retired only by its own edge. */
+  liveInTurn: boolean
   kind: AgentSessionBackgroundTask['kind']
   description?: string
   name?: string
@@ -38,7 +42,9 @@ export function claudeBackgroundTaskDetail(
     ...(task.name ? { name: task.name } : {}),
     state: task.state ?? (task.kind === 'monitor' ? 'monitoring' : 'working'),
     startedAt: task.startedAt,
-    ...(task.totalTokens !== undefined ? { totalTokens: task.totalTokens } : {})
+    ...(task.totalTokens !== undefined ? { totalTokens: task.totalTokens } : {}),
+    // Only a backgrounded row has a stop the host can target; absent means yes.
+    ...(task.backgrounded ? {} : { stoppable: false })
   }
 }
 
@@ -103,7 +109,15 @@ export class ClaudeSettledBackgroundTasks {
     if (!source || source.startedAt === undefined) {
       return undefined
     }
-    return { ...source, backgrounded: true, state: undefined, startedAt: source.startedAt }
+    // Positive live evidence, so it re-enters live in this turn too; a resumed
+    // task is always backgrounded, which is what actually gates its visibility.
+    return {
+      ...source,
+      backgrounded: true,
+      liveInTurn: true,
+      state: undefined,
+      startedAt: source.startedAt
+    }
   }
 
   get hasSettled(): boolean {
diff --git a/src/main/codex/codex-background-command-tracker.ts b/src/main/codex/codex-background-command-tracker.ts
index becbb18a67c..844134881ad 100644
--- a/src/main/codex/codex-background-command-tracker.ts
+++ b/src/main/codex/codex-background-command-tracker.ts
@@ -10,9 +10,33 @@ const MAX_DESCRIPTION_CHARS = 512
 
 type Command = { threadId: string; task: AgentSessionBackgroundTask; bytes: number }
 
-/** Stays within the retained bound, so read-time qualification cannot outgrow admission. */
+/** The label's reserved share of the description. Reserved, not merely capped:
+ *  a label free to spend the whole budget clips away the command it qualifies,
+ *  leaving a command row naming an agent and no command — the failure this
+ *  qualification exists to remove, in the other direction. `bytes` is counted
+ *  before qualification, so this share is also what a published row may exceed
+ *  the admitted count by. */
+const MAX_LABEL_CHARS = 96
+
+/** Every cut in this file goes through here, clipped the way `boundSubagentField`
+ *  clips the same provider string on the agent row: never mid surrogate pair,
+ *  since a lone surrogate is lossy through any non-JSON UTF-8 hop. A composed
+ *  row is cut a SECOND time, so a clip that is safe only where the label is
+ *  bounded is not safe. No ordinal, because a row's identity is its `id`. */
+function boundText(value: string, max: number): string {
+  if (value.length <= max) {
+    return value
+  }
+  const keep = max - 1
+  const last = value.charCodeAt(keep - 1)
+  const end = last >= 0xd800 && last <= 0xdbff ? keep - 1 : keep
+  return `${value.slice(0, end)}…`
+}
+
+/** Resolved on read, and capped at the bound the admitted description already respects. */
 function qualifiedDescription(label: string, description: string | undefined): string {
-  return (description ? `${label} — ${description}` : label).slice(0, MAX_DESCRIPTION_CHARS)
+  const name = boundText(label, MAX_LABEL_CHARS)
+  return boundText(description ? `${name} — ${description}` : name, MAX_DESCRIPTION_CHARS)
 }
 
 export class CodexBackgroundCommandTracker {
@@ -122,8 +146,7 @@ export class CodexBackgroundCommandTracker {
     }
     const key = JSON.stringify([event.threadId, item.id])
     const completed = event.method === 'item/completed' || item.status !== 'inProgress'
-    const description = readString(item, 'command')
-      ?.slice(0, MAX_DESCRIPTION_CHARS)
+    const description = boundText(readString(item, 'command') ?? '', MAX_DESCRIPTION_CHARS)
       .replace(/\s+/g, ' ')
       .trim()
     const value = {
diff --git a/src/main/codex/codex-background-task-tracker.test.ts b/src/main/codex/codex-background-task-tracker.test.ts
index 47987fe3fc0..0a70442a0b3 100644
--- a/src/main/codex/codex-background-task-tracker.test.ts
+++ b/src/main/codex/codex-background-task-tracker.test.ts
@@ -22,7 +22,8 @@ function turn(
 function activity(
   kind = 'started',
   parentTurn = PARENT_TURN,
-  child = CHILD
+  child = CHILD,
+  name = 'count_a'
 ): CodexBackgroundTaskEvent {
   return {
     method: 'item/started',
@@ -35,7 +36,7 @@ function activity(
         id: `activity-${kind}`,
         kind,
         agentThreadId: child,
-        agentPath: '/root/count_a'
+        agentPath: `/root/${name}`
       }
     }
   }
@@ -49,7 +50,11 @@ function runningChild(): CodexBackgroundTaskTracker {
   return tracker
 }
 
-function command(threadId = PRIMARY, method = 'item/started'): CodexBackgroundTaskEvent {
+function command(
+  threadId = PRIMARY,
+  method = 'item/started',
+  commandText = 'sleep 90'
+): CodexBackgroundTaskEvent {
   return {
     method,
     threadId,
@@ -61,7 +66,7 @@ function command(threadId = PRIMARY, method = 'item/started'): CodexBackgroundTa
         id: 'exec-1',
         processId: '71831',
         source: 'unifiedExecStartup',
-        command: 'sleep 90',
+        command: commandText,
         status: method === 'item/started' ? 'inProgress' : 'completed'
       }
     }
@@ -103,15 +108,19 @@ describe('CodexBackgroundTaskTracker child execution ownership', () => {
     expect(tracker.state).toBeNull()
   })
 
-  it('reports an executing child only after the foreground turn ends', () => {
+  it('reports an executing child while the spawning turn is still open', () => {
     const tracker = runningChild()
-    expect(tracker.state).toBeNull()
-    expect(tracker.observe(turn('turn/completed', PRIMARY, PARENT_TURN))).toBe(true)
-    expect(tracker.state).toEqual({
+    const running = {
       state: 'monitoring',
       supportsStopAll: false,
       tasks: [{ id: `codex-agent:${CHILD}`, kind: 'agent', description: 'count_a' }]
-    })
+    }
+    // The strip is a live view: a fan-out is reported while it runs, not once
+    // the parent turn happens to end.
+    expect(tracker.state).toEqual(running)
+    // Turn end reveals children, it never settles them; the child is unchanged.
+    expect(tracker.observe(turn('turn/completed', PRIMARY, PARENT_TURN))).toBe(false)
+    expect(tracker.state).toEqual(running)
   })
 
   it('never settles a child when a primary turn ends', () => {
@@ -220,15 +229,16 @@ describe('CodexBackgroundTaskTracker child execution ownership', () => {
 })
 
 describe('CodexBackgroundTaskTracker command integration', () => {
-  it('keeps a primary shell visible after the turn until its own completion', () => {
+  it('keeps a primary shell visible from launch until its own completion', () => {
     const tracker = new CodexBackgroundTaskTracker(PRIMARY)
+    const shell = [{ id: 'codex-command:primary:exec-1', kind: 'command', description: 'sleep 90' }]
     tracker.observe(turn('turn/started', PRIMARY, PARENT_TURN))
     tracker.observe(command())
-    expect(tracker.state).toBeNull()
+    // Visible while the turn that launched it is still running.
+    expect(tracker.state?.tasks).toEqual(shell)
     tracker.observe(turn('turn/completed', PRIMARY, PARENT_TURN))
-    expect(tracker.state?.tasks).toEqual([
-      { id: 'codex-command:primary:exec-1', kind: 'command', description: 'sleep 90' }
-    ])
+    expect(tracker.state?.tasks).toEqual(shell)
+    // Only the shell's own completion retires the row.
     tracker.observe(command(PRIMARY, 'item/completed'))
     expect(tracker.state).toBeNull()
   })
@@ -261,6 +271,63 @@ describe('CodexBackgroundTaskTracker command integration', () => {
     })
   })
 
+  it('keeps the command visible under a label that would otherwise fill the row', () => {
+    const tracker = new CodexBackgroundTaskTracker(PRIMARY)
+    tracker.observe(turn('turn/started', PRIMARY, PARENT_TURN))
+    tracker.observe(turn('turn/started', CHILD, CHILD_TURN))
+    tracker.observe(activity('started', PARENT_TURN, CHILD, 'L'.repeat(600)))
+    tracker.observe(command(CHILD))
+    tracker.observe(turn('turn/completed', PRIMARY, PARENT_TURN))
+    tracker.observe(turn('turn/completed', CHILD, CHILD_TURN))
+    const description = tracker.state?.tasks?.[0]?.description
+    expect(description).toContain('sleep 90')
+    expect(description).toBe(`${'L'.repeat(95)}… — sleep 90`)
+  })
+
+  it('never cuts a label mid surrogate pair', () => {
+    const tracker = new CodexBackgroundTaskTracker(PRIMARY)
+    tracker.observe(turn('turn/started', PRIMARY, PARENT_TURN))
+    tracker.observe(turn('turn/started', CHILD, CHILD_TURN))
+    tracker.observe(activity('started', PARENT_TURN, CHILD, `${'L'.repeat(94)}\u{1F600}bad`))
+    tracker.observe(command(CHILD))
+    tracker.observe(turn('turn/completed', PRIMARY, PARENT_TURN))
+    tracker.observe(turn('turn/completed', CHILD, CHILD_TURN))
+    const description = tracker.state?.tasks?.[0]?.description ?? ''
+    expect(description.isWellFormed()).toBe(true)
+    expect(description).toBe(`${'L'.repeat(94)}… — sleep 90`)
+  })
+
+  it('never cuts a qualified command mid surrogate pair', () => {
+    // The label is bounded, then the COMPOSED row is bounded again. That second
+    // cut lands inside the description, so clipping only the label side leaves a
+    // lone surrogate — lossy through any non-JSON UTF-8 hop.
+    const tracker = new CodexBackgroundTaskTracker(PRIMARY)
+    tracker.observe(turn('turn/started', PRIMARY, PARENT_TURN))
+    tracker.observe(turn('turn/started', CHILD, CHILD_TURN))
+    tracker.observe(activity('started', PARENT_TURN, CHILD, 'L'.repeat(96)))
+    // Places the pair exactly where a raw slice of the composed row splits it.
+    tracker.observe(command(CHILD, 'item/started', `${'C'.repeat(412)}\u{1F600}${'D'.repeat(200)}`))
+    tracker.observe(turn('turn/completed', PRIMARY, PARENT_TURN))
+    tracker.observe(turn('turn/completed', CHILD, CHILD_TURN))
+    const description = tracker.state?.tasks?.[0]?.description ?? ''
+    expect(description.length).toBeLessThanOrEqual(512)
+    expect(description.startsWith(`${'L'.repeat(96)} — `)).toBe(true)
+    expect(description.isWellFormed()).toBe(true)
+  })
+
+  it('never cuts an unqualified primary command mid surrogate pair', () => {
+    const tracker = new CodexBackgroundTaskTracker(PRIMARY)
+    tracker.observe(turn('turn/started', PRIMARY, PARENT_TURN))
+    // The pair straddles the raw description bound itself.
+    tracker.observe(
+      command(PRIMARY, 'item/started', `${'C'.repeat(511)}\u{1F600}${'D'.repeat(50)}`)
+    )
+    tracker.observe(turn('turn/completed', PRIMARY, PARENT_TURN))
+    const description = tracker.state?.tasks?.[0]?.description ?? ''
+    expect(description.length).toBeLessThanOrEqual(512)
+    expect(description.isWellFormed()).toBe(true)
+  })
+
   it('names a child shell whose label only arrives after the command', () => {
     const tracker = new CodexBackgroundTaskTracker(PRIMARY)
     tracker.observe(turn('turn/started', PRIMARY, PARENT_TURN))
diff --git a/src/main/codex/codex-background-task-tracker.ts b/src/main/codex/codex-background-task-tracker.ts
index 2918f087809..a972b7bb4c1 100644
--- a/src/main/codex/codex-background-task-tracker.ts
+++ b/src/main/codex/codex-background-task-tracker.ts
@@ -12,7 +12,6 @@ import { boundSubagentField } from './codex-subagent-group-body'
 
 /** Projects the same child execution facts the durable roster consumes. */
 export class CodexBackgroundTaskTracker {
-  private primaryTurnId: string | null = null
   private publishedFingerprint = '[]'
   private publishedState: AgentSessionBackgroundTaskState | null = null
   private readonly commands: CodexBackgroundCommandTracker
@@ -44,29 +43,22 @@ export class CodexBackgroundTaskTracker {
     }
     if (frame.kind === 'subagent') {
       this.executions.register(frame.agentThreadId, frame.label, frame.parentTurnId)
-    } else if (frame.threadId === this.primaryThreadId) {
-      if (frame.state === 'working') {
-        this.primaryTurnId = frame.turnId
-      } else if (frame.turnId === this.primaryTurnId) {
-        this.primaryTurnId = null
-      }
-    } else {
+    } else if (frame.threadId !== this.primaryThreadId) {
       this.executions.observeTurn(frame.threadId, frame.turnId, frame.state)
     }
+    // A primary-turn frame only prompts a republish: turn end reveals children,
+    // it never settles them. Codex `spawn_agent` children keep reporting well
+    // past their parent turn, so nothing here may sweep the roster.
     return this.refresh()
   }
 
   clear(): boolean {
     this.executions.clear()
     this.commands.clear()
-    this.primaryTurnId = null
     return this.refresh()
   }
 
   private tasks(): AgentSessionBackgroundTask[] {
-    if (this.primaryTurnId !== null) {
-      return []
-    }
     const children = this.executions.workingChildren()
     const agents: AgentSessionBackgroundTask[] = children.map((child, index) => ({
       id: `codex-agent:${child.agentThreadId}`,
diff --git a/src/main/codex/codex-structured-session-background-tasks.test.ts b/src/main/codex/codex-structured-session-background-tasks.test.ts
index aa6156027e8..380abb1da6f 100644
--- a/src/main/codex/codex-structured-session-background-tasks.test.ts
+++ b/src/main/codex/codex-structured-session-background-tasks.test.ts
@@ -215,29 +215,27 @@ describe('codex background tasks reach the strip', () => {
     }
   })
 
-  it('publishes the orphaned fan-out once the spawning turn completes', async () => {
+  it('publishes the fan-out while it runs and keeps it past the spawning turn', async () => {
     const published: { sessionId: string; state: AgentSessionBackgroundTaskState | null }[] = []
     const { adapter, codex } = await adapterWithSession(published)
+    const running = {
+      state: 'monitoring',
+      supportsStopAll: false,
+      tasks: [{ id: `codex-agent:${CHILD_ID}`, kind: 'agent', description: 'count_a' }]
+    }
 
     const spawn = subagentNotification('started')
     codex.handlers().onNotification?.(spawn.method, spawn.params)
-    // The child is still inside the turn, so the strip stays silent.
-    expect(published).toEqual([])
-    expect(adapter.backgroundTaskState('session-1')).toBeNull()
+    // Mid-turn: the child is running, so the strip reports it now.
+    expect(published).toEqual([{ sessionId: 'session-1', state: running }])
+    expect(adapter.backgroundTaskState('session-1')).toEqual(running)
 
+    published.length = 0
     codex.handlers().onNotification?.(TURN_COMPLETED.method, TURN_COMPLETED.params)
 
-    expect(published).toEqual([
-      {
-        sessionId: 'session-1',
-        state: {
-          state: 'monitoring',
-          supportsStopAll: false,
-          tasks: [{ id: `codex-agent:${CHILD_ID}`, kind: 'agent', description: 'count_a' }]
-        }
-      }
-    ])
-    expect(adapter.backgroundTaskState('session-1')).toEqual(published[0].state)
+    // Turn end is not the child's outcome: no republish and no settle.
+    expect(published).toEqual([])
+    expect(adapter.backgroundTaskState('session-1')).toEqual(running)
   })
 
   it('clears the strip when the session closes', async () => {
diff --git a/src/main/ipc/runtime.ts b/src/main/ipc/runtime.ts
index 6237b8d040d..81de25d66c0 100644
--- a/src/main/ipc/runtime.ts
+++ b/src/main/ipc/runtime.ts
@@ -11,6 +11,7 @@ import type { RuntimeRpcResponse } from '../../shared/runtime-rpc-envelope'
 import type { ClientHostedBrowserRowsEvent } from '../../shared/client-hosted-browser-rows'
 import { TERMINAL_FIT_RESTORE_DEADLINE_MS } from '../../shared/terminal-fit-restore-deadline'
 import {
+  AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
   AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
   CLAUDE_STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY,
   STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY
@@ -82,6 +83,7 @@ export function registerRuntimeHandlers(runtime: OrcaRuntimeService): void {
           connectionId: desktopSenders.connectionIdFor(event.sender),
           clientCapabilities: [
             AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
+            AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
             STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY,
             CLAUDE_STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY
           ]
@@ -131,6 +133,7 @@ export function registerRuntimeHandlers(runtime: OrcaRuntimeService): void {
             connectionId,
             clientCapabilities: [
               AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
+              AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
               STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY,
               CLAUDE_STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY
             ]
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.test.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.test.ts
index 42d03f46b5b..5a3370c910f 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command-admission.test.ts
@@ -45,4 +45,26 @@ describe('conversationCommandBlocked background tasks', () => {
     )
     expect(blocked).toBe('Wait for background tasks to finish before using this command.')
   })
+
+  it('still refuses on the open turn, not on the work the strip now shows', () => {
+    // The strip reports subagents while a turn runs. That must not change which
+    // refusal the user sees: an open turn already refuses, and it refuses first,
+    // so a live fan-out never re-labels the reason or blocks anything new.
+    const ctx = contextWith({ state: 'monitoring', supportsTaskStop: true })
+    ctx.journal.snapshot = () =>
+      ({
+        items: [
+          {
+            id: 'turn-1',
+            body: {
+              kind: 'status',
+              turnLifecycle: { turnId: 'turn-1', state: 'running' }
+            }
+          }
+        ]
+      }) as unknown as ReturnType<typeof ctx.journal.snapshot>
+    expect(conversationCommandBlocked(ctx, RECORD)).toBe(
+      'Wait for the current turn to finish before using this command.'
+    )
+  })
 })
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-background-task-capability.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-background-task-capability.test.ts
index cc5a7282080..2b62b00525e 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-background-task-capability.test.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-background-task-capability.test.ts
@@ -1,6 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { AgentSessionBackgroundTaskState } from '../../../../shared/agent-session-wire'
-import { AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY } from '../../../../shared/protocol-version'
+import {
+  AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
+  AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY
+} from '../../../../shared/protocol-version'
 import { remoteRuntimeClientCapabilities } from '../../../../shared/remote-runtime-client-capabilities'
 import type { AgentSessionSubscribeInput } from '../../../native-chat/agent-session-wire/structured-agent-session-subscribers'
 import {
@@ -24,6 +27,20 @@ const CURRENT_CLIENT = {
   ...STRUCTURED_CLIENT,
   clientCapabilities: remoteRuntimeClientCapabilities(STRUCTURED_CLIENT.clientCapabilities)
 }
+/** Understands a stopless roster, but predates per-row stoppability. */
+const STOP_ONLY_CLIENT = {
+  ...STRUCTURED_CLIENT,
+  clientCapabilities: remoteRuntimeClientCapabilities(STRUCTURED_CLIENT.clientCapabilities).filter(
+    (capability) => capability !== AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY
+  )
+}
+const FOREGROUND_ROW = { id: 'fore', kind: 'agent', stoppable: false } as const
+const BACKGROUNDED_ROW = { id: 'back', kind: 'agent' } as const
+const MIXED_ROWS: AgentSessionBackgroundTaskState = {
+  state: 'monitoring',
+  supportsTaskStop: true,
+  tasks: [FOREGROUND_ROW, BACKGROUNDED_ROW]
+}
 
 describe('background-task stop capability at the RPC boundary', () => {
   it('advertises reader support on remote requests and subscriptions', () => {
@@ -93,6 +110,58 @@ describe('background-task stop capability at the RPC boundary', () => {
     }
   )
 
+  it('advertises row-stop support separately from stop support', () => {
+    // A client can advertise the stop capability and still predate `stoppable`,
+    // so the two must not be conflated.
+    expect(CURRENT_CLIENT.clientCapabilities).toContain(
+      AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY
+    )
+    expect(STOP_ONLY_CLIENT.clientCapabilities).not.toContain(
+      AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY
+    )
+  })
+
+  it.each([
+    ['row-stop reader', () => CURRENT_CLIENT, MIXED_ROWS],
+    [
+      'stop-only reader',
+      () => STOP_ONLY_CLIENT,
+      { state: 'monitoring', tasks: [BACKGROUNDED_ROW] }
+    ],
+    ['in-process reader', () => undefined, MIXED_ROWS]
+  ] as const)('projects unstoppable rows for a %s', async (_label, client, expected) => {
+    hostCalls.history.mockReturnValue({
+      ok: true,
+      page: { items: [], backgroundTasks: MIXED_ROWS }
+    })
+    expect(
+      await call('agentSession.history', { sessionId: SESSION, direction: 'tail' }, client())
+    ).toMatchObject({ ok: true, result: { page: { backgroundTasks: expected } } })
+  })
+
+  it('hands a reader that predates the field no strip when every row is unstoppable', async () => {
+    // Its pre-feature view exactly: the host published no foreground rows at all.
+    const foregroundOnly = {
+      state: 'monitoring' as const,
+      supportsTaskStop: true,
+      tasks: [{ id: 'fore', kind: 'agent' as const, stoppable: false }]
+    }
+    hostCalls.history.mockReturnValue({
+      ok: true,
+      page: { items: [], backgroundTasks: foregroundOnly }
+    })
+    expect(
+      await call(
+        'agentSession.history',
+        { sessionId: SESSION, direction: 'tail' },
+        STOP_ONLY_CLIENT
+      )
+    ).toMatchObject({ ok: true, result: { page: { backgroundTasks: null } } })
+    expect(
+      await call('agentSession.history', { sessionId: SESSION, direction: 'tail' }, CURRENT_CLIENT)
+    ).toMatchObject({ ok: true, result: { page: { backgroundTasks: foregroundOnly } } })
+  })
+
   it('preserves legacy stoppable state for both readers', async () => {
     const stoppable = { state: 'monitoring', tasks: TASKS.tasks }
     hostCalls.history.mockReturnValue({ ok: true, page: { items: [], backgroundTasks: stoppable } })
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-background-task-capability.ts b/src/main/runtime/rpc/methods/structured-agent-session-background-task-capability.ts
index 02afc5569bf..ae69de4a069 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-background-task-capability.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-background-task-capability.ts
@@ -3,7 +3,10 @@ import type {
   AgentSessionHistoryResult,
   AgentSessionSubscribeEvent
 } from '../../../../shared/agent-session-wire'
-import { AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY } from '../../../../shared/protocol-version'
+import {
+  AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
+  AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY
+} from '../../../../shared/protocol-version'
 import type { RpcContext } from '../core'
 
 type BackgroundTaskReader = Pick<RpcContext, 'clientKind' | 'clientCapabilities'>
@@ -15,14 +18,37 @@ function supportsReadOnlyTasks(ctx: BackgroundTaskReader): boolean {
   )
 }
 
+function honoursRowStop(ctx: BackgroundTaskReader): boolean {
+  return (
+    ctx.clientKind === undefined ||
+    ctx.clientCapabilities?.includes(AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY) === true
+  )
+}
+
+/** A reader that predates `stoppable` draws a per-row stop on every row it is
+ *  handed, and the host cannot honour one on a row marked unstoppable — the
+ *  dead button the field exists to remove. The host publishing such rows at all
+ *  is new, so withholding them hands that reader exactly its pre-feature view;
+ *  a state whose every row is withheld becomes no strip, as it was. */
+function withoutUnstoppableRows(
+  state: AgentSessionBackgroundTaskState
+): AgentSessionBackgroundTaskState | null {
+  if (!state.tasks?.some((task) => task.stoppable === false)) {
+    return state
+  }
+  const tasks = state.tasks.filter((task) => task.stoppable !== false)
+  return tasks.length > 0 ? { ...state, tasks } : null
+}
+
 function projectState(
   state: AgentSessionBackgroundTaskState | null | undefined,
   ctx: BackgroundTaskReader
 ): AgentSessionBackgroundTaskState | null | undefined {
+  const rows = !state || honoursRowStop(ctx) ? state : withoutUnstoppableRows(state)
   // Legacy readers always offer a stop; retain their pre-producer empty strip.
-  return state?.supportsStopAll === false && !state.supportsTaskStop && !supportsReadOnlyTasks(ctx)
+  return rows?.supportsStopAll === false && !rows.supportsTaskStop && !supportsReadOnlyTasks(ctx)
     ? null
-    : state
+    : rows
 }
 
 export function projectBackgroundTaskHistory(
diff --git a/src/renderer/src/components/native-chat/NativeChatBackgroundTasksStatus.test.tsx b/src/renderer/src/components/native-chat/NativeChatBackgroundTasksStatus.test.tsx
index 96be91820a3..365be31cc47 100644
--- a/src/renderer/src/components/native-chat/NativeChatBackgroundTasksStatus.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatBackgroundTasksStatus.test.tsx
@@ -3,7 +3,7 @@
 import '@testing-library/jest-dom/vitest'
 
 import { act, cleanup, fireEvent, render, screen, within } from '@testing-library/react'
-import { Profiler } from 'react'
+import { Profiler, useState } from 'react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { AgentSessionBackgroundTask } from '../../../../shared/agent-session-wire'
 import { NativeChatBackgroundTasksStatus } from './NativeChatBackgroundTasksStatus'
@@ -13,6 +13,24 @@ afterEach(() => {
   vi.useRealTimers()
 })
 
+/** The strip's disclosure is parent-owned, because the strip unmounts whenever
+ *  live work momentarily drops to nothing; this stands in for that owner. */
+function DisclosureHost(
+  props: Omit<
+    Parameters<typeof NativeChatBackgroundTasksStatus>[0],
+    'expanded' | 'onExpandedChange'
+  >
+): React.JSX.Element {
+  const [expanded, setExpanded] = useState(false)
+  return (
+    <NativeChatBackgroundTasksStatus
+      {...props}
+      expanded={expanded}
+      onExpandedChange={setExpanded}
+    />
+  )
+}
+
 const TASKS: AgentSessionBackgroundTask[] = [
   { id: 'codex-agent:child-1', kind: 'agent', description: 'count_a' },
   { id: 'codex-command:exec-1', kind: 'command', description: 'sleep 90' }
@@ -23,7 +41,7 @@ function renderStrip(props: { supportsTaskStop: boolean; supportsStopAll: boolea
 } {
   const onStop = vi.fn()
   render(
-    <NativeChatBackgroundTasksStatus
+    <DisclosureHost
       isVisible
       tasks={TASKS}
       settledTasks={[]}
@@ -51,6 +69,33 @@ describe('NativeChatBackgroundTasksStatus stop affordances', () => {
     expect(screen.getByLabelText('Stop background tasks')).toBeInTheDocument()
   })
 
+  it('withholds a row stop the host reported it cannot act on', () => {
+    // Claude publishes in-turn foreground rows with `stoppable: false`: the
+    // session accepts targeted stops, but `stopTask` has no target for this row,
+    // so a Stop here resolves to an empty list and reports nothing cancelled.
+    render(
+      <DisclosureHost
+        isVisible
+        tasks={[
+          { id: 'fore-1', kind: 'agent', description: 'in-turn subagent', stoppable: false },
+          { id: 'back-1', kind: 'agent', description: 'backgrounded subagent' }
+        ]}
+        settledTasks={[]}
+        indicatorActive
+        supportsTaskStop
+        supportsStopAll
+        stoppingTaskIds={new Set()}
+        stoppingAll={false}
+        onStop={vi.fn()}
+      />
+    )
+    fireEvent.click(screen.getByRole('button', { expanded: false }))
+
+    expect(screen.getByText('in-turn subagent')).toBeInTheDocument()
+    expect(screen.queryByLabelText('Stop in-turn subagent')).not.toBeInTheDocument()
+    expect(screen.getByLabelText('Stop backgrounded subagent')).toBeInTheDocument()
+  })
+
   it('offers no stop at all when the provider exposes none', () => {
     // Codex: a Stop button here would be a control that cannot act.
     renderStrip({ supportsTaskStop: false, supportsStopAll: false })
@@ -64,7 +109,7 @@ describe('NativeChatBackgroundTasksStatus stop affordances', () => {
 describe('background-tasks strip header', () => {
   function renderHeader(tasks: AgentSessionBackgroundTask[]): HTMLElement {
     render(
-      <NativeChatBackgroundTasksStatus
+      <DisclosureHost
         isVisible
         tasks={tasks}
         settledTasks={[]}
@@ -111,7 +156,7 @@ describe('background-tasks strip header', () => {
 
   it('dims the monitor amber while a turn owns the voice', () => {
     render(
-      <NativeChatBackgroundTasksStatus
+      <DisclosureHost
         isVisible
         tasks={[{ id: 'm1', kind: 'monitor' }]}
         settledTasks={[]}
@@ -176,7 +221,7 @@ describe('settled rows beside their live siblings', () => {
   // usage it ended on, and stops claiming a clock or a stop control.
   it('keeps a settled row with its final usage, no clock and no stop', () => {
     render(
-      <NativeChatBackgroundTasksStatus
+      <DisclosureHost
         isVisible
         tasks={[
           {
@@ -220,7 +265,7 @@ describe('settled rows beside their live siblings', () => {
 describe('background-task row reasons', () => {
   function expandedRows(tasks: AgentSessionBackgroundTask[]): HTMLElement[] {
     render(
-      <NativeChatBackgroundTasksStatus
+      <DisclosureHost
         isVisible
         tasks={tasks}
         settledTasks={[]}
@@ -261,6 +306,8 @@ it('stops elapsed renders in a hidden pane and catches up on reveal', () => {
   const view = (isVisible: boolean) => (
     <Profiler id="strip" onRender={committed}>
       <NativeChatBackgroundTasksStatus
+        expanded={false}
+        onExpandedChange={() => {}}
         isVisible={isVisible}
         tasks={[{ id: 'shell', kind: 'command', startedAt: 1_000 }]}
         settledTasks={[]}
diff --git a/src/renderer/src/components/native-chat/NativeChatBackgroundTasksStatus.tsx b/src/renderer/src/components/native-chat/NativeChatBackgroundTasksStatus.tsx
index 21b8d73f258..d9bef4e6099 100644
--- a/src/renderer/src/components/native-chat/NativeChatBackgroundTasksStatus.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatBackgroundTasksStatus.tsx
@@ -62,6 +62,15 @@ function kindIconTone(kind: AgentSessionBackgroundTask['kind'], dimmed: boolean)
   return dimmed ? `${tone}/40` : tone
 }
 
+/** Absent means stoppable: a host predating the field published only rows its
+ *  stop could act on, so reading absence as "not stoppable" would hide a
+ *  working control. Only an explicit `false` withholds the button — Claude
+ *  marks its in-turn foreground rows that way, and a Stop on one of those
+ *  resolves to an empty target list and silently reports nothing cancelled. */
+function backgroundTaskStoppable(task: AgentSessionBackgroundTask): boolean {
+  return task.stoppable !== false
+}
+
 function BackgroundTaskRow(props: {
   entry: BackgroundRosterTask
   now: number
@@ -100,7 +109,7 @@ function BackgroundTaskRow(props: {
           {meta}
         </span>
       ) : null}
-      {!entry.settled && props.supportsTaskStop ? (
+      {!entry.settled && props.supportsTaskStop && backgroundTaskStoppable(entry.task) ? (
         <Button
           type="button"
           variant="ghost"
@@ -135,9 +144,16 @@ export function NativeChatBackgroundTasksStatus(props: {
    *  animated monitoring indicator. A running turn owns the voice. */
   indicatorActive: boolean
   isVisible: boolean
+  /** Owned by the parent. The strip is mounted on live work, so it disappears
+   *  and comes back whenever the roster momentarily empties between two pieces
+   *  of a sequential fan-out — settled rows are flushed at that same instant
+   *  and hold nothing open — and local state would collapse the list on every
+   *  such gap. */
+  expanded: boolean
+  onExpandedChange: (expanded: boolean) => void
   onStop: (taskId?: string) => void
 }): React.JSX.Element {
-  const [expanded, setExpanded] = useState(false)
+  const expanded = props.expanded
   const taskListId = useId()
   const stripRef = useRef<HTMLDivElement>(null)
   const narrow = useNarrowStrip(stripRef)
@@ -170,7 +186,7 @@ export function NativeChatBackgroundTasksStatus(props: {
             aria-expanded={expanded}
             aria-controls={taskListId}
             aria-label={headerText}
-            onClick={() => setExpanded((current) => !current)}
+            onClick={() => props.onExpandedChange(!expanded)}
           >
             <span className="min-w-0 truncate">
               {header.segments.map((segment, index) => {
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
index 81ff9ba555d..f50ab8bebc0 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
@@ -243,7 +243,9 @@ describe('NativeChatStructuredSession', () => {
     }
   )
 
-  // Every background-task test mounts the same local Claude session; only the ids differ.
+  // Every background-task test mounts the same local Claude session; only the ids
+  // differ. A fresh element per call also matters for the rerenders below: React
+  // bails out of re-rendering an identical one.
   const claudeSessionView = (tabId: string, sessionId: string) => (
     <NativeChatStructuredSession
       isVisible
@@ -254,7 +256,7 @@ describe('NativeChatStructuredSession', () => {
     />
   )
 
-  it('places background monitoring above the usable composer and stops without an active turn', async () => {
+  it('places background monitoring above the usable composer, keeps its list open across a gap in live work, and stops without an active turn', async () => {
     mocks.monitoringBackgroundTasks = true
     mocks.supportsBackgroundTaskStop = true
     mocks.backgroundTasks = [
@@ -263,7 +265,9 @@ describe('NativeChatStructuredSession', () => {
     ]
     mocks.stopBackgroundTask.mockResolvedValue({ cancelled: true })
 
-    render(claudeSessionView('structured-tab-background', 'session-background'))
+    const { rerender } = render(
+      claudeSessionView('structured-tab-background', 'session-background')
+    )
 
     const disclosure = screen.getByRole('button', { name: '1 agent · 1 shell' })
     const status = disclosure.closest('[data-native-chat-background-tasks="true"]')
@@ -288,6 +292,17 @@ describe('NativeChatStructuredSession', () => {
     await waitFor(() =>
       expect(mocks.stopBackgroundTask).toHaveBeenCalledWith('session-background', 'task-command')
     )
+
+    // The strip is mounted on live work, and settled rows are flushed the instant
+    // the last live one ends, so a sequential fan-out unmounts it between one
+    // subagent finishing and the next starting. The disclosure is not the
+    // strip's to forget in that gap.
+    mocks.monitoringBackgroundTasks = false
+    rerender(claudeSessionView('structured-tab-background', 'session-background'))
+    expect(document.querySelector('[data-native-chat-background-tasks="true"]')).toBeNull()
+    mocks.monitoringBackgroundTasks = true
+    rerender(claudeSessionView('structured-tab-background', 'session-background'))
+    expect(screen.getByRole('list', { name: 'Agents' })).toBeTruthy()
   })
 
   it('keeps the strip mounted through a running turn, with the turn owning the voice', () => {
@@ -373,6 +388,8 @@ describe('NativeChatStructuredSession', () => {
     fireEvent.click(screen.getByRole('button', { name: 'Stop Shared task' }))
 
     rerender(claudeSessionView('structured-tab-stale-background', 'session-current'))
+    // The disclosure is keyed by session, so a new session opens collapsed.
+    fireEvent.click(screen.getByRole('button', { name: '1 shell command — working' }))
     const currentStop = screen.getByRole('button', { name: 'Stop Shared task' })
     expect((currentStop as HTMLButtonElement).disabled).toBe(false)
     fireEvent.click(currentStop)
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index faa67c87338..06a726134a8 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -30,6 +30,8 @@ type StoppingBackgroundTasks = {
 
 const NO_STOPPING_TASKS: ReadonlySet<string> = new Set()
 
+type ExpandedBackgroundTasks = { sessionId: string; expanded: boolean }
+
 function encodeQuestionAnswer(questionId: string, answer: string): string {
   return `${encodeURIComponent(questionId)}:${encodeURIComponent(answer)}`
 }
@@ -41,6 +43,10 @@ export function NativeChatStructuredSession(
   const [composerError, setComposerError] = useState<string | null>(null)
   const [stoppingBackgroundTasks, setStoppingBackgroundTasks] =
     useState<StoppingBackgroundTasks | null>(null)
+  // Held here, not in the strip: the strip unmounts whenever live work briefly
+  // drops to nothing, and its own state would collapse the list each time.
+  const [expandedBackgroundTasks, setExpandedBackgroundTasks] =
+    useState<ExpandedBackgroundTasks | null>(null)
   const [optionPickerRequest, setOptionPickerRequest] = useState<{
     id: string
     sequence: number
@@ -314,6 +320,13 @@ export function NativeChatStructuredSession(
           supportsStopAll={controller.backgroundTasks.supportsStopAll}
           stoppingTaskIds={activeStoppingBackgroundTasks?.taskIds ?? NO_STOPPING_TASKS}
           stoppingAll={activeStoppingBackgroundTasks?.all ?? false}
+          expanded={
+            expandedBackgroundTasks?.sessionId === props.sessionId &&
+            expandedBackgroundTasks.expanded
+          }
+          onExpandedChange={(expanded) =>
+            setExpandedBackgroundTasks({ sessionId: props.sessionId, expanded })
+          }
           onStop={(taskId) => {
             const targetSessionId = props.sessionId
             setStoppingBackgroundTasks((current) => {
diff --git a/src/renderer/src/components/native-chat/structured-session-background-tasks-view.ts b/src/renderer/src/components/native-chat/structured-session-background-tasks-view.ts
index 3765d7daf6a..a79e97f705a 100644
--- a/src/renderer/src/components/native-chat/structured-session-background-tasks-view.ts
+++ b/src/renderer/src/components/native-chat/structured-session-background-tasks-view.ts
@@ -1,8 +1,11 @@
 // The background-tasks strip's view of one session's wire state.
 //
-// The strip stands for work that OUTLIVES a turn. It stays mounted through a
-// running turn — a fan-out's children keep reporting long after the parent
-// settles — but only an idle session lets it animate or speak for itself.
+// The strip reports work that is IN FLIGHT, whether or not it outlived a turn:
+// a fan-out's children keep reporting long after the parent settles, and a
+// foreground fan-out is running work while the turn is still open. It stays
+// mounted through a running turn — turn state is not a filter on the rows,
+// because the producers publish only tasks they still have live evidence for.
+// Only an idle session lets it animate or speak for itself.
 
 import type {
   AgentSessionBackgroundTask,
diff --git a/src/renderer/src/web/web-runtime-client.test.ts b/src/renderer/src/web/web-runtime-client.test.ts
index 171d48455f2..8bc2d66adc7 100644
--- a/src/renderer/src/web/web-runtime-client.test.ts
+++ b/src/renderer/src/web/web-runtime-client.test.ts
@@ -12,6 +12,7 @@ import {
 } from '../../../shared/e2ee-crypto'
 import type { RuntimeRpcResponse } from '../../../shared/runtime-rpc-envelope'
 import {
+  AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
   AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY,
   SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY,
   SESSION_TABS_RETIREMENT_PROOF_DELTA_RUNTIME_CAPABILITY,
@@ -86,6 +87,7 @@ describe('WebRuntimeClient', () => {
       type: 'e2ee_auth',
       deviceToken: 'token',
       clientCapabilities: [
+        AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
         SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY,
         SESSION_TABS_RETIREMENT_PROOF_DELTA_RUNTIME_CAPABILITY,
         AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY,
diff --git a/src/renderer/src/web/web-runtime-connection-frame-router.ts b/src/renderer/src/web/web-runtime-connection-frame-router.ts
index fe089be80ef..bb0d51b1380 100644
--- a/src/renderer/src/web/web-runtime-connection-frame-router.ts
+++ b/src/renderer/src/web/web-runtime-connection-frame-router.ts
@@ -1,6 +1,7 @@
 import type { RuntimeRpcResponse } from '../../../shared/runtime-rpc-envelope'
 import { isKeepaliveFrame } from '../../../shared/runtime-rpc-envelope'
 import {
+  AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
   AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY,
   SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY,
   SESSION_TABS_RETIREMENT_PROOF_DELTA_RUNTIME_CAPABILITY,
@@ -58,6 +59,7 @@ export async function routeWebRuntimeConnectionFrame(
           type: 'e2ee_auth',
           deviceToken: context.pairingToken,
           clientCapabilities: [
+            AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
             SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY,
             SESSION_TABS_RETIREMENT_PROOF_DELTA_RUNTIME_CAPABILITY,
             AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY,
diff --git a/src/shared/agent-session-background-task-wire.ts b/src/shared/agent-session-background-task-wire.ts
new file mode 100644
index 00000000000..c5e6893fb0b
--- /dev/null
+++ b/src/shared/agent-session-background-task-wire.ts
@@ -0,0 +1,83 @@
+// The background-tasks half of the agent-session wire: the per-task row, the
+// roster state that carries it, and the field equality both the client reducer
+// and the host status feed compare with. Split out of `agent-session-wire.ts`
+// when that file reached its line budget; the definitions below are unchanged.
+
+/** Per-task run state, reusing the agent-state vocabulary the dashboard already
+ *  renders. Optional on the wire: an old host sends none and clients fall back
+ *  to kind-derived defaults. */
+export type AgentSessionBackgroundTaskRunState =
+  | 'working'
+  | 'monitoring'
+  | 'waiting'
+  | 'blocked'
+  | 'done'
+  | 'idle'
+  | 'unverifiable'
+
+export type AgentSessionBackgroundTask = {
+  id: string
+  kind: 'agent' | 'workflow' | 'command' | 'monitor' | 'unknown'
+  description?: string
+  /** Provider-reported identity (e.g. a subagent type). `description` stays the
+   *  display name; this is the fallback when the description is absent. */
+  name?: string
+  state?: AgentSessionBackgroundTaskRunState
+  /** Host epoch ms when the task was first observed, so clients render elapsed. */
+  startedAt?: number
+  /** Cumulative provider-reported token usage, where the provider supplies it. */
+  totalTokens?: number
+  /** Whether this row's own stop can act on it. Absent means yes: every host
+   *  that predates this field published only backgrounded, stoppable rows, and
+   *  a client that read absence as "not stoppable" would hide a working control
+   *  on those hosts. A row the host cannot target sends `false`. */
+  stoppable?: boolean
+}
+
+export type AgentSessionBackgroundTaskState = {
+  state: 'monitoring'
+  /** Optional so mixed-version clients can consume state-only hosts. */
+  tasks?: AgentSessionBackgroundTask[]
+  /** Terminal-state siblings of a still-live roster, kept apart from `tasks`
+   *  so old clients keep rendering exactly the live set they render today. */
+  settledTasks?: AgentSessionBackgroundTask[]
+  /** Optional so clients only send targeted stops to hosts that accept them. */
+  supportsTaskStop?: boolean
+  /** Whether an untargeted "stop everything" is available at all. Absent means
+   *  yes: every host that predates this field accepted one, and a client that
+   *  read absence as "no stop" would hide a working control on those hosts.
+   *  A host whose provider exposes no honest stop sends `false`. */
+  supportsStopAll?: boolean
+}
+
+function backgroundTaskFieldsEqual(
+  left: AgentSessionBackgroundTask,
+  right: AgentSessionBackgroundTask
+): boolean {
+  return (
+    left.id === right.id &&
+    left.kind === right.kind &&
+    left.description === right.description &&
+    left.name === right.name &&
+    left.state === right.state &&
+    left.startedAt === right.startedAt &&
+    left.totalTokens === right.totalTokens &&
+    left.stoppable === right.stoppable
+  )
+}
+
+/** Field equality for task lists, shared by the client reducer and the host
+ *  status feed so a publish whose only change is one task's state is never
+ *  judged equal and dropped. */
+export function agentSessionBackgroundTasksEqual(
+  left: AgentSessionBackgroundTask[] | undefined,
+  right: AgentSessionBackgroundTask[] | undefined
+): boolean {
+  if (left === right) {
+    return true
+  }
+  if (!left || !right || left.length !== right.length) {
+    return false
+  }
+  return left.every((task, index) => backgroundTaskFieldsEqual(task, right[index]))
+}
diff --git a/src/shared/agent-session-wire.ts b/src/shared/agent-session-wire.ts
index 854f02e74e1..9b7b4f7e76f 100644
--- a/src/shared/agent-session-wire.ts
+++ b/src/shared/agent-session-wire.ts
@@ -1,3 +1,7 @@
+import type {
+  AgentSessionBackgroundTask,
+  AgentSessionBackgroundTaskState
+} from './agent-session-background-task-wire'
 import type { AgentSessionRewindReason, AgentSessionRewindSupport } from './agent-session-rewind'
 import type { AgentSessionConversationCommand } from './agent-session-conversation-command'
 // ─── Structured agent-session wire contract ─────────────────────────────────
@@ -56,78 +60,12 @@ export type AgentSessionHandoffRequest = {
 
 export type AgentSessionHandoffResult = { status: AgentSessionHandoffStatus }
 
-/** Per-task run state, reusing the agent-state vocabulary the dashboard already
- *  renders. Optional on the wire: an old host sends none and clients fall back
- *  to kind-derived defaults. */
-export type AgentSessionBackgroundTaskRunState =
-  | 'working'
-  | 'monitoring'
-  | 'waiting'
-  | 'blocked'
-  | 'done'
-  | 'idle'
-  | 'unverifiable'
-
-export type AgentSessionBackgroundTask = {
-  id: string
-  kind: 'agent' | 'workflow' | 'command' | 'monitor' | 'unknown'
-  description?: string
-  /** Provider-reported identity (e.g. a subagent type). `description` stays the
-   *  display name; this is the fallback when the description is absent. */
-  name?: string
-  state?: AgentSessionBackgroundTaskRunState
-  /** Host epoch ms when the task was first observed, so clients render elapsed. */
-  startedAt?: number
-  /** Cumulative provider-reported token usage, where the provider supplies it. */
-  totalTokens?: number
-}
-
-export type AgentSessionBackgroundTaskState = {
-  state: 'monitoring'
-  /** Optional so mixed-version clients can consume state-only hosts. */
-  tasks?: AgentSessionBackgroundTask[]
-  /** Terminal-state siblings of a still-live roster, kept apart from `tasks`
-   *  so old clients keep rendering exactly the live set they render today. */
-  settledTasks?: AgentSessionBackgroundTask[]
-  /** Optional so clients only send targeted stops to hosts that accept them. */
-  supportsTaskStop?: boolean
-  /** Whether an untargeted "stop everything" is available at all. Absent means
-   *  yes: every host that predates this field accepted one, and a client that
-   *  read absence as "no stop" would hide a working control on those hosts.
-   *  A host whose provider exposes no honest stop sends `false`. */
-  supportsStopAll?: boolean
-}
-
-function backgroundTaskFieldsEqual(
-  left: AgentSessionBackgroundTask,
-  right: AgentSessionBackgroundTask
-): boolean {
-  return (
-    left.id === right.id &&
-    left.kind === right.kind &&
-    left.description === right.description &&
-    left.name === right.name &&
-    left.state === right.state &&
-    left.startedAt === right.startedAt &&
-    left.totalTokens === right.totalTokens
-  )
-}
-
-/** Field equality for task lists, shared by the client reducer and the host
- *  status feed so a publish whose only change is one task's state is never
- *  judged equal and dropped. */
-export function agentSessionBackgroundTasksEqual(
-  left: AgentSessionBackgroundTask[] | undefined,
-  right: AgentSessionBackgroundTask[] | undefined
-): boolean {
-  if (left === right) {
-    return true
-  }
-  if (!left || !right || left.length !== right.length) {
-    return false
-  }
-  return left.every((task, index) => backgroundTaskFieldsEqual(task, right[index]))
-}
+export type {
+  AgentSessionBackgroundTask,
+  AgentSessionBackgroundTaskRunState,
+  AgentSessionBackgroundTaskState
+} from './agent-session-background-task-wire'
+export { agentSessionBackgroundTasksEqual } from './agent-session-background-task-wire'
 
 export type AgentSessionTurnActivity = {
   turnId: string
diff --git a/src/shared/protocol-version.ts b/src/shared/protocol-version.ts
index 74317dd28c1..beeb37a5faa 100644
--- a/src/shared/protocol-version.ts
+++ b/src/shared/protocol-version.ts
@@ -166,6 +166,13 @@ export const AGENT_SESSION_REWIND_RUNTIME_CAPABILITY = 'agent-session.rewind.v1'
 // Readers must understand a monitoring roster with no available stop control.
 export const AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY =
   'agent-session.background-task-stop.v1' as const
+// Why: the host now publishes rows for work that is live inside a turn, and such
+// a row carries `stoppable: false` because no targeted stop can reach it. A
+// reader that predates the field draws a per-row Stop on every row it is given,
+// so it must be told apart from one that honours the field — and NOT by the
+// stop capability above, which a client can advertise while predating this.
+export const AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY =
+  'agent-session.background-task-row-stop.v1' as const
 // Why: adding kimi to RESUMABLE_TUI_AGENTS grows terminal.ensureAgentSession's enum, and an
 // older host answers the unknown member with invalid_argument — a code the launch fallback does
 // not retry on — so clients must probe before taking the host-authority path.
@@ -273,6 +280,7 @@ export const RUNTIME_CAPABILITIES = [
   AGENT_SESSION_STATUS_FEED_RUNTIME_CAPABILITY,
   AGENT_SESSION_REWIND_RUNTIME_CAPABILITY,
   AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
+  AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
   AGENT_SESSION_KIMI_RESUME_RUNTIME_CAPABILITY,
   FILE_MUTATION_OWNERSHIP_RUNTIME_CAPABILITY,
   GITHUB_MARK_PR_READY_RUNTIME_CAPABILITY,
diff --git a/src/shared/remote-runtime-client-capabilities.ts b/src/shared/remote-runtime-client-capabilities.ts
index 456f90e25ad..21e6bb145fa 100644
--- a/src/shared/remote-runtime-client-capabilities.ts
+++ b/src/shared/remote-runtime-client-capabilities.ts
@@ -1,4 +1,5 @@
 import {
+  AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
   AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
   AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY,
   AUTOMATION_OWNER_FENCING_RUNTIME_CAPABILITY,
@@ -18,6 +19,7 @@ export function remoteRuntimeClientCapabilities(
   return Array.from(
     new Set([
       AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
+      AGENT_SESSION_BACKGROUND_TASK_ROW_STOP_CAPABILITY,
       SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY,
       SESSION_TABS_AUTHORITATIVE_INVENTORY_RUNTIME_CAPABILITY,
       AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY,
diff --git a/src/shared/structured-agent-session-reducer.test.ts b/src/shared/structured-agent-session-reducer.test.ts
index f617db975f5..b72e413d39a 100644
--- a/src/shared/structured-agent-session-reducer.test.ts
+++ b/src/shared/structured-agent-session-reducer.test.ts
@@ -87,6 +87,46 @@ describe('structured agent session reducer', () => {
     expect(updated.items).toBe(initial.items)
   })
 
+  it("republishes when only a row's stoppability changes", () => {
+    // A row losing its stop is the whole difference between an honest control
+    // and a dead one, so it must not be dropped as an equal state.
+    const backgroundTasks = {
+      state: 'monitoring' as const,
+      supportsTaskStop: true,
+      tasks: [{ id: 'task-1', kind: 'agent' as const }]
+    }
+    const initial = reduceStructuredAgentSession(EMPTY_STRUCTURED_AGENT_SESSION, {
+      type: 'event',
+      event: {
+        type: 'snapshot',
+        sessionId: 'session-a',
+        fence: 1,
+        page: { ...hydrationPage([]), backgroundTasks }
+      }
+    })
+    const updated = reduceStructuredAgentSession(initial, {
+      type: 'event',
+      event: {
+        type: 'batch',
+        sessionId: 'session-a',
+        batch: {
+          cursor: { epoch: 'epoch-a', sequence: 0 },
+          items: [],
+          removedItemIds: [],
+          submissions: []
+        },
+        backgroundTasks: {
+          ...backgroundTasks,
+          tasks: [{ id: 'task-1', kind: 'agent' as const, stoppable: false }]
+        }
+      }
+    })
+
+    expect(updated.backgroundTasks?.tasks).toEqual([
+      { id: 'task-1', kind: 'agent', stoppable: false }
+    ])
+  })
+
   it('uses the bounded hydration page pagination boundary', () => {
     const restored = reduceStructuredAgentSession(EMPTY_STRUCTURED_AGENT_SESSION, {
       type: 'event',