@@ -1301,7 +1301,11 @@ export class TerminalService {
     if (latch.signal.aborted) void latch.stopRunning()
     const outcome = await Promise.race([
       awaitRun(handle, waitMs),
-      stopped.then(() => ({ ...pollRun(handle), done: true })),
+      // A stopped run's closed pane never writes its status. An untracked run is never stopped,
+      // so it is still going unless its status says otherwise.
+      stopped.then(() =>
+        handle.runId === null ? pollRun(handle) : { ...pollRun(handle), done: true }
+      ),
     ]).finally(() => {
       this.awaitedRuns.delete(handle)
       if (this.releasedAwaitedRuns.delete(handle)) handle.dispose()
 
@@ -16,6 +16,8 @@ const tmuxFake = vi.hoisted(() => ({
   stopped: [] as string[],
   /** Panes no longer the run's (closed by the user, or reused after a tmux restart). */
   gone: new Set<string>(),
+  /** Runs start untracked, as on a tmux too old to tag their panes. */
+  untracked: false,
   statusPaths: new Map<string, string>(),
 }))
 
@@ -40,20 +42,21 @@ vi.mock('@/main/terminal/tmux', async () => {
       return {
         window: `@${pane.slice(1)}`,
         pane,
-        runId: `run-${pane}`,
+        runId: tmuxFake.untracked ? null : `run-${pane}`,
         outPath: join(dir, 'out'),
         statusPath,
         dispose: () => rmSync(dir, { recursive: true, force: true }),
       }
     },
     runPaneState: async (...args: Parameters<typeof actual.runPaneState>) => {
       if (!tmuxFake.on) return actual.runPaneState(...args)
-      return tmuxFake.gone.has(args[0].pane) ? 'gone' : 'ours'
+      if (tmuxFake.gone.has(args[0].pane)) return 'gone'
+      return args[0].runId === null ? 'unknown' : 'ours'
     },
     stopRun: async (...args: Parameters<typeof actual.stopRun>) => {
       if (!tmuxFake.on) return actual.stopRun(...args)
       const [handle] = args
-      if (tmuxFake.gone.has(handle.pane)) return
+      if (tmuxFake.gone.has(handle.pane) || handle.runId === null) return
       tmuxFake.stopped.push(handle.pane)
       writeFileSync(handle.statusPath, '130')
     },
@@ -587,6 +590,35 @@ describe('agent commands in tmux', () => {
     }
   })
 
+  it('reports an untracked run it could not stop as still running, and keeps tracking it', async () => {
+    tmuxFake.on = true
+    tmuxFake.untracked = true
+    tmuxFake.statusPaths.clear()
+    try {
+      const terminal = new TerminalService({ loadCwd: () => '/tmp' })
+      terminal.start({ cols: 80, rows: 24 })
+      const running = terminal.executeTool('call-untracked', 'run', {
+        command: 'sleep 600',
+        waitSeconds: 60,
+      })
+      await vi.waitFor(() => expect(tmuxFake.statusPaths.size).toBe(1))
+      const [, statusPath = ''] = [...tmuxFake.statusPaths][0] ?? []
+
+      await terminal.cancelTool('call-untracked')
+
+      await expect(running).resolves.toMatchObject({ ok: true, result: { status: 'running' } })
+      expect(existsSync(join(statusPath, '..'))).toBe(true)
+
+      // Once it does finish, the next run's bookkeeping reaps it.
+      writeFileSync(statusPath, '0')
+      await terminal.executeTool('call-next', 'run', { command: 'ls', waitSeconds: 1 })
+      expect(existsSync(join(statusPath, '..'))).toBe(false)
+    } finally {
+      tmuxFake.on = false
+      tmuxFake.untracked = false
+    }
+  })
+
   it("keeps a run's output readable for its call when the terminal goes away mid-wait", async () => {
     tmuxFake.on = true
     tmuxFake.statusPaths.clear()
 
@@ -104,8 +104,10 @@ interface FakeTmuxState {
   log: string[]
   /** Commands the fake fails, with the error tmux would print. */
   fail?: Record<string, string>
-  /** Commands the fake answers only after this many milliseconds, like a busy tmux server. */
-  delay?: Record<string, number>
+  /** Commands the fake holds until the file named here exists, like a busy tmux server. */
+  hold?: Record<string, string>
+  /** Commands the fake is holding right now. */
+  held?: string[]
 }
 
 const FAKE_TMUX = `
@@ -116,8 +118,13 @@ const args = process.argv.slice(2)
 const save = () => fs.writeFileSync(file, JSON.stringify(state))
 const target = () => args[args.indexOf('-t') + 1]
 const fail = (message) => { process.stderr.write(message); process.exit(1) }
-if (state.delay && state.delay[args[0]]) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, state.delay[args[0]])
+if (state.hold && state.hold[args[0]]) {
+  state.held = [...(state.held ?? []), args[0]]
+  save()
+  while (!fs.existsSync(state.hold[args[0]])) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20)
+  }
+  state.held = state.held.filter((command) => command !== args[0])
 }
 if (state.fail && state.fail[args[0]]) fail(state.fail[args[0]])
 switch (args[0]) {
@@ -265,6 +272,12 @@ describe('stopping a tmux run touches only its own pane', () => {
     // No pane is touched by an id that a restarted server might have handed to the user.
     expect(tmux.read().log).toEqual([])
     expect(Object.keys(tmux.read().panes)).toEqual([run.pane])
+
+    // Once its pane is gone, it can be let go.
+    const state = tmux.read()
+    delete state.panes[run.pane]
+    tmux.write(state)
+    expect(await runPaneState(run, tmux.env)).toBe('gone')
   })
 
   it('lets a tagged run start only once its pane is tagged', async () => {
@@ -311,15 +324,18 @@ describe('stopping a tmux run touches only its own pane', () => {
   it('holds a command until tmux has finished tagging its pane', async () => {
     const tmux = fakeTmux({ exec: true })
     dirs.push(tmux.dir)
-    tmux.write({ ...tmux.read(), delay: { 'set-option': 2_000 } })
+    const release = join(tmux.dir, 'release')
+    tmux.write({ ...tmux.read(), hold: { 'set-option': release } })
     const marker = join(tmux.dir, 'ran')
 
     const starting = startRun('agent', `touch ${JSON.stringify(marker)}`, null, tmux.env)
-    await sleep(1_200)
-    // The pane exists and its script is running, but the tag is not on it yet.
-    expect(Object.keys(tmux.read().panes)).toHaveLength(1)
+    // The pane is open and the tagging call is in flight, held by tmux.
+    await expect.poll(() => tmux.read().held ?? [], { timeout: 10_000 }).toEqual(['set-option'])
+    // Time enough for an ungated command to have run.
+    await sleep(1_000)
     expect(existsSync(marker)).toBe(false)
 
+    writeFileSync(release, '')
     const run = await starting
     if ('error' in run) throw new Error(run.error)
     await expect.poll(() => existsSync(marker), { timeout: 10_000 }).toBe(true)
 
@@ -430,19 +430,19 @@ export async function startRun(
 /**
  * Whether the run's pane is still the run's: `ours`, or `gone` when tmux has no such pane or the
  * pane under that id is not tagged as this run's (the user closed it, or a restarted tmux server
- * handed the id to one of the user's own panes). `unknown` when tmux could not be asked, or the
- * run is untracked: such a pane is neither touched nor given up on.
+ * handed the id to one of the user's own panes). `unknown` when tmux could not be asked, or an
+ * untracked run's pane still exists, since nothing proves whose it is: such a pane is neither
+ * touched nor given up on.
  */
 export async function runPaneState(
   handle: TmuxRunHandle,
   env: NodeJS.ProcessEnv
 ): Promise<'ours' | 'gone' | 'unknown'> {
   if (!handle.pane) return 'gone'
-  if (handle.runId === null) return 'unknown'
-  const shown = await runTmux(
-    ['display-message', '-p', '-t', handle.pane, `#{${RUN_ID_OPTION}}`],
-    env
-  )
+  // An untracked run's pane can still be found missing, with a format every tmux knows.
+  const format = handle.runId === null ? '#{pane_id}' : `#{${RUN_ID_OPTION}}`
+  const shown = await runTmux(['display-message', '-p', '-t', handle.pane, format], env)
+  if (shown.ok && handle.runId === null) return 'unknown'
   if (shown.ok) return shown.stdout.trim() === handle.runId ? 'ours' : 'gone'
   return /can't find|no server running/i.test(shown.stderr) ? 'gone' : 'unknown'
 }