@prohost/cli 0.16.3 → 0.16.5

package/dist/codehost/terminals.js

@@ -20,26 +20,31 @@
  * is the thread already started.
  */
 import { execFile } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
 import { closeSync, openSync, utimesSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { shellQuote } from '../agent/shell.js';
 import { worktreesRoot } from '../agent/worktrees.js';
 import { markTurn } from './activity.js';
+import { markTurnAnswered } from './decision.js';
 import { missingAgentReason } from './agents.js';
 import { claudeConfigDir, claudeTrusts, trustClaudeWorkspace } from './claude_trust.js';
 import { event } from './events.js';
 import { readHistory } from './history.js';
+import { loginOf, readSession } from './session.js';
 import { CODE_THREAD_ID_ENV, TERMINAL_ID_ENV } from './hooks.js';
 import { MAX_OPEN_PTYS } from './pty.js';
-import { claudeSessionSince, isReady, markReady } from './ready.js';
+import { claudeSessionSince, claudeTranscripts, clearReady, isReady, markReady } from './ready.js';
 import { defaultSizeArgs, HOLD_OPTION, holdChannel, holdCommand, resizeWindowArgs, TerminalSizing } from './sizing.js';
 import { noteInputTakeover } from './sizing.js';
-import { attachArgs, baseArgs, clampDim, DEFAULT_COLS, DEFAULT_ROWS, hasSessionArgs, isCopyModeExitKey, isHumanInput, isTypedText, isInterruptInput, isScrollGesture, leaveCopyModeArgs, mayEnterCopyMode, paneInModeArgs, isValidId, killSessionArgs, listWindowsArgs, newSessionArgs, newWindowArgs, parseListWindows, sendTextCommands, setWindowMetaArgs, TERMINAL_WINDOWS, DAEMON_ONLY_ENV, paneEnv, viewSessionName, windowName, windowTarget, } from './tmux.js';
+import { attachArgs, baseArgs, clampDim, DEFAULT_COLS, DEFAULT_ROWS, hasSessionArgs, isCopyModeExitKey, isHumanInput, isTypedText, isInterruptInput, isScrollGesture, leaveCopyModeArgs, mayEnterCopyMode, paneInModeArgs, isValidId, respawnPaneArgs, killSessionArgs, listWindowsArgs, newSessionArgs, newWindowArgs, parseListWindows, sendTextCommands, setWindowMetaArgs, TERMINAL_WINDOWS, DAEMON_ONLY_ENV, paneEnv, viewSessionName, windowName, windowTarget, } from './tmux.js';
 export const CODE_AGENTS = ['claude_code', 'codex', 'shell'];
 export const GOAL_ENV = 'PROHOST_CODE_THREAD_GOAL';
 /** Window option set when the agent exits and its window becomes a shell. */
 export const EXITED_OPTION = '@prohost_exited';
+/** Window option a relaunched pane stamps with its relaunch's token (`CodeTerminals.restart`). */
+export const RELAUNCH_OPTION = '@prohost_relaunch';
 /**
  * Window option that marks a relayed reply as possibly sitting in the agent's
  * input unsubmitted. It is set before the reply's first keystroke reaches the
@@ -77,6 +82,33 @@ export function execTmux(binary = 'tmux') {
         }
     });
 }
+/** What a restart that found no conversation to resume says on its thread. */
+export function freshConversationNote(agent) {
+    const label = agent === 'codex' ? 'Codex' : 'Claude Code';
+    return `${label} restarted in a new conversation: its earlier one wasn't found on this Mac.`;
+}
+/** Shells a thread window falls back to (`exec "${SHELL:-/bin/zsh}" -l`), as `#{pane_current_command}` names them. */
+const SHELL_COMMANDS = new Set(['sh', 'zsh', 'bash', 'fish', 'dash', 'ksh', 'tcsh', 'csh', 'nu']);
+/** Whether a pane's current command is a shell (a login shell's `-zsh` too). */
+export function isShellCommand(command) {
+    return SHELL_COMMANDS.has(path.basename(command.replace(/^-/, '')));
+}
+/**
+ * How long a relaunched agent is watched for quitting at once before its restart is confirmed: a
+ * missing binary or a failed resume exits within a second or two.
+ */
+export const RESTART_SETTLE_POLLS = 6;
+/** How long a relaunched pane may take to stamp its token (wall clock, from the relaunch). */
+export const RESTART_STAMP_WAIT_MS = 10_000;
+export const RESTART_SETTLE_POLL_MS = 500;
+/** How many times a restart's `stop` is posted, and the first pause between tries (doubling). */
+export const RESTART_STOP_ATTEMPTS = 3;
+export const RESTART_STOP_BACKOFF_MS = 500;
+/** Then, in the background, this many more rounds, the n-th after n × the pause. */
+export const RESTART_STOP_LATER_ATTEMPTS = 4;
+export const RESTART_STOP_LATER_PAUSE_MS = 15_000;
+/** How old a restart may be when it reaches this Mac (the server's `RESTART_MAX_AGE`). */
+export const RESTART_MAX_AGE_MS = 10 * 60_000;
 /**
  * Whether an event post's status settles it (see {@link StartResult}): the
  * server applied it (2xx) or will refuse it the same way every time (404, 409,
@@ -96,12 +128,20 @@ export const CLAUDE_SKIP_PERMISSIONS_FLAG = '--dangerously-skip-permissions';
  * `-a never` alone would keep the sandbox, where a command needing the network fails instead of asking.
  */
 export const CODEX_SKIP_PERMISSIONS_FLAG = '--dangerously-bypass-approvals-and-sandbox';
+/** Claude Code's (`claude --help`, 2.1.318): "Continue the most recent conversation in the current directory". */
+export const CLAUDE_CONTINUE_FLAG = '--continue';
+/**
+ * Codex's (`codex resume --help`, 0.146): the most recent session without the picker, filtered to
+ * the current folder (`--all` would lift that). Its own options (`-c`, the skip flag) follow it.
+ */
+export const CODEX_RESUME_ARGS = 'resume --last';
 /** The shell command line a thread's agent window runs. */
 export function agentCommandLine(agent, options) {
+    const resume = options.resume;
     // `--` first: a goal is the agent's prompt, never an option, however it
     // starts (`--dangerously-skip-permissions`, or a word Codex would read as a
     // subcommand).
-    const goal = options.hasGoal ? ` -- "$${GOAL_ENV}"` : '';
+    const goal = options.hasGoal && !resume ? ` -- "$${GOAL_ENV}"` : '';
     const skip = options.skipPermissions === true;
     const shell = 'exec "${SHELL:-/bin/zsh}" -l';
     if (agent === 'shell')
@@ -113,10 +153,12 @@ export function agentCommandLine(agent, options) {
     const after = `tmux set-option -w ${EXITED_OPTION} 1 2>/dev/null; ` +
         `printf '\\n[${label} exited — this window is now a shell in the thread worktree]\\n'; ${shell}`;
     if (agent === 'codex') {
-        const flags = skip ? ` ${CODEX_SKIP_PERMISSIONS_FLAG}` : '';
+        const resumeArgs = resume === undefined ? '' : resume === 'latest' ? ` ${CODEX_RESUME_ARGS}` : ` resume ${shellQuote(resume, 'darwin')}`;
+        const flags = `${resumeArgs}${skip ? ` ${CODEX_SKIP_PERMISSIONS_FLAG}` : ''}`;
         return `codex${flags} -c ${shellQuote(options.codexNotify, 'darwin')}${goal}; ${after}`;
     }
-    const claude = `command claude${skip ? ` ${CLAUDE_SKIP_PERMISSIONS_FLAG}` : ''} --settings`;
+    const resumeFlag = resume === undefined ? '' : resume === 'latest' ? ` ${CLAUDE_CONTINUE_FLAG}` : ` --resume ${shellQuote(resume, 'darwin')}`;
+    const claude = `command claude${resumeFlag}${skip ? ` ${CLAUDE_SKIP_PERMISSIONS_FLAG}` : ''} --settings`;
     // A window that skips prompts reads the documents that also accept Claude Code's bypass warning.
     const settings = (skip && options.claudeSkipSettings) || options.claudeSettings;
     const invocationSettings = (skip && options.claudeInvocationSkipSettings) || options.claudeInvocationSettings;
@@ -187,6 +229,10 @@ export class CodeTerminals {
     /** Per terminal: the tail of its typing queue (see {@link serialize}). */
     typing = new Map();
     openPtys = 0;
+    /** The last `adopt` look timed out (`TmuxResult.uncertain`): records were kept, not re-read. */
+    lastListUncertain = false;
+    /** Each agent window's pane process at the last `adopt`: a restart is confirmed by its changing. */
+    panePids = new Map();
     /** Who sizes each window, and what its viewers are told (`sizing.ts`). */
     sizing;
     log;
@@ -302,6 +348,10 @@ export class CodeTerminals {
     }
     async adopt() {
         const listed = await this.tmux(listWindowsArgs());
+        // A look tmux didn't answer in time says nothing about what survived: what is known stays.
+        this.lastListUncertain = !listed.ok && listed.uncertain === true;
+        if (this.lastListUncertain)
+            return this.records.size;
         if (!listed.ok) {
             // No server or no session: nothing survived, and nothing is wrong.
             this.records.clear();
@@ -327,6 +377,7 @@ export class CodeTerminals {
         this.records.clear();
         for (const [id, record] of found)
             this.records.set(id, record);
+        this.panePids = panes;
         // Once per daemon start: the windows an older build left behind are all there now. Started by
         // the first call; every call waits for it, so none returns before those windows are marked. A
         // pass that fails (a keychain still locked right after login) never fails an adopt: it is
@@ -576,6 +627,319 @@ export class CodeTerminals {
             await this.sleep(TRUST_POLL_MS);
         }
     }
+    /**
+     * Relaunch a thread's Claude Code or Codex in its own window and folder, continuing its
+     * conversation (`code_thread.restart_requested`): the process in the agent window is replaced
+     * (`respawn-pane -k`), so the window, its viewers and its size stay. Run with
+     * {@link RestartRequest.skipPermissions}, it no longer asks before running commands, as a start
+     * that skips prompts (the same flags and `--settings` documents). Whatever the old one was doing
+     * stops: the person asked for that, from the thread they own.
+     *
+     * It resumes the session the window's hooks recorded (`session.ts`); a worktree of the thread's
+     * own may fall back to its latest session.
+     *
+     * Refused (nothing is touched, the server says so on the thread) with remote control off
+     * (`remote_terminal_disabled`: as for a start, nothing from ProhostAI starts an agent that runs
+     * commands unasked then), for a thread whose window is gone (`terminal_gone`), for a shell
+     * thread (`shell_window`), or while its session isn't known in a folder it shares
+     * (`session_unknown`). An agent that exited into its shell is relaunched all the same.
+     * Serialized with the thread's replies, so it never lands between a paste and its Enter.
+     */
+    async restart(request, outcome = {}, hooks = {}) {
+        if (!isValidId(request.terminalId) || !isValidId(request.codeThreadId))
+            return false;
+        return this.serialize(request.terminalId, () => this.restartNow(request, outcome, hooks));
+    }
+    /** Once every typing job and restart already queued for the terminal has finished (never rejects). */
+    async settled(terminalId) {
+        await (this.typing.get(terminalId) ?? Promise.resolve()).catch(() => undefined);
+    }
+    /** The agent window's pane process as tmux says now; `undefined` when it didn't answer or has none. */
+    async panePidNow(terminalId) {
+        const listed = await this.tmux(listWindowsArgs());
+        if (!listed.ok)
+            return undefined;
+        const name = windowName(terminalId, 'agent');
+        return parseListWindows(listed.stdout).find((window) => window.name === name)?.panePid;
+    }
+    /** Whether the thread's folder is a worktree this host made for threads (never one of the owner's own). */
+    ownsFolder(record) {
+        const relative = path.relative(worktreesRoot({ PROHOST_HOME: this.options.home }), record.cwd);
+        return Boolean(relative) && !relative.startsWith('..') && !path.isAbsolute(relative);
+    }
+    async restartNow(request, outcome, hooks) {
+        const short = request.codeThreadId.slice(0, 12);
+        const refuse = (reason, why) => {
+            this.log(`    ! code thread ${short} not restarted: ${why}`);
+            outcome.refused = reason;
+            return false;
+        };
+        // Too late to stop a turn nobody expects to stop (the Mac was asleep or offline).
+        if (request.requestedAtMs !== undefined && this.now() - request.requestedAtMs > RESTART_MAX_AGE_MS) {
+            return refuse('restart_expired', 'it arrived too late');
+        }
+        // Re-read tmux first: a window closed since the last look is gone, not retried. A look that timed
+        // out says nothing either way (the window may well be there): sent again later.
+        await this.adopt();
+        if (this.lastListUncertain) {
+            this.log(`    ! code thread ${short} not restarted yet: tmux did not answer`);
+            outcome.retry = true;
+            return false;
+        }
+        const record = this.records.get(request.terminalId);
+        if (!record || record.codeThreadId !== request.codeThreadId)
+            return refuse('terminal_gone', 'its terminal is gone');
+        if (record.agent !== 'claude_code' && record.agent !== 'codex')
+            return refuse('shell_window', 'it is a shell');
+        if (request.skipPermissions && !this.canType())
+            return refuse('remote_terminal_disabled', 'remote control is off');
+        const agent = record.agent;
+        const account = this.options.accountEnv?.(agent) ?? { ok: true, env: {} };
+        if (!account.ok)
+            return refuse('login_unavailable', account.reason);
+        const launchEnv = { ...(this.options.processEnv ?? process.env), ...agentWindowEnv(agent, account.env) };
+        const recorded = readSession(record.terminalId, { PROHOST_HOME: this.options.home });
+        // Never a silent switch to another login: the conversation lives under the one it ran on.
+        if (recorded && recorded.login !== loginOf(agent, launchEnv)) {
+            return refuse('login_changed', `its session is on another ${agent} login than this Mac runs now`);
+        }
+        const resume = this.resumeTarget(agent, record, recorded?.id, launchEnv);
+        if (resume === null)
+            return refuse('session_unknown', `which ${agent} session its window runs isn't known yet`);
+        const name = windowName(record.terminalId, 'agent');
+        const target = windowTarget(name);
+        const env = { PROHOST_HOME: this.options.home };
+        // From inside the pane, before the agent: an agent that dies at once marks its window a shell
+        // again (`agentCommandLine`'s `after`), never after this clears it.
+        // The pane itself, once the new process really runs and before the agent: lifts the exited mark of
+        // whatever ran before and stamps this relaunch's token. The daemon never lifts the mark itself (a
+        // window that is still a shell must keep refusing replies), and trusts a mark only after seeing the
+        // token (`exitsAtOnce`): a stale mark can never read as the new agent quitting.
+        const token = randomBytes(8).toString('hex');
+        const command = `tmux set-option -wu ${EXITED_OPTION} 2>/dev/null; tmux set-option -w ${RELAUNCH_OPTION} ${token} 2>/dev/null; ` +
+            agentCommandLine(agent, { ...this.options.hookFiles, hasGoal: false, skipPermissions: request.skipPermissions, resume });
+        // Like a new window: replies wait for the new Claude Code's first hook (`ready.ts`). Dropped before
+        // the old process goes, so that hook's mark is never wiped after it was written.
+        // The switch once more, as late as it can be: nothing awaits between here and `respawn-pane`, so a
+        // `remote off` that landed during the looks above stops it before anything is claimed or touched.
+        if (request.skipPermissions && !this.canType())
+            return refuse('remote_terminal_disabled', 'remote control went off');
+        // Claimed only now, past every refusal: a redelivery after any earlier failure is judged afresh,
+        // and one queued behind this attempt sees its real outcome (`CodeHost.handleRestart`).
+        const claimed = hooks.claim ? hooks.claim() : true;
+        if (claimed === 'unsaved') {
+            outcome.retry = true;
+            return false;
+        }
+        if (!claimed) {
+            outcome.repeat = true;
+            return false;
+        }
+        const before = this.panePids.get(record.terminalId);
+        const wasReady = agent === 'claude_code' && this.isReady(record.terminalId) === true;
+        if (agent === 'claude_code')
+            clearReady(record.terminalId, env);
+        // The restart's own `stop` is stamped now, before the new pane exists: any hook the new agent
+        // sends is strictly newer and wins under the server's host-event ordering, never this one.
+        const stopAt = this.now();
+        const respawned = await this.tmux(respawnPaneArgs({
+            name,
+            cwd: record.cwd,
+            env: {
+                ...agentWindowEnv(agent, account.env),
+                PROHOST_HOME: this.options.home,
+                [TERMINAL_ID_ENV]: record.terminalId,
+                [CODE_THREAD_ID_ENV]: record.codeThreadId,
+            },
+            command,
+        }));
+        if (!respawned.ok && !respawned.uncertain) {
+            // Nothing was replaced: the old process (and its readiness) stays, and it is worth sending again.
+            if (wasReady)
+                markReady(record.terminalId, env);
+            this.log(`    ! code thread ${short} not restarted: tmux said ${respawned.stderr.trim()}`);
+            outcome.retry = true;
+            outcome.release = true;
+            return false;
+        }
+        // Done only once the window is seen running a new process (its pane's pid changed) and the agent
+        // still runs in it a moment later. tmux saying yes (or timing out) is not enough to tell the server
+        // prompts are off.
+        const after = await this.panePidNow(record.terminalId);
+        if (after !== undefined && after === before) {
+            // The same process still runs: nothing was replaced. It keeps its readiness, and is sent again.
+            if (wasReady)
+                markReady(record.terminalId, env);
+            this.log(`    ! code thread ${short} not restarted: its window still runs the same process`);
+            outcome.retry = true;
+            outcome.release = true;
+            return false;
+        }
+        const replaced = after !== undefined && before !== undefined;
+        if (!replaced && !respawned.ok) {
+            // Can't be told (tmux timed out and didn't answer the look): the old process may still run, so
+            // its state stays as it was. Never done twice, never reported done.
+            this.log(`    ! code thread ${short}: couldn't confirm ${agent} restarted; it may or may not have`);
+            outcome.refused = 'restart_unconfirmed';
+            return false;
+        }
+        if (after !== undefined)
+            this.panePids.set(record.terminalId, after);
+        // The old process is gone (seen, or tmux said so): nothing of an old reply left in its input, no
+        // permission menu of it open, not mid-turn, and the thread is the person's turn.
+        await this.tmux(['set-option', '-wu', '-t', target, STAGED_OPTION]);
+        markTurnAnswered(record.terminalId, env, this.now);
+        markTurn(record.terminalId, false, env);
+        if (agent === 'claude_code' && !record.readyMark) {
+            // This build's mark governs it from now on.
+            for (const args of setWindowMetaArgs(name, { ...record, readyMark: true }))
+                await this.tmux(args);
+            this.records.set(record.terminalId, { ...record, readyMark: true });
+        }
+        const exit = replaced ? await this.exitsAtOnce(target, token) : 'running';
+        // A session whose conversation wasn't found started a new one, and the thread says so (never
+        // "continues the same conversation" silently).
+        const fresh = resume === undefined && recorded !== undefined && replaced && exit === 'running';
+        // One event, built once: every try (and every later one) sends the same body and stamp, so the
+        // server applies it once (a repeat of a stamp it has is a redelivery) and a newer hook event of
+        // the new agent is never overtaken by it.
+        const stop = event('stop', fresh ? { finalText: freshConversationNote(agent), question: true } : { question: true }, stopAt);
+        if (!replaced || exit !== 'running') {
+            // Not a confirmed relaunch: said to the server for what it is (below). Its turn state is tried
+            // once before that refusal, then the same event again in the background: a window that is a
+            // shell now sends no hook of its own that would correct it.
+            const status = await this.options.events.post(record.codeThreadId, stop);
+            if ((status < 200 || status >= 300) && !isDefinitive(status)) {
+                void this.postRestartStopLater(record.codeThreadId, stop);
+            }
+        }
+        if (!replaced) {
+            // tmux said it relaunched, but the window couldn't be looked at: not reported done.
+            this.log(`    ! code thread ${short}: ${agent} relaunched, but its window couldn't be checked`);
+            outcome.refused = 'restart_unconfirmed';
+            return false;
+        }
+        if (exit === 'exited') {
+            // A new process, but the agent quit at once (a missing binary, a resume that failed), and the
+            // pane says it runs a shell: the window is its shell now. Never reported as an agent at all.
+            this.log(`    ! code thread ${short}: ${agent} exited right after restarting; its window is a shell`);
+            outcome.refused = 'agent_exited';
+            return false;
+        }
+        if (exit === 'unclear') {
+            // The signals disagree: it may well be running without prompts. Never said to be a shell, never
+            // said done: the server keeps it asking and says it may run without asking.
+            this.log(`    ! code thread ${short}: couldn't tell whether ${agent} still runs after restarting`);
+            outcome.refused = 'restart_unconfirmed';
+            return false;
+        }
+        // Confirmed: the agent runs without prompts in that window. Recorded as done first (the ledger:
+        // no redelivery relaunches it again, whatever the post below does), and acknowledged done, so the
+        // server records it and never offers it again.
+        hooks.confirmed?.();
+        if (!(await this.postRestartStop(record.codeThreadId, stop))) {
+            // Only the thread's turn state is behind (the agent's own next hook corrects it too): the same
+            // event keeps being sent a while longer, never a relaunch.
+            this.log(`    ! code thread ${short}: ${agent} restarted; its waiting state hasn't reached ProhostAI yet, retrying`);
+            void this.postRestartStopLater(record.codeThreadId, stop);
+        }
+        this.log(`    ↻ code thread ${short}: ${agent} restarted${request.skipPermissions ? ' without permission prompts' : ''}`);
+        if (agent === 'claude_code') {
+            void this.watchTrustPrompt(record.codeThreadId, record.terminalId, name, request.skipPermissions);
+        }
+        return true;
+    }
+    /**
+     * Whether a just-relaunched agent quits within a moment. First waits (until {@link RESTART_STAMP_WAIT_MS}
+     * have passed) for the window to carry this relaunch's `token` ({@link RELAUNCH_OPTION}, stamped by the new
+     * process's own pane after it lifted the old exited mark); only then is {@link EXITED_OPTION} read as
+     * the new agent's, over {@link RESTART_SETTLE_POLLS} more looks from that moment. `exited` only when that mark and the pane running a shell (`#{pane_current_command}`)
+     * agree; `running` only when the token was seen and the last look was answered without the mark;
+     * anything else (never seen, a look unanswered, the signals disagreeing) is `unclear`.
+     */
+    async exitsAtOnce(target, token) {
+        // First the stamp, in its own bounded wait: a login shell's start-up (`.zshenv`, a Mac just awake)
+        // can take seconds before the pane's prefix runs.
+        // A wall-clock bound: a look tmux is slow to answer counts against it too.
+        const deadline = this.now() + RESTART_STAMP_WAIT_MS;
+        let stamped = false;
+        while (!stamped && this.now() < deadline) {
+            await this.sleep(RESTART_SETTLE_POLL_MS);
+            const stamp = await this.tmux(['show-options', '-wqv', '-t', target, RELAUNCH_OPTION]);
+            stamped = stamp.ok && stamp.stdout.trim() === token;
+        }
+        if (!stamped)
+            return 'unclear';
+        // Then the agent gets its full settle time from that moment, whenever the stamp came.
+        let lastAnswered = false;
+        for (let look = 0; look < RESTART_SETTLE_POLLS; look += 1) {
+            await this.sleep(RESTART_SETTLE_POLL_MS);
+            lastAnswered = false;
+            const stamp = await this.tmux(['show-options', '-wqv', '-t', target, RELAUNCH_OPTION]);
+            // Another relaunch's stamp, or no answer: nothing can be read from the mark.
+            if (!stamp.ok || stamp.stdout.trim() !== token)
+                continue;
+            const shown = await this.tmux(['show-options', '-wqv', '-t', target, EXITED_OPTION]);
+            if (!shown.ok)
+                continue;
+            lastAnswered = true;
+            if (shown.stdout.trim() !== '1')
+                continue;
+            const command = await this.tmux(['display-message', '-p', '-t', target, '#{pane_current_command}']);
+            if (!command.ok)
+                return 'unclear';
+            return isShellCommand(command.stdout.trim()) ? 'exited' : 'unclear';
+        }
+        return lastAnswered ? 'running' : 'unclear';
+    }
+    /**
+     * The restart's `stop` (the person's turn), tried {@link RESTART_STOP_ATTEMPTS} times with a
+     * growing pause: whether ProhostAI took it (2xx). A restart is acknowledged done only after that.
+     */
+    async postRestartStop(codeThreadId, stop) {
+        for (let attempt = 0; attempt < RESTART_STOP_ATTEMPTS; attempt += 1) {
+            if (attempt > 0)
+                await this.sleep(RESTART_STOP_BACKOFF_MS * 2 ** (attempt - 1));
+            const status = await this.options.events.post(codeThreadId, stop);
+            if (status >= 200 && status < 300)
+                return true;
+            // An answer it will keep giving (a 4xx other than 401/403/408/429): trying again changes nothing.
+            if (isDefinitive(status))
+                return false;
+        }
+        return false;
+    }
+    /** The same `stop`, sent again a few times over a few minutes, in the background; never throws. */
+    async postRestartStopLater(codeThreadId, stop) {
+        try {
+            for (let attempt = 0; attempt < RESTART_STOP_LATER_ATTEMPTS; attempt += 1) {
+                await this.sleep(RESTART_STOP_LATER_PAUSE_MS * (attempt + 1));
+                if (await this.postRestartStop(codeThreadId, stop))
+                    return;
+            }
+        }
+        catch {
+            /* the agent's own next hook says whose turn it is */
+        }
+    }
+    /**
+     * What a restart resumes (`agentCommandLine`'s `resume`): the recorded session when its
+     * conversation exists; `'latest'` in a worktree of the thread's own; `undefined` (a fresh start)
+     * when there is no conversation yet; `null` when it can't be told (a folder of the owner's, its
+     * session never reported). Claude Code writes a session's transcript only once its first prompt
+     * runs (`ready.ts`), so a session id from `SessionStart` alone has nothing to resume. Codex reports
+     * its id only after a turn (`notify`), so a recorded one has.
+     */
+    resumeTarget(agent, record, sessionId, launchEnv) {
+        if (agent === 'codex')
+            return sessionId ?? (this.ownsFolder(record) ? 'latest' : null);
+        const transcripts = claudeTranscripts(record.cwd, claudeConfigDir(launchEnv));
+        if (sessionId)
+            return transcripts.includes(`${sessionId}.jsonl`) ? sessionId : undefined;
+        if (!this.ownsFolder(record))
+            return null;
+        return transcripts.length > 0 ? 'latest' : undefined;
+    }
     async known(terminalId) {
         if (!isValidId(terminalId))
             return undefined;

package/dist/codehost/tmux.d.ts

@@ -63,6 +63,12 @@ export interface NewWindowSpec {
     command: string;
 }
 export declare function newWindowArgs(spec: NewWindowSpec): string[];
+/**
+ * Replace the process in a window's pane (`respawn-pane -k`: the one running is killed) with
+ * `command`, in `cwd` and with `env` as {@link newWindowArgs} gives them: the same window (its name,
+ * options, size and viewers) runs something new.
+ */
+export declare function respawnPaneArgs(spec: NewWindowSpec): string[];
 /** Window options that let a restarted daemon re-adopt a thread. */
 export interface WindowMeta {
     terminalId: string;

package/dist/codehost/tmux.js

@@ -128,6 +128,15 @@ export function newWindowArgs(spec) {
     const env = Object.entries(spec.env).flatMap(([key, value]) => ['-e', `${key}=${value}`]);
     return ['new-window', '-d', '-t', `${TMUX_SESSION}:`, '-n', spec.name, '-c', spec.cwd, ...env, spec.command];
 }
+/**
+ * Replace the process in a window's pane (`respawn-pane -k`: the one running is killed) with
+ * `command`, in `cwd` and with `env` as {@link newWindowArgs} gives them: the same window (its name,
+ * options, size and viewers) runs something new.
+ */
+export function respawnPaneArgs(spec) {
+    const env = Object.entries(spec.env).flatMap(([key, value]) => ['-e', `${key}=${value}`]);
+    return ['respawn-pane', '-k', '-t', windowTarget(spec.name), '-c', spec.cwd, ...env, spec.command];
+}
 export function setWindowMetaArgs(name, meta) {
     const target = windowTarget(name);
     return [

package/dist/host/api.d.ts

@@ -61,6 +61,13 @@ export type ClaimResult = {
  | {
     kind: 'elsewhere';
 }
+/**
+ * `409 conversation_busy`: an earlier turn of the same employee's conversation is still open.
+ * The run stays queued here; the server sends its frame again when that turn ends.
+ */
+ | {
+    kind: 'busy';
+}
 /** Gone server-side (404 / 410): nothing to run. */
  | {
     kind: 'gone';
@@ -78,5 +85,4 @@ export type ClaimResult = {
     status: number;
     error?: string;
 };
-/** Claim a run for this computer. Exactly one computer ever gets a 200. */
 export declare function claimRun(options: ComputerApiOptions, computerId: string, runId: string): Promise<ClaimResult>;

package/dist/host/api.js

@@ -94,6 +94,20 @@ function parseSkills(value) {
     });
 }
 /** Claim a run for this computer. Exactly one computer ever gets a 200. */
+/** A refusal's code: `{detail: {error}}`, `{detail: "<code>"}` or `{error}`, matched exactly by the caller. */
+function errorCode(body) {
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        return undefined;
+    const top = body;
+    const detail = top.detail;
+    if (typeof detail === 'string')
+        return detail;
+    if (detail && typeof detail === 'object' && !Array.isArray(detail)) {
+        const code = detail.error;
+        return typeof code === 'string' ? code : undefined;
+    }
+    return typeof top.error === 'string' ? top.error : undefined;
+}
 export async function claimRun(options, computerId, runId) {
     const response = await callJson(options, claimPath(computerId, runId), {});
     if (response.status === 200 || response.status === 201) {
@@ -112,7 +126,7 @@ export async function claimRun(options, computerId, runId) {
         };
     }
     if (response.status === 409)
-        return { kind: 'elsewhere' };
+        return errorCode(response.body) === 'conversation_busy' ? { kind: 'busy' } : { kind: 'elsewhere' };
     if (response.status === 404 || response.status === 410)
         return { kind: 'gone', status: response.status };
     if (response.status === 0 || response.status === 429 || response.status >= 500) {