@@ -101,7 +101,7 @@ void app.whenReady().then(async () => {
     installStatePath: join(directory, 'update-install.json'),
     describeInFlightWork: async () =>
       describeInFlightWork({
-        terminalCommands,
+        terminalCommands: terminalCommands.map((command) => ({ command, shell: 'zsh' })),
         uncheckedTerminalCount: 0,
         computerUseApp: null,
         browserToolRunning,
 
@@ -30,6 +30,7 @@ describe('countWindowsWithUnsavedChanges', () => {
 })
 
 describe('describeInFlightWork', () => {
+  const zsh = (command: string) => ({ command, shell: 'zsh' })
   const IDLE: InFlightWork = {
     terminalCommands: [],
     uncheckedTerminalCount: 0,
@@ -51,23 +52,35 @@ describe('describeInFlightWork', () => {
   })
 
   it('starts the sentence for an unannounced command with a capital', () => {
-    expect(describeInFlightWork({ ...IDLE, terminalCommands: [''] })).toEqual([
+    expect(describeInFlightWork({ ...IDLE, terminalCommands: [zsh('')] })).toEqual([
       'A command is still running in a terminal.',
     ])
-    expect(describeInFlightWork({ ...IDLE, terminalCommands: ['npm run dev'] })).toEqual([
+    expect(describeInFlightWork({ ...IDLE, terminalCommands: [zsh('npm run dev')] })).toEqual([
       'npm is still running in a terminal.',
     ])
   })
 
   it('counts unannounced commands rather than naming "a command" twice', () => {
-    expect(describeInFlightWork({ ...IDLE, terminalCommands: ['', ''] })).toEqual([
+    expect(describeInFlightWork({ ...IDLE, terminalCommands: [zsh(''), zsh('')] })).toEqual([
       '2 terminal commands are still running.',
     ])
-    expect(describeInFlightWork({ ...IDLE, terminalCommands: ['', 'npm run dev'] })).toEqual([
-      'npm and a command are still running in terminals.',
-    ])
     expect(
-      describeInFlightWork({ ...IDLE, terminalCommands: ['', 'npm run dev', 'claude'] })
+      describeInFlightWork({ ...IDLE, terminalCommands: [zsh(''), zsh('npm run dev')] })
+    ).toEqual(['npm and a command are still running in terminals.'])
+    expect(
+      describeInFlightWork({
+        ...IDLE,
+        terminalCommands: [zsh(''), zsh('npm run dev'), zsh('claude')],
+      })
     ).toEqual(['3 terminal commands are still running.'])
   })
+
+  it("names a Windows command by its program, read in its own shell's syntax", () => {
+    expect(
+      describeInFlightWork({
+        ...IDLE,
+        terminalCommands: [{ command: 'C:\\tools\\node.exe server.js', shell: 'pwsh' }],
+      })
+    ).toEqual(['node is still running in a terminal.'])
+  })
 })
@@ -3,6 +3,7 @@ import { describeRunningCommand } from '@sim/terminal-protocol'
 import { getErrorMessage } from '@sim/utils/errors'
 import { sleep } from '@sim/utils/helpers'
 import type { WebContents } from 'electron'
+import type { RunningTerminalCommand } from '@/main/terminal'
 
 const logger = createLogger('DesktopInFlightWork')
 
@@ -60,8 +61,8 @@ export async function countWindowsWithUnsavedChanges(
 }
 
 export interface InFlightWork {
-  /** The command line holding each busy terminal's foreground (`''` when unannounced). */
-  terminalCommands: readonly string[]
+  /** The command holding each busy terminal's foreground. */
+  terminalCommands: readonly RunningTerminalCommand[]
   /** Terminals whose foreground could not be read, which may be running a command. */
   uncheckedTerminalCount: number
   /** The app a computer-use action is driving, `''` when it has no name, or null when idle. */
@@ -80,11 +81,11 @@ export interface InFlightWork {
  * One sentence for the busy terminals. Commands are named while at most two are running and
  * at most one is unannounced; past that, two "a command"s would say nothing, so they are counted.
  */
-function describeTerminalCommands(commands: readonly string[]): string | null {
+function describeTerminalCommands(commands: readonly RunningTerminalCommand[]): string | null {
   if (commands.length === 0) return null
   const named = commands
-    .filter((command) => command.trim())
-    .map((command) => describeRunningCommand(command))
+    .filter(({ command }) => command.trim())
+    .map(({ command, shell }) => describeRunningCommand(command, shell))
   const unnamed = commands.length - named.length
   if (unnamed > 1 || commands.length > MAX_NAMED_TERMINAL_COMMANDS) {
     return `${commands.length} terminal commands are still running.`
 
@@ -166,10 +166,18 @@ export interface TerminalServiceOptions {
   runLedger?: RunLedger
 }
 
+/** A command holding a terminal's foreground. */
+export interface RunningTerminalCommand {
+  /** Its command line, `''` when the shell did not announce it. */
+  command: string
+  /** The program name of the shell it was typed into (`zsh`, `pwsh`), whose syntax names its program. */
+  shell: string
+}
+
 /** The terminal work a restart would cut off. */
 export interface TerminalWork {
-  /** The command line holding each busy terminal's foreground, `''` when unannounced. */
-  commands: string[]
+  /** The command holding each busy terminal's foreground. */
+  commands: RunningTerminalCommand[]
   /** Terminals whose foreground could not be read, which may be running anything. */
   uncheckedCount: number
 }
@@ -319,16 +327,20 @@ export class TerminalService {
     const groups = this.options.processGroups ?? osProcessGroups
     const perSession = await Promise.all(
       [...this.sessions.values()].map(
-        async (session): Promise<{ command: string | null; unchecked: boolean }> => {
-          if (session.isBusy) return { command: session.foreground ?? '', unchecked: false }
+        async (
+          session
+        ): Promise<{ command: RunningTerminalCommand | null; unchecked: boolean }> => {
+          const running = (command: string) => ({ command, shell: session.shellProgram })
+          if (session.isBusy)
+            return { command: running(session.foreground ?? ''), unchecked: false }
           if (session.hasShellIntegration) return { command: null, unchecked: false }
           const foreground = await groups.foreground(
             session.pid,
             session.spawnedAt,
             session.shellReadyAt
           )
           return {
-            command: foreground?.length ? '' : null,
+            command: foreground?.length ? running('') : null,
             unchecked: foreground === null,
           }
         }
@@ -1018,7 +1030,7 @@ export class TerminalService {
       (await groups.foreground(session.pid, startedAt, session.shellReadyAt)) ?? []
     let command = groups.readBeforeInterrupt ? await readCommand() : undefined
     if (session.agentCommandToolCallId !== toolCallId) return
-    session.kill('SIGINT')
+    session.interrupt()
     for (const escalation of groups.escalations) {
       if (await this.commandEnds(session, toolCallId, STOP_ESCALATION_MS)) return
       const remaining =
@@ -1036,6 +1048,30 @@ export class TerminalService {
     }
   }
 
+  /**
+   * Sends a terminating signal to the command holding a plain shell's foreground, never the shell:
+   * the tool stops what is running, and the shell is the user's tab. On macOS and Linux that is
+   * the tty's foreground process group; on Windows, which has no signals, each process the shell
+   * started since the command began is ended with its tree. `signalled` is false when nothing but
+   * the shell held the foreground, or the OS could not say what did.
+   */
+  private async terminateForeground(
+    session: TerminalSession,
+    signal: 'SIGTERM' | 'SIGKILL',
+    stopped: AbortSignal
+  ): Promise<{ signal: string; terminalId: string; signalled: boolean }> {
+    const groups = this.options.processGroups ?? osProcessGroups
+    const command =
+      (await groups.foreground(
+        session.pid,
+        session.foregroundStartedAt ?? session.spawnedAt,
+        session.shellReadyAt
+      )) ?? []
+    if (stopped.aborted) throw stoppedBeforeStart()
+    if (command.length > 0) groups.signal(command, signal)
+    return { signal, terminalId: session.terminalId, signalled: command.length > 0 }
+  }
+
   private async dispatch(
     toolCallId: string,
     operation: TerminalOperation,
@@ -1159,8 +1195,11 @@ export class TerminalService {
           await sendKey(target, signal === 'SIGKILL' ? 'C-\\' : 'C-c', session.env)
           return { signal, terminalId: session.terminalId, pane: target }
         }
-        session.kill(signal)
-        return { signal, terminalId: session.terminalId }
+        if (signal === 'SIGINT') {
+          session.interrupt()
+          return { signal, terminalId: session.terminalId }
+        }
+        return await this.terminateForeground(session, signal, latch.signal)
       }
       default:
         throw new TerminalError('INVALID_REQUEST', `Unknown terminal operation: ${operation}`)
 
@@ -7,8 +7,7 @@
  * marker. That build asks for the terminal's device attributes as it starts and holds the shell's
  * first output until it hears back, three seconds when nothing answers, so the pty answers that
  * one query itself, as xterm.js would, and keeps it from the output so the reply is never sent
- * twice; an agent's shell has no panel to answer it at all. node-pty there cannot send a signal
- * either, only end the shell.
+ * twice; an agent's shell has no panel to answer it at all.
  */
 import { spawn } from '@lydell/node-pty'
 
@@ -48,8 +47,8 @@ export interface TerminalPty {
   resize(cols: number, rows: number): void
   pause(): void
   resume(): void
-  /** Sends `signal` to the shell; on Windows, which has no signals, ends it. */
-  kill(signal?: NodeJS.Signals): void
+  /** Ends the shell. */
+  kill(): void
 }
 
 /** Spawns `options.shellPath` in a pseudo-terminal, set up for the platform it runs on. */
@@ -95,6 +94,6 @@ export function spawnTerminalPty(options: TerminalPtyOptions): TerminalPty {
     resize: (cols, rows) => pty.resize(cols, rows),
     pause: () => pty.pause(),
     resume: () => pty.resume(),
-    kill: (signal) => (windows ? pty.kill() : pty.kill(signal)),
+    kill: () => pty.kill(),
   }
 }