@@ -170,6 +170,8 @@ function setup(
   const busy: boolean[] = []
   /** Calls whose result the executor reported as reaching the model, in order. */
   const delivered: string[] = []
+  /** Calls Sim finished with without their real result reaching the model, in order. */
+  const notDelivered: string[] = []
   const executor = new DesktopExecutor({
     client: sim.client,
     journal,
@@ -180,12 +182,23 @@ function setup(
     onBusyChange: (value) => busy.push(value),
     onApprovals: (items) => approvals.push(items),
     onResultDelivered: (toolCallId) => delivered.push(toolCallId),
+    onResultNotDelivered: (toolCallId) => notDelivered.push(toolCallId),
     ...(options.maxHeldCalls ? { maxHeldCalls: options.maxHeldCalls } : {}),
     ...(options.deliveryAwakeLimitMs !== undefined
       ? { deliveryAwakeLimitMs: options.deliveryAwakeLimitMs }
       : {}),
   })
-  return { sim, journal, runner, executor, onUnregistered, busy, approvals, delivered }
+  return {
+    sim,
+    journal,
+    runner,
+    executor,
+    onUnregistered,
+    busy,
+    approvals,
+    delivered,
+    notDelivered,
+  }
 }
 
 describe('claiming', () => {
@@ -207,13 +220,13 @@ describe('claiming', () => {
   })
 
   it('reports a result as reaching the model only once Sim takes it as the call own', async () => {
-    const { sim, journal, runner, executor, delivered } = setup()
+    const { sim, journal, runner, executor, delivered, notDelivered } = setup()
     runner.immediate = DONE
     // Sim settled this call first: the result never reached the model.
     sim.completionOutcome = 'superseded'
     sim.inbox = [callItem('call-superseded', 'chat-a')]
     await executor.reconcile()
-    await vi.waitFor(() => expect(sim.completions).toHaveLength(1))
+    await vi.waitFor(() => expect(notDelivered).toEqual(['call-superseded']))
     expect(delivered).toEqual([])
 
     // Taken by Sim, even with nothing written locally (no OS encryption, say).
@@ -222,10 +235,40 @@ describe('claiming', () => {
     sim.inbox = [callItem('call-recorded', 'chat-a')]
     await executor.reconcile()
     await vi.waitFor(() => expect(delivered).toEqual(['call-recorded']))
+    expect(notDelivered).toEqual(['call-superseded'])
+  })
+
+  it('reports a result Sim settled first, while a failed send waited to retry, as never reaching the model', async () => {
+    const { sim, runner, executor, delivered, notDelivered } = setup()
+    // The terminal handed back a command still going, and the first send of that result fails.
+    runner.immediate = { status: 'success', message: 'running', data: { status: 'running' } }
+    sim.completeErrors = [new DeviceRequestError(503, 'unavailable')]
+    sim.inbox = [callItem('call-1', 'chat-a', 'terminal')]
+    await executor.reconcile()
+    await vi.waitFor(() => expect(runner.started).toEqual(['call-1']))
+
+    // The user pressed Stop meanwhile, so Sim settled the call before the retry reached it.
+    sim.completionOutcome = 'superseded'
+    sim.inbox = [{ kind: 'cancel', toolCallId: 'call-1' }]
+    await executor.reconcile()
+
+    await vi.waitFor(() => expect(notDelivered).toEqual(['call-1']))
+    expect(delivered).toEqual([])
+  })
+
+  it('reports a result Sim refused as never reaching the model', async () => {
+    const { sim, runner, executor, notDelivered } = setup()
+    runner.immediate = DONE
+    sim.completeErrors = [new DeviceRequestError(403, 'forbidden')]
+    sim.inbox = [callItem('call-refused', 'chat-a')]
+
+    await executor.reconcile()
+
+    await vi.waitFor(() => expect(notDelivered).toEqual(['call-refused']))
   })
 
   it('reports no result that stands in for what the action produced as reaching the model', async () => {
-    const { sim, runner, executor, delivered } = setup()
+    const { sim, runner, executor, delivered, notDelivered } = setup()
     const standIns: DesktopToolCompletion[] = [
       { status: 'cancelled', message: 'Stopped.' },
       { status: 'error', message: 'Too large.', data: { resultOmitted: true } },
@@ -243,6 +286,7 @@ describe('claiming', () => {
     sim.inbox = [callItem('real', 'chat-a')]
     await executor.reconcile()
     await vi.waitFor(() => expect(delivered).toEqual(['real']))
+    expect(notDelivered).toEqual(['stand-in-0', 'stand-in-1', 'stand-in-2', 'stand-in-3'])
   })
 
   it('claims a whole backlog at once, before any of it runs', async () => {
 
@@ -87,6 +87,12 @@ export interface DesktopExecutorOptions {
    * pane still running) is in use.
    */
   onResultDelivered?: (toolCallId: string) => void
+  /**
+   * Called once Sim is done with a call without taking its real result: it settled the call
+   * first, refused the result, or was sent one that stands in for it. The model never learns of
+   * anything the action handed back as still going, so nothing will come back to it.
+   */
+  onResultNotDelivered?: (toolCallId: string) => void
   maxHeldCalls?: number
   /** First delivery retry delay; tests shorten it. */
   retryBaseMs?: number
@@ -413,6 +419,7 @@ export class DesktopExecutor {
     sendingSince: number
   ): Promise<void> {
     let pending = completion
+    let delivered = false
     for (let attempt = 1; !this.disposed; attempt++) {
       try {
         const outcome = await this.options.client.complete({
@@ -422,9 +429,8 @@ export class DesktopExecutor {
         })
         logger.info('Desktop call result acknowledged', { toolCallId, outcome })
         // Superseded: Sim settled the call first, so this result never reached the model.
-        if (outcome !== 'superseded' && isDeliveredResult(pending)) {
-          this.options.onResultDelivered?.(toolCallId)
-        }
+        delivered = outcome !== 'superseded' && isDeliveredResult(pending)
+        if (delivered) this.options.onResultDelivered?.(toolCallId)
         break
       } catch (error) {
         // Encoding failed on this machine, so nothing was sent; the same data would fail again.
@@ -481,7 +487,9 @@ export class DesktopExecutor {
         )
       }
     }
-    if (!this.disposed) await this.forget(toolCallId)
+    if (this.disposed) return
+    if (!delivered) this.options.onResultNotDelivered?.(toolCallId)
+    await this.forget(toolCallId)
   }
 
   private async renew(entry: HeldCall): Promise<void> {
 
@@ -64,6 +64,8 @@ export interface DesktopExecutorServiceDeps {
   onBusyChange?: (busy: boolean) => void
   /** Sim has taken a call's real result as the call's own, so the model has it. */
   onResultDelivered?: (toolCallId: string) => void
+  /** Sim is done with a call whose real result the model never got. */
+  onResultNotDelivered?: (toolCallId: string) => void
 }
 
 export interface DesktopExecutorService {
@@ -275,6 +277,7 @@ export function createDesktopExecutorService(
         ...(deps.onApprovals ? { onApprovals: deps.onApprovals } : {}),
         ...(deps.onBusyChange ? { onBusyChange: deps.onBusyChange } : {}),
         ...(deps.onResultDelivered ? { onResultDelivered: deps.onResultDelivered } : {}),
+        ...(deps.onResultNotDelivered ? { onResultNotDelivered: deps.onResultNotDelivered } : {}),
       })
       // Recovery rewrites the journal, so what it held before is read first.
       await pendingResultsSnapshot()
 
@@ -610,6 +610,9 @@ function main(): void {
     // A result the model has makes a tmux run it handed back as still going collectable across a
     // restart.
     onResultDelivered: (toolCallId) => terminal.markRunDelivered(toolCallId),
+    // One the model never got leaves a run it handed back as still going with no one to come back
+    // to it, the rule the launch sweep applies to a previous process's runs.
+    onResultNotDelivered: (toolCallId) => void terminal.stopUndeliveredRun(toolCallId),
     runner: createDesktopToolRunner({
       preferences: () => desktopSettings.getPreferences(),
       accountDataAvailable,
 
@@ -938,6 +938,13 @@ export class TerminalService {
     await Promise.allSettled(stops)
   }
 
+  /** Stops the command a plain shell's `run` handed back as still going, if it still is. */
+  async stopAgentCommand(toolCallId: string): Promise<void> {
+    await Promise.allSettled(
+      [...this.sessions.values()].map((session) => this.stopCommand(session, toolCallId))
+    )
+  }
+
   /** Waits for the command a run started to end, up to `ms`. */
   private async commandEnds(
     session: TerminalSession,
 
@@ -119,6 +119,23 @@ describe('stopping recorded tmux runs', () => {
     expect(ledger.list()).toEqual([])
   })
 
+  it("stops only the run of a call whose result never reached the model, this process's or a previous one's", async () => {
+    const dir = ledgerDir()
+    createRunLedger(dir).record(run('previous', '%1'))
+    const ledger = createRunLedger(dir)
+    ledger.record(run('current', '%2'))
+    ledger.record(run('other', '%3'))
+    const registry = new TerminalRegistry(undefined, undefined, ledger)
+
+    await registry.stopUndeliveredRun('call-current')
+    await registry.stopUndeliveredRun('call-previous')
+
+    expect(panes.get('current')).toBe('stopped')
+    expect(panes.get('previous')).toBe('stopped')
+    expect(panes.get('other')).toBeUndefined()
+    expect(ledger.list().map((record) => record.runId)).toEqual(['other'])
+  })
+
   it('notes the run of a call whose result reached the model as handed back', () => {
     const dir = ledgerDir()
     const ledger = createRunLedger(dir)
 
@@ -410,23 +410,39 @@ export class TerminalRegistry {
     if (runId) this.runLedger?.advance(runId, 'delivered')
   }
 
+  /**
+   * Stops what a call's `run` handed back as still going once Sim is done with the call without
+   * its result reaching the model: a plain shell's command, or a tmux run, this process's or a
+   * previous one's.
+   */
+  async stopUndeliveredRun(callId: string): Promise<void> {
+    await Promise.allSettled(
+      [...this.entries.values()].map((entry) => entry.service.stopAgentCommand(callId))
+    )
+    await this.stopRecordedRuns({ callId })
+  }
+
   /**
    * Stops the recorded tmux runs, each only while its pane still carries its tag, and drops the
    * records with nothing left to stop. `excludeLive` skips the runs this process has started;
-   * `keep` names runs to leave going, such as a previous process's runs whose results the model
-   * already has and may come back to.
+   * `callId` limits it to the run that call started; `keep` names runs to leave going, such as a
+   * previous process's runs whose results the model already has and may come back to.
    */
   async stopRecordedRuns(
     options: {
       excludeLive?: boolean
+      callId?: string
       /** Runs to leave going; their records are only dropped once their panes are gone. */
       keep?: (run: RunRecord) => boolean
     } = {}
   ): Promise<void> {
     const ledger = this.runLedger
     if (!ledger) return
+    const runs = ledger
+      .list({ excludeLive: options.excludeLive })
+      .filter((run) => options.callId === undefined || run.callId === options.callId)
     await Promise.allSettled(
-      ledger.list({ excludeLive: options.excludeLive }).map(async (run) => {
+      runs.map(async (run) => {
         let keeping = options.keep?.(run) ?? false
         let state = keeping ? await recordedRunState(run, process.env) : 'ours'
         // A kept run whose command already ended leaves only its dead pane (`remain-on-exit`).
 
@@ -106,6 +106,8 @@ const { stubSessions } = vi.hoisted(() => ({
       setInterruptible(interruptible: boolean): void
       /** Ends the running command the way its process exiting would. */
       finishRun(exitCode: number): void
+      /** Returns the run as still going, its command left running, as a wait that ran out does. */
+      handBack(): void
       kill: ReturnType<typeof vi.fn>
       readonly runningToolCallId: string | null
     }
@@ -158,6 +160,11 @@ vi.mock('@/main/terminal/session', async () => {
             state.interruptible = interruptible
           },
           finishRun,
+          handBack: () => {
+            const resolve = state.resolveRun
+            state.resolveRun = null
+            resolve?.({ status: 'running', exitCode: null, terminalId })
+          },
           runCommand: (_command: string, toolCallId: string) =>
             new Promise((resolve) => {
               state.busy = true
@@ -572,6 +579,22 @@ describe('stopping a tool call', () => {
     await expect(running).resolves.toMatchObject({ ok: true, result: { exitCode: 130 } })
   })
 
+  it('stops the command a run handed back as still going, once asked for that call', async () => {
+    const { terminal, session } = cancellableService()
+    const { running } = await startRun(terminal, session, 'call-handed-back')
+    session.handBack()
+    await expect(running).resolves.toMatchObject({ ok: true, result: { status: 'running' } })
+    // The call is over, so a Stop for it in flight finds nothing.
+    await expect(terminal.cancelTool('call-handed-back')).resolves.toBe(false)
+
+    await terminal.stopAgentCommand('call-other')
+    expect(session.kill).not.toHaveBeenCalled()
+
+    await terminal.stopAgentCommand('call-handed-back')
+    expect(session.kill).toHaveBeenCalledWith('SIGINT')
+    expect(session.runningToolCallId).toBeNull()
+  })
+
   it('leaves a command the user started alone at sign-out', async () => {
     const { terminal, session, processGroups } = cancellableService()
     session.setBusy(true)