fix(desktop): never stop a run the model may hold

Author: waleedlatif1

apps/desktop/src/main/desktop-executor/executor.test.ts

@@ -536,6 +536,20 @@ describe('restarting', () => {
     expect(runner.started).toEqual([])
     await vi.waitFor(() => expect(journal.entries.size).toBe(0))
   })
+
+  it('leaves open whether the model has a result when Sim already held one for the call', async () => {
+    const { sim, journal, executor, delivered, notDelivered } = setup()
+    // The previous run's send of the real result may have landed just before the app went down.
+    sim.completionOutcome = 'duplicate'
+    await journal.put({ toolCallId: 'started-1', state: 'started', executionToken: 't-started' })
+
+    await executor.recover()
+
+    await vi.waitFor(() => expect(journal.entries.size).toBe(0))
+    expect(sim.completions).toHaveLength(1)
+    expect(delivered).toEqual([])
+    expect(notDelivered).toEqual([])
+  })
 })
 
 describe('delivery', () => {

apps/desktop/src/main/desktop-executor/executor.ts

@@ -89,7 +89,7 @@ export interface DesktopExecutorOptions {
   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
+   * first, refused the result, or recorded 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
@@ -419,7 +419,7 @@ export class DesktopExecutor {
     sendingSince: number
   ): Promise<void> {
     let pending = completion
-    let delivered = false
+    let notDelivered = true
     for (let attempt = 1; !this.disposed; attempt++) {
       try {
         const outcome = await this.options.client.complete({
@@ -429,8 +429,11 @@ export class DesktopExecutor {
         })
         logger.info('Desktop call result acknowledged', { toolCallId, outcome })
         // Superseded: Sim settled the call first, so this result never reached the model.
-        delivered = outcome !== 'superseded' && isDeliveredResult(pending)
+        const delivered = outcome !== 'superseded' && isDeliveredResult(pending)
         if (delivered) this.options.onResultDelivered?.(toolCallId)
+        // A stand-in Sim already holds leaves open which result it took first: a send from before
+        // a restart may have carried the real one.
+        notDelivered = !delivered && outcome !== 'duplicate'
         break
       } catch (error) {
         // Encoding failed on this machine, so nothing was sent; the same data would fail again.
@@ -488,7 +491,7 @@ export class DesktopExecutor {
       }
     }
     if (this.disposed) return
-    if (!delivered) this.options.onResultNotDelivered?.(toolCallId)
+    if (notDelivered) this.options.onResultNotDelivered?.(toolCallId)
     await this.forget(toolCallId)
   }
 

apps/desktop/src/main/index.ts

@@ -610,8 +610,8 @@ 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.
+    // A result the model never got leaves such a run with no one to come back to it, so it is
+    // stopped, as the launch sweep stops a previous process's.
     onResultNotDelivered: (toolCallId) => void terminal.stopUndeliveredRun(toolCallId),
     runner: createDesktopToolRunner({
       preferences: () => desktopSettings.getPreferences(),

apps/desktop/src/main/terminal/registry-run-ledger.test.ts

@@ -125,15 +125,24 @@ describe('stopping recorded tmux runs', () => {
     const ledger = createRunLedger(dir)
     ledger.record(run('current', '%2'))
     ledger.record(run('other', '%3'))
+    // Recorded as handed back: the model has its pane.
+    ledger.record(run('handed-back', '%4', 'delivered'))
     const registry = new TerminalRegistry(undefined, undefined, ledger)
 
     await registry.stopUndeliveredRun('call-current')
     await registry.stopUndeliveredRun('call-previous')
+    await registry.stopUndeliveredRun('call-handed-back')
 
     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'])
+    expect(panes.get('handed-back')).toBeUndefined()
+    expect(
+      ledger
+        .list()
+        .map((record) => record.runId)
+        .sort()
+    ).toEqual(['handed-back', 'other'])
   })
 
   it('notes the run of a call whose result reached the model as handed back', () => {

apps/desktop/src/main/terminal/registry.ts

@@ -413,13 +413,13 @@ export class TerminalRegistry {
   /**
    * 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.
+   * previous one's. A run recorded as handed back is the model's, and is left going.
    */
   async stopUndeliveredRun(callId: string): Promise<void> {
     await Promise.allSettled(
       [...this.entries.values()].map((entry) => entry.service.stopAgentCommand(callId))
     )
-    await this.stopRecordedRuns({ callId })
+    await this.stopRecordedRuns({ callId, keep: (run) => run.state === 'delivered' })
   }
 
   /**