fix(desktop): stop the agent's terminal commands at sign-out, by their own process groups

Commands the agent started could outlive the session that started them.
Closing a shell only hangs up its foreground, so a command that ignores
SIGHUP kept running, and a tmux run outlives the Sim terminal entirely.

- Sign-out and an account change now stop every command the agent started
  before the shells are torn down. A plain shell's command is stopped by its
  own process group, the same Ctrl-C, SIGTERM, SIGKILL escalation Stop uses,
  and each tmux run window still going gets Ctrl-C, then is closed.
- A command the user started is never touched: only a command a `run`
  started counts as the agent's.
- The agent's command stays the agent's until it really exits, even after an
  interactive command detaches from its tool call. Stop and sign-out can
  still end it then.

Author: waleedlatif1

apps/desktop/src/main/index.ts

@@ -331,7 +331,15 @@ function main(): void {
               await desktopExecutor.signOut()
             },
           },
-          { label: 'terminal sessions', clear: () => terminal.dispose() },
+          {
+            label: 'terminal sessions',
+            // Agent commands are stopped by their own process groups first: closing a shell only
+            // hangs up its foreground, and a tmux run outlives the Sim terminal entirely.
+            clear: async () => {
+              await terminal.stopAgentCommands()
+              terminal.dispose()
+            },
+          },
           { label: 'task resource state', clear: clearDesktopChatSessions },
           { label: 'local filesystem grants', clear: () => localFilesystem.forgetAll() },
         ]
@@ -746,7 +754,13 @@ function main(): void {
           ? [
               { label: 'sign-in handoff state', clear: () => handoff.clear() },
               { label: 'background executor', clear: () => desktopExecutor.signOut() },
-              { label: 'terminal sessions', clear: () => terminal.dispose() },
+              {
+                label: 'terminal sessions',
+                clear: async () => {
+                  await terminal.stopAgentCommands()
+                  terminal.dispose()
+                },
+              },
               { label: 'task resource state', clear: clearDesktopChatSessions },
               {
                 label: 'app session storage',

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

@@ -858,15 +858,42 @@ export class TerminalService {
     return true
   }
 
+  /** Ctrl-C in the run's own window, then closing the window hangs up anything that ignored it. */
+  private async interruptTmuxRun(handle: TmuxRunHandle, env: NodeJS.ProcessEnv): Promise<void> {
+    await sendKey(handle.window, 'C-c', env)
+    const deadline = Date.now() + STOP_ESCALATION_MS
+    while (!isRunComplete(handle) && Date.now() < deadline) await sleep(100)
+    if (!isRunComplete(handle)) await closeRunWindow(handle, env)
+  }
+
+  /**
+   * Stops every command the agent started that is still running, for sign-out: a plain shell's
+   * agent command by its own process group, as Stop does, and every tmux run window still going.
+   * A command the user started is not the agent's and is left alone.
+   */
+  async stopAgentCommands(): Promise<void> {
+    const stops: Promise<void>[] = []
+    for (const session of this.sessions.values()) {
+      const toolCallId = session.agentCommandToolCallId
+      if (toolCallId) stops.push(this.stopCommand(session, toolCallId))
+      for (const handle of this.pendingRuns.get(session.terminalId) ?? []) {
+        if (!isRunComplete(handle)) stops.push(this.interruptTmuxRun(handle, session.env))
+      }
+    }
+    await Promise.allSettled(stops)
+  }
+
   /** Waits for the command a run started to end, up to `ms`. */
   private async commandEnds(
     session: TerminalSession,
     toolCallId: string,
     ms: number
   ): Promise<boolean> {
     const deadline = Date.now() + ms
-    while (session.runningToolCallId === toolCallId) {
-      if (Date.now() >= deadline || !session.alive) return session.runningToolCallId !== toolCallId
+    while (session.agentCommandToolCallId === toolCallId) {
+      if (Date.now() >= deadline || !session.alive) {
+        return session.agentCommandToolCallId !== toolCallId
+      }
       await sleep(50)
     }
     return true
@@ -878,15 +905,15 @@ export class TerminalService {
    * call and the same group still hold it, so a command the user starts meanwhile is never hit.
    */
   private async stopCommand(session: TerminalSession, toolCallId: string): Promise<void> {
-    if (session.runningToolCallId !== toolCallId) return
+    if (session.agentCommandToolCallId !== toolCallId) return
     const groups = this.options.processGroups ?? OS_PROCESS_GROUPS
     const pgid = await groups.foreground(session.pid)
-    if (session.runningToolCallId !== toolCallId) return
+    if (session.agentCommandToolCallId !== toolCallId) return
     session.kill('SIGINT')
     for (const escalation of ['SIGTERM', 'SIGKILL'] as const) {
       if (await this.commandEnds(session, toolCallId, STOP_ESCALATION_MS)) return
       if (pgid === null || (await groups.foreground(session.pid)) !== pgid) return
-      if (session.runningToolCallId !== toolCallId) return
+      if (session.agentCommandToolCallId !== toolCallId) return
       logger.info('Stopped command ignored the previous signal; escalating', {
         toolCallId,
         signal: escalation,
@@ -1234,10 +1261,7 @@ export class TerminalService {
       endWait = resolve
     })
     latch.stopRunning = async () => {
-      await sendKey(handle.window, 'C-c', terminal.env)
-      const deadline = Date.now() + STOP_ESCALATION_MS
-      while (!isRunComplete(handle) && Date.now() < deadline) await sleep(100)
-      if (!isRunComplete(handle)) await closeRunWindow(handle, terminal.env)
+      await this.interruptTmuxRun(handle, terminal.env)
       endWait()
     }
     // A Stop that landed while the run window opened applies now.

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

@@ -369,6 +369,13 @@ export class TerminalRegistry {
     return true
   }
 
+  /** Stops every command the agent started in any chat's terminals; the user's own are untouched. */
+  async stopAgentCommands(): Promise<void> {
+    await Promise.allSettled(
+      [...this.entries.values()].map((entry) => entry.service.stopAgentCommands())
+    )
+  }
+
   /** Tears down every shell owned by every chat scope. */
   dispose(): void {
     const entries = [...this.entries.values()]

apps/desktop/src/main/terminal/service.test.ts

@@ -74,6 +74,9 @@ vi.mock('@/main/terminal/session', async () => {
           get runningToolCallId() {
             return state.toolCallId
           },
+          get agentCommandToolCallId() {
+            return state.toolCallId
+          },
           kill: vi.fn((signal: string) => {
             if (signal === 'SIGINT' && state.interruptible) finishRun(130)
           }),
@@ -466,6 +469,26 @@ describe('stopping a tool call', () => {
     expect(session.kill).not.toHaveBeenCalled()
   })
 
+  it("stops the agent's running command at sign-out", async () => {
+    const { terminal, session } = cancellableService()
+    const { running } = await startRun(terminal, session, 'call-left-running')
+
+    await terminal.stopAgentCommands()
+
+    expect(session.kill).toHaveBeenCalledWith('SIGINT')
+    await expect(running).resolves.toMatchObject({ ok: true, result: { exitCode: 130 } })
+  })
+
+  it('leaves a command the user started alone at sign-out', async () => {
+    const { terminal, session, processGroups } = cancellableService()
+    session.setBusy(true)
+
+    await terminal.stopAgentCommands()
+
+    expect(session.kill).not.toHaveBeenCalled()
+    expect(processGroups.signal).not.toHaveBeenCalled()
+  })
+
   it('leaves the terminal alone for a call it is not running', async () => {
     const { terminal, session, processGroups } = cancellableService()
     const { running } = await startRun(terminal, session, 'call-other')

apps/desktop/src/main/terminal/session.test.ts

@@ -137,6 +137,9 @@ describe('TerminalSession command lifecycle', () => {
       const resultPromise = session.runCommand('vim', 'tool-call-1', 10_000)
       ptyStub.dataHandler?.('\u001b]633;C;test-nonce\u0007\u001b[?1049h')
       expect(await resultPromise).toMatchObject({ status: 'interactive' })
+      // Detached from the tool call, the command is still the agent's until it exits.
+      expect(session.runningToolCallId).toBeNull()
+      expect(session.agentCommandToolCallId).toBe('tool-call-1')
 
       expect(commandEvents.at(-1)).toMatchObject({
         terminalId: 'terminal-1',
@@ -153,6 +156,7 @@ describe('TerminalSession command lifecycle', () => {
         command: 'vim',
         exitCode: 0,
       })
+      expect(session.agentCommandToolCallId).toBeNull()
       expect(commandEvents.at(-1)?.toolCallId).toBeUndefined()
     } finally {
       session.dispose()

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

@@ -316,6 +316,12 @@ export class TerminalSession {
   private altScreen = false
   private foregroundCommand: string | null = null
   private foregroundToolCallId: string | null = null
+  /**
+   * The agent tool call whose command is still running, until that command really ends. Unlike
+   * {@link runningToolCallId} it survives an interactive command detaching from the tool call:
+   * the command is still the agent's, so Stop and sign-out can still end it.
+   */
+  private agentToolCallId: string | null = null
   private pendingCommand: PendingCommand | null = null
   /** Command line reported by the shell but not yet bracketed by output-start. */
   private announcedCommand: string | null = null
@@ -439,6 +445,11 @@ export class TerminalSession {
     return this.foregroundToolCallId
   }
 
+  /** The agent tool call whose command is still running in this shell, if one is. */
+  get agentCommandToolCallId(): string | null {
+    return this.agentToolCallId
+  }
+
   /**
    * Tab-strip view of this terminal. The label prefers the running command,
    * which is what the user is actually waiting on, and falls back to the
@@ -604,6 +615,7 @@ export class TerminalSession {
       }
       this.foregroundCommand = command
       this.foregroundToolCallId = toolCallId
+      this.agentToolCallId = toolCallId
       this.emitState()
       this.callbacks.onCommand({ terminalId: this.terminalId, phase: 'start', command, toolCallId })
 
@@ -983,6 +995,7 @@ export class TerminalSession {
 
     this.foregroundCommand = null
     this.foregroundToolCallId = null
+    this.agentToolCallId = null
     this.announcedCommand = null
     this.altScreen = false
     this.emitState()