openmausbot 0.1.96 → 0.1.97

package/dist-server/server/computer-selection.js

@@ -0,0 +1,18 @@
+/** The option a request picks, and whether it is the computer this turn
+ * already has. `current` is the turn's mounted place. `startsOnFirstCall`
+ * says that place's computer is the one this turn's first computer call
+ * creates or wakes (the bot's own cloud computer): it is this turn's before
+ * it is up, so asking for it, or for Auto, keeps it instead of restarting
+ * the request somewhere else. */
+export function pickComputer(options, requested, current, startsOnFirstCall) {
+    const isCurrent = (option) => option.surface === current && (option.ready || (startsOnFirstCall && option.available));
+    const option = requested === "auto"
+        ? options.find(isCurrent)
+            ?? options.find((candidate) => candidate.ready && candidate.surface === "vm")
+            ?? options.find((candidate) => candidate.ready)
+            ?? options.find((candidate) => candidate.canStart)
+            ?? options.find((candidate) => candidate.canCreate && candidate.surface === "vm")
+            ?? options.find((candidate) => candidate.canCreate)
+        : options.find((candidate) => candidate.surface === requested);
+    return { option, current: option !== undefined && isCurrent(option) };
+}

package/dist-server/server/config.js

@@ -7,6 +7,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { normalizeImageGenerationUrl } from "../shared/image-generation.js";
 import { writeFileAtomic } from "./atomic.js";
+import { withoutComputerEngine } from "./computer-engine-removal.js";
 import { newBotDefaultsSchema } from "./new-bot-defaults.js";
 import { EFFORT_LEVELS } from "../shared/wire.js";
 import { isModelVariant } from "./contracts.js";
@@ -1443,10 +1444,10 @@ export function instanceOwnsRouting(cfg, entry, routingDefaults) {
 }
 /** The credential env instanceConfigs() injects for one driver at runtime.
  * Each secret goes only to the driver that actually reads it: the API-key
- * Grok driver reads XAI_API_KEY, the Computer driver reads BOX_TOKEN, and
- * OpenCode reads OPENCODE_API_KEY. Every other engine brings its own
- * login, so handing it a key it never uses would only put that key in the
- * environment of an unrelated child process. */
+ * Grok driver reads XAI_API_KEY and OpenCode reads OPENCODE_API_KEY. Every
+ * other engine brings its own login, so handing it a key it never uses would
+ * only put that key in the environment of an unrelated child process. The
+ * Boat token reaches no engine at all: the harness alone talks to Boat. */
 function injectedEnvironment(cfg, instanceId, driver) {
     const environment = new Map();
     if (driver === "mistral" && cfg.mistral?.key)
@@ -1485,11 +1486,6 @@ function injectedEnvironment(cfg, instanceId, driver) {
         if (driver === "openai-compat" && cfg.openaiCompat?.url)
             environment.set("OPENAI_COMPAT_URL", cfg.openaiCompat.url);
     }
-    // driverKind "boxAgent" and env BOX_TOKEN keep their historical names.
-    // Only the person's own token: without one the driver itself falls back
-    // to Cloud Pro's included token, which never enters an environment map.
-    if (driver === "boxAgent" && cfg.box?.token)
-        environment.set("BOX_TOKEN", cfg.box.token);
     if (driver === "opencodeGo") {
         // Keys for OpenCode's other providers, under the names OpenCode reads.
         for (const [name, key] of Object.entries(openCodeProviderKeys(cfg)))
@@ -1551,7 +1547,6 @@ export function instanceConfigs(cfg) {
         chatgpt: { driver: "codex", displayName: "ChatGPT plan", config: { authMode: "chatgpt-plan" } },
         antigravity: { driver: "antigravityAgent" },
         opencodeGo: { driver: "opencodeGo" },
-        computer: { driver: "boxAgent" },
         openaiCompat: { driver: "openai-compat" },
         mistral: { driver: "mistral" },
         cerebras: { driver: "cerebras" },
@@ -1578,7 +1573,8 @@ export function instanceConfigs(cfg) {
         ...CUSTOM_ONLY,
     };
     const configured = cfg.instances && Object.keys(cfg.instances).length ? cfg.instances : null;
-    const map = configured ? { ...configured } : { ...DEFAULT_FLEET };
+    // A fleet saved before the Computer engine was removed may still name it.
+    const map = withoutComputerEngine(configured ? { ...configured } : { ...DEFAULT_FLEET });
     // Product fleets pick up newly shipped engines. A one-off test/shadow map
     // (no claude/grok/codex) is left exactly as written.
     if (configured &&

package/dist-server/server/connector-scope-hint.js

@@ -0,0 +1,83 @@
+// A connected-app call refused for a missing OAuth permission (MOCA-273).
+//
+// Google answers 403 ACCESS_TOKEN_SCOPE_INSUFFICIENT when the account's grant
+// lacks a scope the action needs, such as gmail.settings.basic for a filter.
+// Composio's default auth config for a toolkit never asks for that scope, so
+// reconnecting cannot fix it and a bot that only sees the 403 retries or
+// asks the person to reconnect. The fix is the person's own auth config in
+// their Composio project, which OpenMausBot already prefers
+// (listCustomAuthConfigs). This appends that explanation to the tool result,
+// leaving the provider's own error untouched.
+const SCOPE_ERROR = /ACCESS_TOKEN_SCOPE_INSUFFICIENT|insufficient authentication scopes|insufficientPermissions/i;
+/** The Google scope a known tool needs, when the tool name says which. */
+function requiredScope(slug) {
+    if (!slug.startsWith("GMAIL_"))
+        return null;
+    if (/FORWARD|SEND_AS|DELEGATE/.test(slug))
+        return "https://www.googleapis.com/auth/gmail.settings.sharing";
+    if (/FILTER|VACATION|AUTO_REPLY|IMAP|POP|LANGUAGE/.test(slug))
+        return "https://www.googleapis.com/auth/gmail.settings.basic";
+    return null;
+}
+function appName(slug) {
+    const toolkit = slug.split("_")[0] ?? "";
+    if (toolkit === "GMAIL")
+        return "Gmail";
+    if (toolkit.startsWith("GOOGLE"))
+        return "Google";
+    return toolkit.charAt(0) + toolkit.slice(1).toLowerCase();
+}
+/** The note a bot reads after its call was refused for a missing permission. */
+export function scopeHint(slugs) {
+    const slug = slugs.find((candidate) => requiredScope(candidate)) ?? slugs[0] ?? "";
+    const app = slug ? appName(slug) : "This app";
+    const scope = slug ? requiredScope(slug) : null;
+    const permission = scope ? `the ${scope} permission` : "the permission this action needs";
+    return `OpenMausBot note: ${app} refused this because the connected account has not granted ${permission}. ` +
+        `Reconnecting will not add it: the default Composio connection never asks for it. ` +
+        `To allow it, the person creates their own ${app} auth config in their Composio project that includes ${permission}, ` +
+        `then reconnects ${app} under Connected apps; OpenMausBot uses that config automatically. ` +
+        `Tell the person this. Do not retry this call.`;
+}
+/** Adds the note to one JSON-RPC frame whose tool result is a scope refusal. */
+function annotateFrame(frame, slugs) {
+    const result = frame?.result;
+    if (!result || !Array.isArray(result.content))
+        return false;
+    const refused = result.content.some((item) => item && typeof item === "object" && typeof item.text === "string" &&
+        SCOPE_ERROR.test(item.text));
+    if (!refused)
+        return false;
+    result.content.push({ type: "text", text: scopeHint(slugs) });
+    return true;
+}
+/**
+ * The relayed MCP response, with the note added when a tool call came back
+ * refused for a missing OAuth permission. Anything else, including a body it
+ * cannot read, is returned byte for byte.
+ */
+export function withScopeHint(bytes, contentType, slugs) {
+    const text = new TextDecoder().decode(bytes);
+    if (!SCOPE_ERROR.test(text))
+        return bytes;
+    try {
+        if (/text\/event-stream/i.test(contentType)) {
+            let changed = false;
+            const lines = text.split("\n").map((line) => {
+                if (!line.startsWith("data:"))
+                    return line;
+                const frame = JSON.parse(line.slice(5));
+                if (!annotateFrame(frame, slugs))
+                    return line;
+                changed = true;
+                return `data: ${JSON.stringify(frame)}`;
+            });
+            return changed ? new TextEncoder().encode(lines.join("\n")) : bytes;
+        }
+        const frame = JSON.parse(text);
+        return annotateFrame(frame, slugs) ? new TextEncoder().encode(JSON.stringify(frame)) : bytes;
+    }
+    catch {
+        return bytes;
+    }
+}

package/dist-server/server/default-model-selection.js

@@ -1,6 +1,19 @@
 const claudeFirst = (instances) => instances.find((instance) => instance.driverKind === "claudeAgent") ?? instances[0];
-/** A saved choice is intentional: an unavailable provider or removed model
- * sends new bots to setup instead of silently changing their provider. */
+/** The ready rule: an engine can run a turn now when it is available, the
+ * organisation allows it, and it is not signed out. A custom endpoint brings
+ * its own credential, so its sign-in state does not count. */
+export function readyToRun(instance, context = {}) {
+    return instance.snapshot.state === "available" && context.refusal?.(instance) === undefined &&
+        (instance.access === "custom" || instance.snapshot.authenticated !== false);
+}
+/** The engine a new bot gets, and the one a bot moved off a removed engine
+ * gets (computer-engine-removal.ts): one picker for both.
+ *
+ * A saved choice is intentional: an unavailable provider or removed model
+ * sends new bots to setup instead of silently changing their provider.
+ * Without one, an engine that can run a turn now wins (Claude first), then the
+ * first available one. On an enrolled desktop a working personal engine
+ * still beats a Company one, so billing stays the person's explicit choice. */
 export function selectDefaultModelSelection(instances, preferred, context = {}) {
     if (preferred) {
         const instance = instances.find((candidate) => candidate.instanceId === preferred.instanceId);
@@ -22,19 +35,12 @@ export function selectDefaultModelSelection(instances, preferred, context = {})
     }
     // The organisation's policy is inert (no refusal) unless this desktop is enrolled.
     const available = instances.filter((instance) => instance.snapshot.state === "available" && context.refusal?.(instance) === undefined);
+    const ready = available.filter((instance) => readyToRun(instance, context));
     const company = context.company;
-    let pick;
-    if (company && instances.some((instance) => company(instance.instanceId))) {
-        // Enrolled: an installed but signed-out personal Claude would send every
-        // new bot to setup although a Company model can run. Prefer instances that
-        // can run a turn now; a working personal engine still wins, so billing
-        // stays the person's explicit choice.
-        const ready = available.filter((instance) => instance.access === "custom" || instance.snapshot.authenticated !== false);
-        pick = claudeFirst(ready.filter((instance) => !company(instance.instanceId))) ?? claudeFirst(ready) ?? claudeFirst(available);
-    }
-    else {
-        pick = claudeFirst(available);
-    }
+    const personal = company && instances.some((instance) => company(instance.instanceId))
+        ? claudeFirst(ready.filter((instance) => !company(instance.instanceId)))
+        : undefined;
+    const pick = personal ?? claudeFirst(ready) ?? claudeFirst(available);
     return { instanceId: pick?.instanceId ?? "", model: pick?.models.default ?? "" };
 }
 /** Complete a new bot's selection with the workspace's new-bot effort. An

package/dist-server/server/delegations.js

@@ -195,6 +195,8 @@ export function _loadPending() {
                 }
                 if (item.oneWay === true)
                     loaded.oneWay = true;
+                if (item.completionOwner === "external")
+                    loaded.completionOwner = "external";
                 return [loaded];
             });
             if (items.length)
@@ -401,7 +403,7 @@ onSettled) {
                 if (outcome === "settled" && stillQueued) {
                     const receipt = findDelegationReceipt(item.id);
                     try {
-                        if (receipt && !item.oneWay)
+                        if (receipt && wakesSource(item))
                             onSettled?.(receipt);
                     }
                     catch (error) {
@@ -445,6 +447,10 @@ function appendDeliveryMessage(bus, sourceThreadId, item, message) {
         return;
     bus.store.appendMessage(threadId, message);
 }
+/** A settled handoff resumes the bot that queued it, unless its outcome
+ * belongs elsewhere: to a one-way send's recipient, or to an external
+ * runtime that polls for the receipt. */
+const wakesSource = (item) => !item.oneWay && item.completionOwner !== "external";
 const isExpired = (item, now) => now - item.queuedAt >= DELEGATION_TTL_MS;
 /** Past the busy-hold cap — the tighter bound that fires while its target is
  * still busy, long before the 24-hour window. */
@@ -528,15 +534,15 @@ export function expireStaleDelegations(bus, now, onSettled) {
             expireDelegation(bus, threadId, item, ownerId ?? item.sourceBotId);
             const receipt = findDelegationReceipt(item.id);
             if (receipt)
-                expired.push({ receipt, oneWay: item.oneWay === true });
+                expired.push({ receipt, wake: wakesSource(item) });
         }
     }
     if (!expired.length)
         return 0;
     savePending();
-    for (const { receipt, oneWay } of expired) {
+    for (const { receipt, wake } of expired) {
         try {
-            if (!oneWay)
+            if (wake)
                 onSettled?.(receipt);
         }
         catch (error) {
@@ -717,7 +723,7 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     const prefixed = item.targetThreadId
         ? item.message
         : `[Delegated by @${sender.name}, another bot in this OpenMausBot workspace. Do the work and reply directly.]\n\n${item.message}${reasonLine}`;
-    await runTarget(item.toBotId, prefixed, item.oneWay ? 0 : item.depth + 1, sourceThreadId, channel, item.id, sender.id, item.targetThreadId, item.oneWay === true);
+    await runTarget(item.toBotId, prefixed, item.oneWay ? 0 : item.depth + 1, sourceThreadId, channel, item.id, sender.id, item.targetThreadId, item.oneWay === true, item.completionOwner);
     return "dispatched";
 }
 /** "Is the target free to take this handoff right now?" Both shapes ask for

package/dist-server/server/delta-context.js

@@ -109,6 +109,7 @@ export function recordHanded(state, order, received) {
     return {
         ...(state.session === undefined ? {} : { session: state.session }),
         ...(state.config === undefined ? {} : { config: state.config }),
+        ...(state.effort === undefined ? {} : { effort: state.effort }),
         ...(state.omitted === undefined ? {} : { omitted: state.omitted }),
         ...(through === undefined ? {} : { through }),
         ids: sorted,
@@ -241,10 +242,14 @@ export class Handoffs {
             ? pending.resumeCursor === undefined ? pending.started : pending.recovery
             : existing === undefined ? pending.resumed : undefined;
         if (!start) {
+            if (typeof pending.effort === "string" && existing?.session === session && existing.effort !== pending.effort) {
+                this.store.write(pending.botId, threadId, pending.instanceId, { ...existing, effort: pending.effort });
+            }
             this.add(threadId, pending, [...pending.placed, ...pending.carried]);
             return;
         }
-        this.store.write(pending.botId, threadId, pending.instanceId, recordHanded({ session, config: pending.config, ...(start.omitted === undefined ? {} : { omitted: start.omitted }), ids: [] }, this.store.order(threadId), start.sent));
+        this.store.write(pending.botId, threadId, pending.instanceId, recordHanded({ session, config: pending.config, ...(pending.effort === undefined ? {} : { effort: pending.effort }),
+            ...(start.omitted === undefined ? {} : { omitted: start.omitted }), ids: [] }, this.store.order(threadId), start.sent));
     }
     add(threadId, pending, received) {
         const session = pending.session ?? pending.resumeCursor;

package/dist-server/server/drivers/acp/core.js

@@ -350,7 +350,7 @@ export function createAcpDriver(support) {
                 }
                 // The operator's own secrets are outside any driver's allowlist.
                 stripControlPlaneEnv(env);
-                support.transformEnv?.(env, activeConfig, instanceId);
+                support.transformEnv?.(env, activeConfig, instanceId, input.environment);
                 return env;
             };
             let models = support.models;

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

@@ -132,7 +132,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",
@@ -303,7 +303,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." },
             } },
     },
     {
@@ -854,7 +854,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) {

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/claude.js

@@ -1145,8 +1145,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
@@ -1459,7 +1471,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 +1487,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 +1635,9 @@ export const ClaudeDriver = {
                 cleanupUnownedLaunch();
                 throw error;
             }
+            let markClosed;
             const session = {
+                closed: new Promise((resolve) => { markClosed = resolve; }),
                 child,
                 broker,
                 mcpConfigPath,
@@ -1749,6 +1756,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 +2060,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 +2093,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 +2244,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)

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

@@ -1711,8 +1711,8 @@ export const CodexDriver = {
                             // back. The app-server offers no way to clear a level either:
                             // "" is rejected outright and thread/start takes no effort at
                             // all. So a thread keeps the last level it was sent until it is
-                            // sent another, and choosing Default lands on the bot's next new
-                            // thread rather than the current one.
+                            // sent another; back on Default, the harness gives a thread that
+                            // holds a level a new thread instead of resuming it (server/index.ts).
                             ...(turn.effort ? { effort: turn.effort } : {}),
                         });
                     };