openmausbot 0.1.96 → 0.1.98

package/dist-server/server/drivers/acp/opencode-go.js

@@ -432,8 +432,6 @@ export function resetOpenCodeModelCache() {
 /** Compatibility export for older tests/imports while the product migrates
  * from the Go-only name. */
 export const resetOpenCodeGoModelCache = resetOpenCodeModelCache;
-/** The names live in config.ts, beside the keys the owner saves for OpenCode. */
-export { OPENCODE_PROVIDER_ENV };
 /** Whether OpenCode may read provider keys from the server's own
  * environment. Only when that environment is the person's own shell: not on a
  * Cloud home, a hosted team workspace or an organisation-managed desktop, and
@@ -453,23 +451,16 @@ let providerKeysAllowed = () => openCodeProviderKeysAllowed({
 export function setOpenCodeProviderKeyPolicy(allowed) {
     providerKeysAllowed = allowed;
 }
-let ownProviderKeys = () => ({});
-/** The keys the owner saved for OpenCode in Settings (config.ts
- * openCodeProviderKeys). The server sets this beside the policy above. */
-export function setOpenCodeOwnProviderKeys(keys) {
-    ownProviderKeys = keys;
-}
-function withholdProviderKeysWhenManaged(env) {
+/** Where OpenCode may not read the server's own environment, a provider key
+ * reaches it only through its instance environment: a key the owner saved
+ * in Settings (config.ts injectedEnvironment), which is theirs on any
+ * server. The same name riding along in the server's env stays out. */
+function withholdProviderKeysWhenManaged(env, _config, _instanceId, instanceEnvironment) {
     if (providerKeysAllowed())
         return;
-    const own = ownProviderKeys();
     for (const key of OPENCODE_PROVIDER_ENV) {
-        // A key the owner saved for OpenCode in Settings is theirs to use on any
-        // server. Only that exact value: the server's own key under the same
-        // name still stays out.
-        if (own[key] !== undefined && env[key] === own[key])
-            continue;
-        delete env[key];
+        if (!Object.hasOwn(instanceEnvironment, key))
+            delete env[key];
     }
 }
 function opencodeConfigDir(env) {
@@ -766,8 +757,10 @@ function allowOwnedDirectories(env, botId, cwd) {
 /** Account failures in plain words, with the fix, naming the provider that
  * refused: with provider keys and `opencode auth login` a model may be
  * OpenRouter's or Anthropic's, not Zen's. Each stays under the 160
- * characters a chat error row shows. */
-export function describeOpenCodeAccountError(code, model) {
+ * characters a chat error row shows. Zen and Go take the key saved in
+ * Settings. On a Cloud the owner has no terminal for `opencode auth login`:
+ * another provider's key is saved under Keys for other OpenCode providers. */
+export function describeOpenCodeAccountError(code, model, where = { cloudHome: cloudHomeConfigured() }) {
     const provider = model && model.includes("/") ? model.slice(0, model.indexOf("/")) : "";
     const zen = provider === "opencode";
     const go = provider === "opencode-go";
@@ -776,8 +769,10 @@ export function describeOpenCodeAccountError(code, model) {
     switch (code) {
         case "invalid_credentials":
             return zen || go || !provider
-                ? "OpenCode rejected its key, or has none for this model. Fix it in Settings → API keys or with `opencode auth login`."
-                : `OpenCode's ${name} key for this model is missing or was rejected. Fix it with \`opencode auth login\`, or choose another model.`;
+                ? "OpenCode rejected its key, or has none for this model. Add or replace the OpenCode key in Settings → API keys."
+                : where.cloudHome
+                    ? `OpenCode's ${name} key for this model is missing or was rejected. Save it under Keys for other OpenCode providers in Settings → API keys.`
+                    : `OpenCode's ${name} key for this model is missing or was rejected. Fix it with \`opencode auth login\`, or choose another model.`;
         case "insufficient_funds":
             return zen || !provider
                 ? "Your OpenCode Zen balance has run out. Add credit at opencode.ai, or choose one of Zen's free models for this bot."
@@ -812,7 +807,7 @@ const support = (loadCatalog) => ({
     models: NO_MODELS,
     defaultCli: "opencode",
     nativeSource: "opencode.acp",
-    loginNote: "OpenCode has no usable models — run `opencode auth login` or connect a provider in the OpenCode app",
+    loginNote: "OpenCode has no usable models. Add an OpenCode key in Settings → API keys.",
     install: {
         command: {
             darwin: "npm install -g opencode-ai",

package/dist-server/server/drivers/agents-call.js

@@ -259,7 +259,7 @@ function routineFields(args) {
     const runOn = destination(args.run_on ?? args.runOn);
     const timeoutMinutes = args.timeout_minutes ?? args.timeoutMinutes;
     if (runOn != null && runOn !== "maus" && runOn !== "cloud") {
-        return { fields, error: 'Use run_on="maus" for the bot’s current model and configured computer (including VPS), or run_on="box" only for the bot’s Boat cloud computer. Legacy "cloud" also means Boat.' };
+        return { fields, error: 'Use run_on="maus" for the bot’s current model and configured computer (including VPS), or run_on="box" only for the bot’s cloud computer. Legacy "cloud" also means box.' };
     }
     if (timeoutMinutes != null && (typeof timeoutMinutes !== "number" || !Number.isInteger(timeoutMinutes) || timeoutMinutes < 5 || timeoutMinutes > 240)) {
         return { fields, error: "timeout_minutes must be a whole number from 5 to 240. Use clear_timeout to remove a limit." };

package/dist-server/server/drivers/agents-catalog.js

@@ -26,6 +26,7 @@ export function catalogProfileFromEnv(env) {
         voiceNotes: env.OMB_VOICE_NOTES === "1",
         cloudHome: env.OMB_CLOUD_HOME === "1",
         memoryEnabled: env.OMB_MEMORY_ENABLED !== "0",
+        chief: env.OMB_CHIEF_OF_STAFF === "1",
         botId: env.OMB_BOT_ID ?? "",
     };
 }
@@ -132,7 +133,7 @@ const ROUTINE_FIELDS_SCHEMA = {
         type: "string",
         // "box" is Boat's historical run_on destination id (agents wire contract).
         enum: ["maus", "box"],
-        description: "Default maus keeps the bot's selected model and configured computer, INCLUDING a self-hosted VPS. Omit this field for normal schedules. box runs on the bot's Boat cloud computer, same model; it requires Boat setup and is not the generic cloud/VPS option. Legacy cloud values from list_routines mean box, not VPS.",
+        description: "Default maus keeps the bot's selected model and configured computer, INCLUDING a self-hosted VPS. Omit this field for normal schedules. box runs on the bot's cloud computer, same model; it needs cloud computers set up and is not the generic cloud/VPS option. Legacy cloud values from list_routines mean box, not VPS.",
     },
     timeout_minutes: {
         type: "integer",
@@ -146,7 +147,7 @@ const ROUTINE_FIELDS_SCHEMA = {
     },
     continuity: {
         type: "boolean",
-        description: "Opt in to using the latest completed run's bounded report as historical context. Defaults to false; set false in an update to start fresh again. Included in the applied result or pending confirmation.",
+        description: "Opt in to using the latest completed run's bounded report as historical context. Use it for recurring work that builds on last time, such as QA passes, monitoring or follow-ups. Defaults to false; set false in an update to start fresh again. Included in the applied result or pending confirmation.",
     },
     overlap: {
         type: "string",
@@ -154,6 +155,9 @@ const ROUTINE_FIELDS_SCHEMA = {
         description: "While this routine is still working, skip scheduled occurrences (default) or queue at most one run. Queue skips further occurrences until the pending run starts; it never builds an unlimited backlog. Manual and webhook requests are separate.",
     },
 };
+// propose_profile's one sentence about for_bot_id, which a bot that is not a
+// Chief is not shown (catalogTools), along with the parameter itself.
+const CHIEF_PROFILE_TARGET = " A Chief of Staff may pass for_bot_id (from list_bots) for a requested change to another bot in its section.";
 const PROPOSAL_OUTCOME = " Read the result: granted Full Access may apply the change immediately. If applied, continue the requested work without another confirmation. Only a pending result requires ending the turn and waiting for the in-app decision. Never claim success from the permission mode alone; report failed or cancelled results honestly. This does not elevate another bot's execution permissions.";
 /** Every tool, in the order it is listed. Four peer tools are worded
  * differently for an external runtime, which may poll inside one process. */
@@ -303,7 +307,7 @@ const toolDefinitions = (externalRuntime) => [
         description: "Choose where this conversation does computer work. Call with no arguments to inspect actual available choices and the current place. For a task needing computer interaction, select the requested place, or auto to choose a suitable configured computer without asking the user to use menus. OpenMausBot reuses an existing computer first; with a configured provider it can start or provision one when needed. Do not provision for ordinary chat or just to inspect availability. A pending result means end this turn immediately: OpenMausBot updates the conversation selector and resumes the original request with that computer's real tools. Do not use the old tools after requesting a switch, repeat the task, or claim the action is done. This cannot change permissions, override Off, or switch a teammate/routine/channel.",
         inputSchema: { type: "object", additionalProperties: false, properties: {
                 surface: { type: "string", enum: ["auto", "cloud", "vm", "local", "browser"],
-                    description: "auto = suitable configured computer, cloud = remote Boat/VPS, vm = isolated Local VM, local = user's own desktop, browser = built-in browser. Omit to list." },
+                    description: "auto = suitable configured computer, cloud = the bot's cloud computer or self-hosted VPS, vm = isolated Local VM, local = user's own desktop, browser = built-in browser. Omit to list." },
             } },
     },
     {
@@ -652,7 +656,7 @@ const toolDefinitions = (externalRuntime) => [
     },
     {
         name: "propose_profile",
-        description: "Submit user-requested changes to your own name, title, description, standing instructions (SOUL.md), working folder (cwd), or your alert and voice toggles (notifications, speakReplies). Keep SOUL.md short — who you are and the rules you never break; put step-by-step procedure into a skill instead. A Chief of Staff may pass for_bot_id (from list_bots) for a requested change to another bot in its section." + PROPOSAL_OUTCOME,
+        description: "Submit user-requested changes to your own name, title, description, standing instructions (SOUL.md), working folder (cwd), or your alert and voice toggles (notifications, speakReplies). Keep SOUL.md short — who you are and the rules you never break; put step-by-step procedure into a skill instead." + CHIEF_PROFILE_TARGET + PROPOSAL_OUTCOME,
         inputSchema: {
             type: "object",
             additionalProperties: false,
@@ -842,6 +846,14 @@ export const SHARED_COMPUTER_TOOL_NAMES = new Set(["list_shared_computers", "sha
 // tool whose every call would end in a setup error. The route behind it
 // refuses regardless; this keeps the catalog honest about what can work.
 const VOICE_TOOL_NAMES = new Set(["send_voice_note"]);
+// And for a role: every route behind these refuses a bot that is not its
+// section's Chief of Staff, as it does a for_bot_id naming another bot on
+// propose_profile or propose_model. (A routine's for_bot_id is open to any
+// bot that can reach that peer, so it stays.)
+const CHIEF_ONLY_TOOL_NAMES = new Set([
+    "create_bot", "list_team_setup", "propose_team_setup", "propose_bot_deletion", "create_room", "manage_room", "retry_thread",
+]);
+const CHIEF_TARGET_TOOL_NAMES = new Set(["propose_profile", "propose_model"]);
 // One teamwork path in room turns; keep all unrelated integrations available.
 // Ordinary direct chats use this same bounded coordinator. Goal-owned turns
 // retain their independent loop and cannot start a second coordinator.
@@ -854,7 +866,7 @@ const WATCHER_TOOL_NAMES = new Set(["create_options_card"]);
 const LOCAL_VM_TOOL_NAMES = new Set(["vm_exec"]);
 const CLOUD_HOME_SURFACE = {
     type: "string", enum: ["auto", "cloud", "browser"],
-    description: "auto = suitable configured computer, cloud = remote Boat/VPS, browser = built-in browser. Omit to list. This server runs in the cloud: the user's own computer and a Local VM are not places here.",
+    description: "auto = suitable configured computer, cloud = the bot's cloud computer, browser = built-in browser. Omit to list. This server runs in the cloud: the user's own computer and a Local VM are not places here.",
 };
 /** The tools one turn is shown, exactly as tools/list serializes them. */
 export function availableTools(profile) {
@@ -878,10 +890,18 @@ function catalogTools(profile) {
     const VOICE_READY_TOOLS = profile.voiceNotes
         ? SHAREABLE_TOOLS
         : SHAREABLE_TOOLS.filter((tool) => !VOICE_TOOL_NAMES.has(tool.name));
+    const ROLE_TOOLS = profile.chief
+        ? VOICE_READY_TOOLS
+        : VOICE_READY_TOOLS.filter((tool) => !CHIEF_ONLY_TOOL_NAMES.has(tool.name)).map((tool) => {
+            if (!CHIEF_TARGET_TOOL_NAMES.has(tool.name))
+                return tool;
+            const properties = Object.fromEntries(Object.entries(tool.inputSchema.properties).filter(([key]) => key !== "for_bot_id"));
+            return { ...tool, description: tool.description.replace(CHIEF_PROFILE_TARGET, ""), inputSchema: { ...tool.inputSchema, properties } };
+        });
     return profile.externalRuntime
         ? BOT_SCOPED_TOOLS.filter(tool => EXTERNAL_TOOL_NAMES.has(tool.name))
         : profile.coordinating
-            ? VOICE_READY_TOOLS.filter(tool => !ROOM_REPLACED_TOOLS.has(tool.name) || (tool.name === "start_thread" && profile.ownThreadCreation))
+            ? ROLE_TOOLS.filter(tool => !ROOM_REPLACED_TOOLS.has(tool.name) || (tool.name === "start_thread" && profile.ownThreadCreation))
                 .map(tool => tool.name === "start_thread" ? {
                 ...tool,
                 description: "Open a separate job on yourself with its own history and run, without switching the person's selected conversation. Use only when the user requests independent jobs (for example one review per pull request). Give a short specific title and complete instructions; you can open at most five per turn. This is not a teammate handoff: use coordinate_bots for teammates and their automatic replies. Self-opened jobs cannot recursively open more jobs. If refused, do not retry; explain what remains.",
@@ -889,5 +909,5 @@ function catalogTools(profile) {
                         bot_id: { type: "string", enum: [profile.botId], description: "Leave out, or use your own bot ID. For teammates use coordinate_bots." },
                     } },
             } : tool)
-            : VOICE_READY_TOOLS.filter(tool => !ROOM_ONLY_TOOLS.has(tool.name));
+            : ROLE_TOOLS.filter(tool => !ROOM_ONLY_TOOLS.has(tool.name));
 }

package/dist-server/server/drivers/agents-proxy.js

@@ -12,6 +12,7 @@
 //   OMB_COMMS_TOKEN  shared secret for the localhost-only internal endpoints
 //   OMB_TURN_DEPTH   this turn's comms depth (the harness refuses recursion)
 //   OMB_EXTERNAL_RUNTIME  "1" for a standing process: peer tools and polling only
+//   OMB_CHIEF_OF_STAFF    "1" for a Chief of Staff, the only bot shown the Chief-only tools
 //
 // This file is the stdio front end only. What the tools are and which a turn
 // sees: agents-catalog.ts. What a call does: agents-call.ts. How the harness

package/dist-server/server/drivers/builtIn.js

@@ -1,5 +1,4 @@
 import { AntigravityDriver } from "./antigravity.js";
-import { BoatAgentDriver } from "./boatagent.js";
 import { ClaudeDriver } from "./claude.js";
 import { CodexDriver } from "./codex.js";
 import { GrokDriver } from "./grok.js";
@@ -33,7 +32,6 @@ export const BUILT_IN_DRIVERS = [
     ClaudeDriver,
     CodexDriver,
     AntigravityDriver,
-    BoatAgentDriver,
     MinimaxDriver,
     MistralDriver,
     CerebrasDriver,

package/dist-server/server/drivers/chat-mcp-tools.js

@@ -14,7 +14,9 @@ import { allowsTool, canUseMcpServer, parseToolScope } from "../../shared/tool-s
 export class ChatToolSessionError extends Error {
 }
 const STARTUP_MS = 8_000;
-const CALL_MS = 10 * 60_000;
+/** Historic per-call ceiling for a bot's MCP tools; a turn can override it
+ * with SendTurnInput.mcpCallTimeoutMs (server config `mcp.callTimeoutMinutes`). */
+const DEFAULT_CALL_MS = 10 * 60_000;
 const FRAME_BYTES = 2 * 1024 * 1024;
 const OUTPUT_BYTES = 50 * 1024;
 const TOOL_COUNT = 128;
@@ -283,7 +285,7 @@ function omitBlankDefaults(builtInBrowser, tool, args) {
             delete args[field];
     }
 }
-export async function mountChatTools(integrations, signal, computerUse = false, toolScope) {
+export async function mountChatTools(integrations, signal, computerUse = false, toolScope, callTimeoutMs = DEFAULT_CALL_MS) {
     const parsed = parseToolScope(toolScope);
     if (!parsed.ok)
         throw new Error(parsed.error);
@@ -411,7 +413,7 @@ export async function mountChatTools(integrations, signal, computerUse = false,
             }
             const tool = registered.get(name);
             try {
-                const result = await tool.client.call("tools/call", { name: tool.name, arguments: args }, AbortSignal.any([signal, callSignal]), CALL_MS);
+                const result = await tool.client.call("tools/call", { name: tool.name, arguments: args }, AbortSignal.any([signal, callSignal]), callTimeoutMs);
                 if (signal.aborted || callSignal.aborted)
                     throw aborted();
                 if (!object(result) || !Array.isArray(result.content) || (result.isError !== undefined && typeof result.isError !== "boolean"))

package/dist-server/server/drivers/claude-login-auth.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import { killCliTree, spawnCli } from "../procs.js";
-import { canonicalPath } from "./codex-device-auth.js";
+import { canonicalPath } from "./device-auth.js";
 const MAX_OUTPUT = 32_768;
 /** Where Anthropic's sign-in lives. Anything else in the CLI's output is not a link we show. */
 const SIGN_IN_HOSTS = ["claude.com", "claude.ai", "console.anthropic.com", "platform.claude.com"];

package/dist-server/server/drivers/claude.js

@@ -15,7 +15,7 @@ import { createServer as createNetServer } from "node:net";
 import { homedir, tmpdir } from "node:os";
 import { join, dirname, isAbsolute, normalize } from "node:path";
 import { DATA_DIR, stripWorkspaceCredentialEnv } from "../config.js";
-import { writeFileAtomic } from "../atomic.js";
+import { writeFileAtomic, writeFileAtomicIfChanged } from "../atomic.js";
 import { augmentedPath } from "../env-path.js";
 import { brokerSocketPath, describeSpawnFailure, execCli, killCliTree, spawnCli } from "../procs.js";
 import { classifyResumeFailure, mayReplay, recoveryPromptFor } from "../resume-recovery.js";
@@ -599,6 +599,9 @@ export async function createPermissionBroker(opts) {
     let boundPath = opts.socketPaths[0] ?? "";
     const connectionHandler = (conn) => {
         conn.on("error", () => { });
+        // An ask carries the whole tool input (a Write's file content), so one
+        // line spans many reads. Decode as a stream so no character is split.
+        conn.setEncoding("utf8");
         let buf = "";
         conn.on("data", (chunk) => {
             buf += chunk;
@@ -932,8 +935,10 @@ function recordCostState(sessionId, state) {
     const ids = Object.keys(history);
     for (const id of ids.slice(0, Math.max(0, ids.length - COST_HISTORY_SESSIONS)))
         delete history[id];
+    // Written after every turn, so not fsynced: what a power cut could lose is
+    // the same thing a failed write already gives up (below).
     try {
-        writeFileAtomic(COST_HISTORY_FILE, JSON.stringify(history), { mode: 0o600 });
+        writeFileAtomic(COST_HISTORY_FILE, JSON.stringify(history), { mode: 0o600, durable: false });
     }
     catch {
         // a lost state only means a later resume keeps its whole figure
@@ -1051,6 +1056,26 @@ export const ClaudeDriver = {
         const readCliVersion = (env) => new Promise((resolve) => {
             execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout.trim() || null));
         });
+        // The --help read while it runs: snapshots that overlap (the server's
+        // read at start and the app's first one) share it.
+        let helpRead = null;
+        const readCliHelp = (version, env) => {
+            if (helpRead?.version === version)
+                return helpRead.done;
+            const read = {
+                version,
+                done: new Promise((resolve) => {
+                    execCli(config.cli, ["--help"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout));
+                }).then((help) => {
+                    cliHasAutocompact = help === null ? null : /^\s*--autocompact\b/m.test(help);
+                    cliHelpVersion = version;
+                    if (helpRead === read)
+                        helpRead = null;
+                }),
+            };
+            helpRead = read;
+            return read.done;
+        };
         const listeners = new Set();
         // one active turn per thread; a second send while busy is a caller bug
         const active = new Map();
@@ -1145,8 +1170,20 @@ export const ClaudeDriver = {
             // logical turn's stop handle in `active` while it sets up, so Stop is
             // never a silent no-op between two CLI processes of the same turn.
             const relaunch = logicalTurnId !== undefined;
-            if (active.has(threadId) && !relaunch)
-                throw new Error("a turn is already running on this thread");
+            if (!relaunch) {
+                // Stop is acknowledged at once and the process tree reaped after it
+                // (taskkill is asynchronous on Windows); the stopped turn leaves
+                // `active` only when its close is handled. A Stop that lands while
+                // a turn is still starting lets the harness send the next message
+                // before then. That turn waits for the stopped process to be gone,
+                // never overlapping its helpers, instead of being refused.
+                const stopped = sessions.get(threadId);
+                if (stopped?.turn?.stopRequested && active.get(threadId)?.turnId === stopped.turn.turnId &&
+                    await killCliTree(stopped.child))
+                    await stopped.closed;
+                if (active.has(threadId))
+                    throw new Error("a turn is already running on this thread");
+            }
             // A bot-level mode is authoritative for this turn. In particular, an
             // old provider instance may still be configured with
             // `bypassPermissions`; Ask/Auto must restore Claude's interactive
@@ -1399,14 +1436,18 @@ export const ClaudeDriver = {
                 ? readClaudeAuthSettings(env, input.environment) : {};
             // Harness hooks (item 0.2): one helper command for the events the
             // harness observes. The helper reads its bearer from a per-thread file
-            // the harness rewrites every turn, so a long-lived CLI process never
+            // the harness refreshes every turn, so a long-lived CLI process never
             // presents a stale token. Registered through the same private
             // --settings file as the auth override; both are 0600 and per launch.
             const hooks = turn.integrations?.hooks;
             const hookTokenPath = hooks ? hookTokenFile(threadId, botId) : null;
             if (hooks && hookTokenPath) {
                 mkdirSync(dirname(hookTokenPath), { recursive: true, mode: 0o700 });
-                writeFileAtomic(hookTokenPath, hooks.token, { mode: 0o600 });
+                // The bearer is usually the same as last turn, and it only lives in
+                // this process's memory, so a restart invalidates the file anyway:
+                // skip identical bytes and the fsync. A rotated bearer differs from
+                // what is on disk, so it is always written before the CLI launches.
+                writeFileAtomicIfChanged(hookTokenPath, hooks.token, { mode: 0o600, durable: false });
                 env.OMB_HOOK_URL = hooks.url;
                 env.OMB_HOOK_TOKEN_FILE = hookTokenPath;
                 env.OMB_HOOK_NODE = process.execPath;
@@ -1459,7 +1500,7 @@ export const ClaudeDriver = {
             if (!turn.sessionReset && live && !live.turn && !live.closing && live.child.exitCode === null && live.argsKey === argsKey && (!sessionId || sessionId === live.sessionId)) {
                 if (live.idleTimer)
                     clearTimeout(live.idleTimer);
-                live.turn = { turnId, input: turn, retryAbort, settled: false, sawStreamDelta: false, pendingSteers: new Set(), deferred: null, continuationGrace: null, continuationSilence: null };
+                live.turn = { turnId, input: turn, retryAbort, settled: false, sawStreamDelta: false, awaitingInit: true, pendingSteers: new Set(), deferred: null, continuationGrace: null, continuationSilence: null };
                 active.set(threadId, { stop: () => {
                         if (live.turn)
                             live.turn.stopRequested = true;
@@ -1475,20 +1516,13 @@ export const ClaudeDriver = {
                     : claudeUserMessage(withVolatileNote(turn.text, volatile), turn.images);
                 live.volatile = volatile;
                 const running = live.turn;
-                const written = await writeUser(live, threadId, message);
-                if (!written && !running?.stopRequested) {
-                    active.delete(threadId);
-                    live.turn = null;
+                // A warm process can end between turns just as the next one is
+                // written: this driver learns of an exit only when the event loop
+                // gets to it (later still on Windows), so the check above can find it
+                // live and the write then fail. Nothing was submitted; its close
+                // resumes this same turn on a fresh process (see `awaitingInit`).
+                if (!(await writeUser(live, threadId, message)) && !running?.stopRequested)
                     closeSession(threadId, "stdin write failed");
-                    retryState.delete(threadId);
-                    if (mcpConfigPath) {
-                        try {
-                            rmSync(dirname(mcpConfigPath), { recursive: true, force: true });
-                        }
-                        catch { }
-                    }
-                    throw new Error("claude session stdin is not writable");
-                }
                 // the MCP config was for the first spawn; nothing to clean here
                 if (mcpConfigPath) {
                     try {
@@ -1630,7 +1664,9 @@ export const ClaudeDriver = {
                 cleanupUnownedLaunch();
                 throw error;
             }
+            let markClosed;
             const session = {
+                closed: new Promise((resolve) => { markClosed = resolve; }),
                 child,
                 broker,
                 mcpConfigPath,
@@ -1749,6 +1785,8 @@ export const ClaudeDriver = {
                                 break;
                             }
                             session.sawInit = true;
+                            if (session.turn)
+                                session.turn.awaitingInit = false;
                             session.nativePermissionMode = typeof o.permissionMode === "string" ? o.permissionMode : null;
                             if (typeof o.session_id === "string")
                                 session.sessionId = o.session_id;
@@ -2051,11 +2089,18 @@ export const ClaudeDriver = {
                     const retry = retryState.get(threadId) ?? { attempt: 0, cancelled: false };
                     const message = `claude exited ${code} before result${session.stderr ? `: ${session.stderr.trim().slice(-300)}` : ""}`;
                     const verdict = classifyError({ exitCode: code, stderr: message });
+                    // A process kept warm from an earlier turn ended before it
+                    // announced this one: it never took the prompt. That is a session
+                    // ending between turns, not a failed turn, so the same turn
+                    // resumes the session on a fresh process at once — no retry row,
+                    // no retry budget spent. (A fresh process is never retained, so
+                    // this happens at most once per turn.)
+                    const endedBeforeTurn = session.turn.awaitingInit === true;
                     if (!retry.cancelled &&
-                        code !== 0 &&
-                        verdict.transient &&
-                        !session.turn.sawStreamDelta &&
-                        retry.attempt < RETRY_MAX_ATTEMPTS - 1) {
+                        (endedBeforeTurn || (code !== 0 &&
+                            verdict.transient &&
+                            !session.turn.sawStreamDelta &&
+                            retry.attempt < RETRY_MAX_ATTEMPTS - 1))) {
                         // the CLI is gone but the TURN continues: keep the thread busy,
                         // emit no terminal event, and relaunch after the backoff. The
                         // `active` entry STAYS — it is what makes an interrupt during
@@ -2077,15 +2122,18 @@ export const ClaudeDriver = {
                         }
                         sessions.delete(threadId);
                         session.turn = null;
-                        retry.attempt++;
-                        const delayMs = computeBackoff(retry.attempt - 1);
-                        emit({
-                            ...base(threadId, turnId),
-                            type: "turn.retrying",
-                            attempt: retry.attempt,
-                            delayMs,
-                            reason: verdict.reason,
-                        });
+                        let delayMs = 0;
+                        if (!endedBeforeTurn) {
+                            retry.attempt++;
+                            delayMs = computeBackoff(retry.attempt - 1);
+                            emit({
+                                ...base(threadId, turnId),
+                                type: "turn.retrying",
+                                attempt: retry.attempt,
+                                delayMs,
+                                reason: verdict.reason,
+                            });
+                        }
                         void (async () => {
                             const wait = interruptibleDelay(delayMs * retryScale, retryAbort.signal);
                             await wait.promise;
@@ -2225,7 +2273,7 @@ export const ClaudeDriver = {
             };
             child.on("close", (code) => {
                 session.finishClose = () => finalizeClose(code);
-                void session.finishClose();
+                void session.finishClose().finally(markClosed);
             });
             const stop = () => {
                 if (session.turn)
@@ -2284,13 +2332,8 @@ export const ClaudeDriver = {
                 return { state: "unavailable", reason: `\`${config.cli}\` CLI not found` };
             cliVersion = parseClaudeCliVersion(version);
             cliVersionChecked = true;
-            if (version !== cliHelpVersion) {
-                const help = await new Promise((resolve) => {
-                    execCli(config.cli, ["--help"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout));
-                });
-                cliHasAutocompact = help === null ? null : /^\s*--autocompact\b/m.test(help);
-                cliHelpVersion = version;
-            }
+            if (version !== cliHelpVersion)
+                await readCliHelp(version, env);
             const update = claudeCliUpdate(version, config.cli);
             const warning = claudeInheritWarning(env);
             if (config.requireApiKey) {