fix(desktop): ask the OS about terminals without shell integration before an update restart

Shells that announce nothing (fish, sh) now count as busy when their tty's
foreground process group is not the shell's own. Live windows are recorded
for relaunch without the cap, which only bounds persisted routes on read.

Author: waleedlatif1

apps/desktop/src/main/index.ts

@@ -598,7 +598,6 @@ function main(): void {
     const otherRoutes = getWindows()
       .filter((win) => win !== active)
       .flatMap((win) => routeFromAppUrl(win.webContents.getURL()) ?? [])
-      .slice(0, MAX_RELAUNCH_WINDOWS)
     config.set('updateRelaunchRoutes', otherRoutes.length > 0 ? otherRoutes : undefined)
     config.flush()
   }
@@ -1171,9 +1170,10 @@ function main(): void {
         const windows = await countWindowsWithUnsavedChanges(
           getWindows().map((win) => win.webContents)
         )
+        const terminalCommands = await terminal.runningCommands()
         const computerUseActivity = computerUse.getActivity()
         return describeInFlightWork({
-          terminalCommands: terminal.runningCommands(),
+          terminalCommands,
           computerUseApp: computerUseActivity ? (computerUseActivity.appName ?? '') : null,
           browserToolRunning: isBrowserToolRunning(),
           agentWorkRunning,

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

@@ -30,6 +30,7 @@ import {
   type TerminalToolArgs,
   type TerminalToolResponse,
 } from '@sim/terminal-protocol'
+import { getErrorMessage } from '@sim/utils/errors'
 import { sleep } from '@sim/utils/helpers'
 import type { BrowserWindow, WebContents } from 'electron'
 import {
@@ -218,6 +219,7 @@ const STOP_ESCALATION_MS = 2_000
 export class TerminalService {
   /** Insertion-ordered, which is also the tab order the user sees. */
   private readonly sessions = new Map<string, TerminalSession>()
+  private foregroundReadFailureLogged = false
   private activeId: string | null = null
   private readonly pendingCloseConfirmations = new Set<string>()
   private agentActiveId: string | null = null
@@ -303,11 +305,32 @@ export class TerminalService {
     this.cwdTimer = null
   }
 
-  /** The command line holding each busy terminal's foreground, `''` when unannounced. */
-  runningCommands(): string[] {
-    return [...this.sessions.values()].flatMap((session) =>
-      session.isBusy ? [session.foreground ?? ''] : []
+  /**
+   * The command line holding each busy terminal's foreground, `''` when unannounced. A shell
+   * without integration (fish, sh) announces nothing, so the OS's foreground process group
+   * answers for it; a failed read counts as idle so a restart is never held by a stale guess.
+   */
+  async runningCommands(): Promise<string[]> {
+    const groups = this.options.processGroups ?? OS_PROCESS_GROUPS
+    const commands = await Promise.all(
+      [...this.sessions.values()].map(async (session) => {
+        if (session.isBusy) return [session.foreground ?? '']
+        if (session.hasShellIntegration) return []
+        try {
+          const pgid = await groups.foreground(session.pid)
+          return pgid !== null && pgid !== session.pid ? [''] : []
+        } catch (error) {
+          if (!this.foregroundReadFailureLogged) {
+            this.foregroundReadFailureLogged = true
+            logger.warn('Could not read a terminal foreground process group', {
+              error: getErrorMessage(error),
+            })
+          }
+          return []
+        }
+      })
     )
+    return commands.flat()
   }
 
   getTabs(): TerminalTabsState {

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

@@ -376,8 +376,11 @@ export class TerminalRegistry {
   }
 
   /** The command line holding each busy terminal's foreground, across every chat. */
-  runningCommands(): string[] {
-    return [...this.entries.values()].flatMap((entry) => entry.service.runningCommands())
+  async runningCommands(): Promise<string[]> {
+    const commands = await Promise.all(
+      [...this.entries.values()].map((entry) => entry.service.runningCommands())
+    )
+    return commands.flat()
   }
 
   /**

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

@@ -104,6 +104,9 @@ const { stubSessions } = vi.hoisted(() => ({
       clearScrollback(): void
       /** Whether Ctrl-C ends the running command, as it does for most programs. */
       setInterruptible(interruptible: boolean): void
+      /** Whether the shell announces its commands, as zsh and bash do and fish does not. */
+      setShellIntegration(on: boolean): void
+      readonly pid: number
       /** 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. */
@@ -142,6 +145,7 @@ vi.mock('@/main/terminal/session', async () => {
           disposed: false,
           busy: false,
           interruptible: true,
+          shellIntegration: true,
           toolCallId: null as string | null,
           resolveRun: null as ((result: Record<string, unknown>) => void) | null,
         }
@@ -159,6 +163,9 @@ vi.mock('@/main/terminal/session', async () => {
           setInterruptible: (interruptible: boolean) => {
             state.interruptible = interruptible
           },
+          setShellIntegration: (on: boolean) => {
+            state.shellIntegration = on
+          },
           finishRun,
           handBack: () => {
             const resolve = state.resolveRun
@@ -204,7 +211,9 @@ vi.mock('@/main/terminal/session', async () => {
           get isBusy() {
             return state.busy
           },
-          hasShellIntegration: true,
+          get hasShellIntegration() {
+            return state.shellIntegration
+          },
           /** Real sessions poll the pty here; a stub's cwd only ever changes on open. */
           refreshCwd: async () => {},
           dispose: () => {
@@ -477,6 +486,43 @@ describe('a shell that ends by itself', () => {
   })
 })
 
+describe('running work before a restart', () => {
+  function serviceWithForeground(read: (shellPid: number) => Promise<number | null>) {
+    const terminal = new TerminalService({
+      loadCwd: () => '/tmp',
+      processGroups: { foreground: vi.fn(read), signal: vi.fn() },
+    })
+    const { activeTerminalId } = terminal.start({ cols: 80, rows: 24 })
+    const session = stubSessions.get(activeTerminalId as string)
+    if (!session) throw new Error('No stub session')
+    return { terminal, session }
+  }
+
+  it('asks the OS about a shell that announces nothing, and trusts one that does', async () => {
+    const { terminal, session } = serviceWithForeground(async () => 4242)
+    session.setShellIntegration(false)
+    await expect(terminal.runningCommands()).resolves.toEqual([''])
+
+    session.setShellIntegration(true)
+    await expect(terminal.runningCommands()).resolves.toEqual([])
+  })
+
+  it('counts a shell at its own prompt, or an unreadable foreground, as idle', async () => {
+    let read: () => Promise<number | null> = async () => null
+    const { terminal, session } = serviceWithForeground(() => read())
+    session.setShellIntegration(false)
+    await expect(terminal.runningCommands()).resolves.toEqual([])
+
+    read = async () => session.pid
+    await expect(terminal.runningCommands()).resolves.toEqual([])
+
+    read = async () => {
+      throw new Error('ps is unavailable')
+    }
+    await expect(terminal.runningCommands()).resolves.toEqual([])
+  })
+})
+
 describe('stopping a tool call', () => {
   const COMMAND_GROUP = 4242