@@ -168,6 +168,8 @@ function setup(
   const runner = new FakeRunner()
   const onUnregistered = vi.fn()
   const busy: boolean[] = []
+  /** Calls whose result the executor reported as journaled, in order. */
+  const journaled: string[] = []
   const executor = new DesktopExecutor({
     client: sim.client,
     journal,
@@ -177,12 +179,13 @@ function setup(
     onUnregistered,
     onBusyChange: (value) => busy.push(value),
     onApprovals: (items) => approvals.push(items),
+    onResultRecorded: (toolCallId) => journaled.push(toolCallId),
     ...(options.maxHeldCalls ? { maxHeldCalls: options.maxHeldCalls } : {}),
     ...(options.deliveryAwakeLimitMs !== undefined
       ? { deliveryAwakeLimitMs: options.deliveryAwakeLimitMs }
       : {}),
   })
-  return { sim, journal, runner, executor, onUnregistered, busy, approvals }
+  return { sim, journal, runner, executor, onUnregistered, busy, approvals, journaled }
 }
 
 describe('claiming', () => {
@@ -203,6 +206,22 @@ describe('claiming', () => {
     expect(executor.heldCallCount()).toBe(0)
   })
 
+  it('reports a result as durable only once the journal holds it', async () => {
+    const { sim, journal, runner, executor, journaled } = setup()
+    runner.immediate = DONE
+    journal.failOn = 'result'
+    sim.inbox = [callItem('call-unjournaled', 'chat-a')]
+    await executor.reconcile()
+    await vi.waitFor(() => expect(sim.completions).toHaveLength(1))
+    expect(journaled).toEqual([])
+
+    journal.failOn = null
+    sim.inbox = [callItem('call-journaled', 'chat-a')]
+    await executor.reconcile()
+    await vi.waitFor(() => expect(sim.completions).toHaveLength(2))
+    expect(journaled).toEqual(['call-journaled'])
+  })
+
   it('claims a whole backlog at once, before any of it runs', async () => {
     const { sim, runner, executor } = setup()
     sim.inbox = [callItem('a-1', 'chat-a'), callItem('a-2', 'chat-a'), callItem('a-3', 'chat-a')]
 
@@ -67,6 +67,11 @@ export interface DesktopExecutorOptions {
   onApprovals?: (items: DesktopApprovalItem[]) => void
   /** Called whenever the number of held calls changes between zero and more. */
   onBusyChange?: (busy: boolean) => void
+  /**
+   * Called once a call's result is in the journal: from then on it reaches Sim, now or after a
+   * restart, so anything it hands back (a pane still running) can be counted on.
+   */
+  onResultRecorded?: (toolCallId: string, completion: DesktopToolCompletion) => void
   maxHeldCalls?: number
   /** First delivery retry delay; tests shorten it. */
   retryBaseMs?: number
@@ -375,7 +380,9 @@ export class DesktopExecutor {
   ): Promise<void> {
     if (this.disposed) return
     // Best effort: unrecorded, a crash reports the call from its `started` entry as outcome unknown.
-    await this.record({ toolCallId, state: 'result', executionToken, completion })
+    if (await this.record({ toolCallId, state: 'result', executionToken, completion })) {
+      this.options.onResultRecorded?.(toolCallId, completion)
+    }
     const sendingSince = Date.now()
     try {
       await this.sendResult(toolCallId, executionToken, completion, sendingSince)
 
@@ -7,6 +7,7 @@
 import { hostname } from 'node:os'
 import { join } from 'node:path'
 import type { DesktopExecutorDevice } from '@sim/desktop-bridge'
+import type { DesktopToolCompletion } from '@sim/desktop-bridge/tool-results'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { generateId } from '@sim/utils/id'
@@ -61,6 +62,8 @@ export interface DesktopExecutorServiceDeps {
   onApprovals?: (items: DesktopApprovalItem[]) => void
   /** Whether any chat has desktop work claimed on this machine changed. */
   onBusyChange?: (busy: boolean) => void
+  /** A call's result is in the journal, so it reaches Sim even across a restart. */
+  onResultRecorded?: (toolCallId: string, completion: DesktopToolCompletion) => void
 }
 
 export interface DesktopExecutorService {
@@ -245,6 +248,7 @@ export function createDesktopExecutorService(
         onUnregistered: handleUnrecognized,
         ...(deps.onApprovals ? { onApprovals: deps.onApprovals } : {}),
         ...(deps.onBusyChange ? { onBusyChange: deps.onBusyChange } : {}),
+        ...(deps.onResultRecorded ? { onResultRecorded: deps.onResultRecorded } : {}),
       })
       await executor.recover()
       // Signed out while recovering: sign-out already disposed this executor.
 
@@ -607,6 +607,13 @@ function main(): void {
     accountDataAvailable,
     onApprovals: (items) => approvalNotifier.update(items),
     onBusyChange: (busy) => sleepBlocker.setBusy(busy),
+    // A result that will reach the model (not one reported as not started or outcome unknown)
+    // makes a tmux run it handed back as still going collectable across a restart.
+    onResultRecorded: (toolCallId, completion) => {
+      if (completion.data?.outcomeUnknown !== true && completion.data?.notStarted !== true) {
+        terminal.markRunDelivered(toolCallId)
+      }
+    },
     runner: createDesktopToolRunner({
       preferences: () => desktopSettings.getPreferences(),
       accountDataAvailable,
 
@@ -1351,8 +1351,8 @@ export class TerminalService {
       handle.dispose()
     }
     // Still going, it stays tracked, and nothing polls the status file again: `read` captures
-    // the pane instead. Its result now points the model at that pane, so a restart must not end it.
-    if (!outcome.done && handle.runId) ledger?.markDelivered(handle.runId)
+    // the pane instead. Its record is marked handed back only once that result is durable
+    // (the executor's journal); see `TerminalRegistry.markRunDelivered`.
 
     const { text, truncated } = elideOutput(outcome.output)
     return {
 
@@ -88,6 +88,35 @@ describe('stopping recorded tmux runs', () => {
     expect(ledger.list().map((record) => record.runId)).toEqual(['handed-back'])
   })
 
+  it('keeps meaning to stop a run a stop for everything could not confirm', async () => {
+    const dir = ledgerDir()
+    createRunLedger(dir).record(run('unconfirmed', '%1', true))
+    panes.set('unconfirmed', 'unknown')
+    const ledger = createRunLedger(dir)
+    // Sign-out could not confirm the run ended.
+    await new TerminalRegistry(undefined, undefined, ledger).stopAgentCommands()
+    panes.set('unconfirmed', 'running')
+
+    // A later launch for the same user, with the journal cleared, still stops it.
+    await new TerminalRegistry(undefined, undefined, ledger).stopUncollectableRuns(new Set())
+
+    expect(panes.get('unconfirmed')).toBe('stopped')
+    expect(ledger.list()).toEqual([])
+  })
+
+  it('notes a run as handed back once its call result is durable', () => {
+    const dir = ledgerDir()
+    const ledger = createRunLedger(dir)
+    ledger.record(run('watched', '%1'))
+    ledger.record(run('other', '%2'))
+
+    new TerminalRegistry(undefined, undefined, ledger).markRunDelivered('call-watched')
+
+    expect(
+      Object.fromEntries(ledger.list().map((record) => [record.runId, record.delivered]))
+    ).toEqual({ watched: true, other: false })
+  })
+
   it("at launch, stops the previous process's runs and none this one has started", async () => {
     const dir = ledgerDir()
     createRunLedger(dir).record(run('previous', '%1'))
 
@@ -396,10 +396,22 @@ export class TerminalRegistry {
   stopUncollectableRuns(unresolvedCalls: ReadonlySet<string> | null): Promise<void> {
     return this.stopRecordedRuns({
       excludeLive: true,
-      keep: (run) => run.delivered && !unresolvedCalls?.has(run.callId),
+      keep: (run) => run.delivered && !run.mustStop && !unresolvedCalls?.has(run.callId),
     })
   }
 
+  /**
+   * Notes that a call's result is durable (in the executor's journal), so a tmux run it handed
+   * back as still going may be left to the model across a restart.
+   */
+  markRunDelivered(callId: string): void {
+    const ledger = this.runLedger
+    if (!ledger) return
+    for (const run of ledger.list()) {
+      if (run.callId === callId) ledger.markDelivered(run.runId)
+    }
+  }
+
   /**
    * 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;
@@ -417,10 +429,14 @@ export class TerminalRegistry {
     if (!ledger) return
     await Promise.allSettled(
       ledger.list({ excludeLive: options.excludeLive }).map(async (run) => {
-        const state = options.keep?.(run)
+        const keeping = options.keep?.(run) ?? false
+        const state = keeping
           ? await recordedRunState(run, process.env)
           : await stopRecordedRun(run, process.env, RECORDED_RUN_GRACE_MS)
         if (state === 'gone') ledger.forget(run.runId)
+        // A run this sweep meant to stop but could not confirm stays meant to stop, so no later
+        // sweep keeps it.
+        else if (!keeping) ledger.markMustStop(run.runId)
       })
     )
   }
 
@@ -27,13 +27,17 @@ export interface RunRecord extends RecordedRun {
    * pane): from then on the model can come back to the pane, so a restart must leave it be.
    */
   delivered: boolean
+  /** A stop for everything (sign-out, Terminal off) could not confirm this run ended. */
+  mustStop?: boolean
 }
 
 export interface RunLedger {
   /** Saves a run's record; false when it could not be saved, so the run must not start. */
   record(run: RunRecord): boolean
   /** Notes that the run's call has handed back its result, with the run still going. */
   markDelivered(runId: string): void
+  /** Notes that the run must be stopped, whatever a later launch would otherwise decide. */
+  markMustStop(runId: string): void
   forget(runId: string): void
   /** Every recorded run; `excludeLive` leaves out runs this process recorded. */
   list(options?: { excludeLive?: boolean }): RunRecord[]
@@ -61,6 +65,7 @@ function parseRecord(text: string): RunRecord | null {
         socket: parsed.socket,
         callId: parsed.callId,
         delivered: parsed.delivered,
+        ...(parsed.mustStop === true ? { mustStop: true } : {}),
       }
     }
   } catch {
@@ -83,6 +88,24 @@ export function createRunLedger(dir: string): RunLedger {
   const live = new Set<string>()
   const pathFor = (runId: string) => join(dir, `${runId}.json`)
 
+  /** Rewrites a saved record; `change` returns null to leave it as it is. */
+  const update = (runId: string, change: (record: RunRecord) => RunRecord | null): void => {
+    if (!RUN_ID.test(runId)) return
+    let record: RunRecord | null = null
+    try {
+      record = parseRecord(readFileSync(pathFor(runId), 'utf8'))
+    } catch {
+      record = null
+    }
+    const changed = record ? change(record) : null
+    if (!changed) return
+    try {
+      writeJsonFileAtomicallySync(pathFor(runId), changed)
+    } catch (error) {
+      logger.warn('Could not update a tmux run record', { error: getErrorMessage(error) })
+    }
+  }
+
   return {
     record(run) {
       if (!RUN_ID.test(run.runId)) return false
@@ -96,20 +119,11 @@ export function createRunLedger(dir: string): RunLedger {
       }
     },
     markDelivered(runId) {
-      if (!RUN_ID.test(runId)) return
-      let record: RunRecord | null = null
-      try {
-        record = parseRecord(readFileSync(pathFor(runId), 'utf8'))
-      } catch {
-        record = null
-      }
-      if (!record || record.delivered) return
-      try {
-        writeJsonFileAtomicallySync(pathFor(runId), { ...record, delivered: true })
-      } catch (error) {
-        // Left undelivered, a restart stops the run: the conservative side.
-        logger.warn('Could not note a tmux run as handed back', { error: getErrorMessage(error) })
-      }
+      // Left undelivered, a restart stops the run: the conservative side.
+      update(runId, (record) => (record.delivered ? null : { ...record, delivered: true }))
+    },
+    markMustStop(runId) {
+      update(runId, (record) => (record.mustStop ? null : { ...record, mustStop: true }))
     },
     forget(runId) {
       live.delete(runId)
 
@@ -662,8 +662,8 @@ describe('agent commands in tmux', () => {
           pane,
           socket: '/tmp/tmux-fake/default',
           callId: 'call-long',
-          // Handed back as still running, with its pane: a restart must leave it be.
-          delivered: true,
+          // Handed back, but only the executor's journal can make that durable.
+          delivered: false,
         },
       ])
 
 
@@ -136,6 +136,8 @@ interface FakeTmuxState {
   retagAtCheck?: number
   /** display-message calls so far. */
   checks?: number
+  /** tmux restarts and the user's pane takes the id just before the next guarded action. */
+  retagBeforeAction?: boolean
   /** Attached clients, as `list-clients` reports them. */
   clients?: Array<{ pid: string; tty: string; session: string }>
   /** Commands the fake holds until the file named here exists, like a busy tmux server. */
@@ -174,6 +176,18 @@ if (state.hold && state.hold[args[0]]) {
   }
   state.held = state.held.filter((command) => command !== args[0])
 }
+// \`if-shell -F -t pane '#{==:#{option},value}' command\`: the check and the action in one command.
+if (args[0] === 'if-shell') {
+  const pane = state.panes[target()]
+  if (pane && state.retagBeforeAction) {
+    pane.options['@sim-run-id'] = 'someone-else'
+    state.retagBeforeAction = false
+    save()
+  }
+  const check = /^#\\{==:#\\{([^}]+)\\},(.*)\\}$/.exec(args[args.length - 2])
+  if (!pane || !check || (pane.options[check[1]] ?? '') !== check[2]) process.exit(0)
+  args = args[args.length - 1].split(' ')
+}
 if (state.fail && state.fail[args[0]]) fail(state.fail[args[0]])
 switch (args[0]) {
   case 'new-window': {
@@ -406,6 +420,17 @@ describe('stopping a run another process started, from its record', () => {
     expect([...saved]).toEqual([])
   })
 
+  it('acts on no pane that took the recorded id between the last check and the action', async () => {
+    const tmux = fakeTmux()
+    const { record } = await recorded(tmux)
+    tmux.write({ ...tmux.read(), retagBeforeAction: true })
+
+    await stopRecordedRun(record, tmux.env, 0)
+
+    expect(tmux.read().log).toEqual([])
+    expect(Object.keys(tmux.read().panes)).toEqual([record.pane])
+  })
+
   it('keeps the record when tmux stops answering part-way through the stop', async () => {
     const tmux = fakeTmux()
     const { record } = await recorded(tmux)
@@ -485,6 +510,17 @@ describe('stopping a tmux run touches only its own pane', () => {
     expect(Object.keys(tmux.read().panes)).toEqual([users])
   })
 
+  it('sends a live run nothing once its pane is retagged between the check and the action', async () => {
+    const tmux = fakeTmux()
+    const run = await started(tmux)
+    tmux.write({ ...tmux.read(), retagBeforeAction: true })
+
+    await stopRun(run, tmux.env, 0)
+
+    expect(tmux.read().log).toEqual([])
+    expect(Object.keys(tmux.read().panes)).toEqual([run.pane])
+  })
+
   it('sends nothing to a pane that reused the run pane id after tmux restarted', async () => {
     const tmux = fakeTmux()
     const run = await started(tmux)