openmausbot 0.1.95 → 0.1.97

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-device-auth.js

@@ -9,7 +9,9 @@ const MAX_OUTPUT = 16_384;
 // Two configured instances can use the same on-disk login. Only the auth
 // operation is exclusive: normal turns are not blocked by this lock.
 const authenticatingHomes = new Set();
-function canonicalPath(path) {
+/** The real path of a credential home, so two spellings of one home share
+ * one sign-in lock. A missing tail keeps its name under its real parent. */
+export function canonicalPath(path) {
     try {
         return realpathSync(path);
     }

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

@@ -1567,10 +1567,11 @@ export const CodexDriver = {
                     // Only the stable half of the prompt belongs in the developer slot:
                     // it is the part that must survive compaction unchanged, and any
                     // change to it invalidates the provider's cached prefix. The volatile
-                    // half (memory, mentions, outstanding teammate work) is delivered
-                    // inside the turn that changed it, after the cached prefix, the same
-                    // contract SendTurnInput.systemStable documents. Without the split
-                    // the driver keeps the previous single-block behaviour.
+                    // half (the sections in VOLATILE_SECTIONS, system-prompt.ts) is
+                    // delivered inside the turn that changed it, after the cached
+                    // prefix, the same contract SendTurnInput.systemStable documents.
+                    // Without the split the driver keeps the previous single-block
+                    // behaviour.
                     const stableInstructions = typeof turn.systemStable === "string" && typeof turn.systemVolatile === "string"
                         ? turn.systemStable
                         : null;
@@ -1710,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 } : {}),
                         });
                     };

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

@@ -45,7 +45,7 @@ export const GrokDriver = {
             generateModel: () => "grok-3-mini",
             nativeLog: {
                 source: "xai.chat.completions",
-                outgoing: (_turn, messages, model) => ({ model, messages }),
+                outgoing: (_turn, messages, model) => ({ model, messageCount: messages.length }),
                 incoming: ({ text, usage }) => ({ text, usage }),
             },
         });

package/dist-server/server/drivers/openai-chat-protocol.js

@@ -1,4 +1,6 @@
-export const MAX_CHAT_TOOL_CALLS = 32;
+/** Calls one model reply may carry (its index bound). The turn's own total is
+ * MAX_TURN_TOOL_CALLS in openai-chat.ts. */
+const MAX_REPLY_TOOL_CALLS = 32;
 const MAX_ARGUMENT_CHARS = 256_000;
 export class ChatProtocolError extends Error {
 }
@@ -36,7 +38,7 @@ export class ChatToolCalls {
         for (const [position, raw] of value.entries()) {
             const delta = object(raw);
             const index = streaming ? delta?.index : position;
-            if (!delta || !Number.isInteger(index) || Number(index) < 0 || Number(index) >= MAX_CHAT_TOOL_CALLS) {
+            if (!delta || !Number.isInteger(index) || Number(index) < 0 || Number(index) >= MAX_REPLY_TOOL_CALLS) {
                 throw new ChatProtocolError("provider returned an invalid tool-call index");
             }
             const call = this.calls.get(Number(index)) ?? { id: "", type: "function", function: { name: "", arguments: "" } };

package/dist-server/server/drivers/openai-chat.js

@@ -7,9 +7,10 @@ import { ChatToolSessionError, mountChatTools } from "./chat-mcp-tools.js";
 import { assertImageTransport, chatImageBudget, chatToolImages, chatUserContent } from "./chat-images.js";
 import { promptHalves, volatileContextNote, withContextNote } from "./prompt-split.js";
 import { createChatToolApproval } from "./chat-tool-approval.js";
-import { ChatProtocolError, ChatReasoningDetails, ChatToolCalls, MAX_CHAT_TOOL_CALLS, object } from "./openai-chat-protocol.js";
+import { ChatProtocolError, ChatReasoningDetails, ChatToolCalls, object } from "./openai-chat-protocol.js";
 import { appendNative } from "./native.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
+import { classifyContinuable, writeTurnHandoff } from "../turn-continuation.js";
 /** The message of a JSON error body a provider returned with HTTP 200.
  *  MiniMax reports auth, balance, and parameter failures as `base_resp`. */
 function providerError(json) {
@@ -31,6 +32,15 @@ const usageFrom = (usage) => usage
 const asError = (value) => value instanceof Error ? value : new Error(String(value));
 class UnsupportedChatToolsError extends Error {
 }
+/** One turn's safety stops: model steps, and tool calls across all of them.
+ * Tool-heavy models (a memory server, a browser) take dozens of steps, and
+ * a stopped turn cannot simply be continued — the next turn is rebuilt from
+ * the text transcript, which holds none of these tool results. The calls
+ * that ran have taken effect, so the stop asks only for what is left: a
+ * retry of the whole task would repeat them. */
+const MAX_CHAT_ROUNDS = 64;
+const MAX_TURN_TOOL_CALLS = 200;
+const stoppedAfter = (count) => `Stopped after ${count} without a final answer. The steps so far already ran, so ask only for what's left.`;
 const NUDGE_ANNOUNCED_ACTION = "You said what you would do next but called no tool. Do it now with your tools, or reply with your final answer if nothing is left to do.";
 /** A short reply that only announces a next step, with nothing to answer. */
 export function announcesAction(text) {
@@ -78,6 +88,53 @@ function rejectsReasoningReplay(status, body) {
     return typeof message === "string" && /\breasoning_content\b/.test(message) &&
         /\b(?:unsupported|not supported|unknown|unrecognized|unexpected|not permitted|not allowed)\b/i.test(message);
 }
+/** Groq checks each generated tool call against the request and fails the
+ *  completion with `tool_use_failed` when the call is invalid: most often a
+ *  tool it was not offered (gpt-oss inventing a "json" tool to answer in
+ *  JSON), sometimes arguments that miss the schema. `refusal` is the
+ *  provider's whole error object, `failed_generation` included. */
+class RejectedToolCallError extends ChatProtocolError {
+    refusal;
+    constructor(message, refusal) {
+        super(message);
+        this.refusal = refusal;
+    }
+}
+const toolCallRefusal = (error) => {
+    const body = object(error);
+    return body?.code === "tool_use_failed" ? body : undefined;
+};
+function refusedToolCall(status, body) {
+    if (status !== 400)
+        return undefined;
+    try {
+        return toolCallRefusal(object(JSON.parse(body))?.error);
+    }
+    catch {
+        return undefined;
+    }
+}
+function completionError(json, label) {
+    const message = providerError(json);
+    if (!message)
+        return null;
+    const text = `provider returned a ${label}: ${message.slice(0, 200)}`;
+    const refusal = toolCallRefusal(json.error);
+    return refusal ? new RejectedToolCallError(text, refusal) : new ChatProtocolError(text);
+}
+/** What a failed turn says once the provider refused every attempt: what
+ *  happened, the next step, then the provider's words. The refused call ran
+ *  nothing, but tool calls from earlier steps of the turn did, and a Retry
+ *  of the whole request would repeat them. */
+function refusedToolCallFailure(error, earlierSteps) {
+    const words = typeof error.refusal.message === "string" ? error.refusal.message : error.message;
+    const tool = /attempted to call tool '([^']+)'/.exec(words)?.[1];
+    const what = tool ? `tried to use a tool it was not given ("${tool}")` : "made a tool call the provider rejected";
+    const next = earlierSteps
+        ? "The steps before it already ran, so ask only for what's left."
+        : "Nothing ran. Retry; if it keeps happening, rephrase the request or choose another model.";
+    return `The model ${what}. ${next} Provider: ${words.slice(0, 200)}`;
+}
 /** Shared runtime for the three providers that speak OpenAI chat completions. */
 export function createOpenAIChatRuntime(options) {
     const { input } = options;
@@ -128,6 +185,9 @@ export function createOpenAIChatRuntime(options) {
                 const message = `${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`;
                 if (rejectsToolsParameter(response.status, body))
                     throw new UnsupportedChatToolsError(message);
+                const refusal = refusedToolCall(response.status, body);
+                if (refusal)
+                    throw new RejectedToolCallError(message, refusal);
                 if (messages.some((entry) => entry.reasoning_content !== undefined) && rejectsReasoningReplay(response.status, body)) {
                     throw new UnsupportedReasoningReplayError(message);
                 }
@@ -146,9 +206,9 @@ export function createOpenAIChatRuntime(options) {
                         costUsd: count(json.usage?.cost),
                     });
                 }
-                const bodyError = providerError(json);
+                const bodyError = completionError(json, "completion error");
                 if (bodyError)
-                    throw new ChatProtocolError(`provider returned a completion error: ${bodyError.slice(0, 200)}`);
+                    throw bodyError;
                 const message = json.choices?.[0]?.message;
                 if (!message || !object(message) || !["content", "reasoning_content", "reasoning", "reasoning_details", "tool_calls", "function_call"].some((key) => key in message)) {
                     throw new ChatProtocolError("provider returned no completion message");
@@ -210,9 +270,9 @@ export function createOpenAIChatRuntime(options) {
                         malformedFrame = true;
                     return false;
                 }
-                const chunkError = providerError(chunk);
+                const chunkError = completionError(chunk, "streaming completion error");
                 if (chunkError)
-                    throw new ChatProtocolError(`provider returned a streaming completion error: ${chunkError.slice(0, 200)}`);
+                    throw chunkError;
                 const choice = chunk.choices?.find((row) => row.index === undefined || row.index === 0);
                 const delta = choice?.delta;
                 if (object(delta))
@@ -262,9 +322,9 @@ export function createOpenAIChatRuntime(options) {
                             catch {
                                 body = undefined;
                             }
-                            const bodyError = body ? providerError(body) : null;
+                            const bodyError = body ? completionError(body, "completion error") : null;
                             if (bodyError)
-                                throw new ChatProtocolError(`provider returned a completion error: ${bodyError.slice(0, 200)}`);
+                                throw bodyError;
                         }
                         throw new ChatProtocolError("Stream ended before completion");
                     }
@@ -413,7 +473,7 @@ export function createOpenAIChatRuntime(options) {
                 if (questionAllowed && !tools.definitions.some((definition) => definition.function.name === ASK_USER_TOOL)) {
                     tools.definitions.push(ASK_USER_TOOL_DEFINITION);
                 }
-                for (let round = 0; round < 16; round++) {
+                for (let round = 0; round < MAX_CHAT_ROUNDS; round++) {
                     abort.signal.throwIfAborted();
                     // Drain parked mid-turn input here, before the next completion
                     // request: the previous round's tool results are complete, so a
@@ -427,6 +487,7 @@ export function createOpenAIChatRuntime(options) {
                     let completion;
                     for (;;) {
                         let streamed = false;
+                        let answerStreamed = false;
                         const pending = { assistant_text: "", reasoning_text: "" };
                         const delta = (text, streamKind, flush = false) => {
                             let combined = pending[streamKind] + text;
@@ -455,6 +516,8 @@ export function createOpenAIChatRuntime(options) {
                         try {
                             completion = await complete(messages, model, true, abort.signal, (text, streamKind) => {
                                 streamed = true;
+                                if (streamKind === "assistant_text")
+                                    answerStreamed = true;
                                 delta(text, streamKind);
                             }, tools.definitions);
                             delta("", "assistant_text", true);
@@ -474,6 +537,20 @@ export function createOpenAIChatRuntime(options) {
                                     delete message.reasoning_content;
                                 continue;
                             }
+                            // A refused tool call ran nothing, so the same request goes
+                            // again; the model usually answers properly next time. Not once
+                            // answer text streamed: the phones' live bubble would join it to
+                            // the next attempt's. Streamed thinking stays thinking. Each
+                            // refusal, failed_generation included, goes to the native log.
+                            if (error instanceof RejectedToolCallError) {
+                                native("in", { refused: "tool_use_failed", attempt: attempt + 1, error: error.refusal });
+                                if (!answerStreamed && !abort.signal.aborted && attempt < RETRY_MAX_ATTEMPTS - 1) {
+                                    emit({ ...base(turn.threadId, turnId), type: "turn.retrying", attempt: ++attempt, delayMs: 0, reason: "tool_use_failed" });
+                                    continue;
+                                }
+                                if (!abort.signal.aborted)
+                                    throw new ChatProtocolError(refusedToolCallFailure(error, seenCalls.size > 0));
+                            }
                             // Only our optional question changed a previously plain request.
                             // A structured parameter rejection has executed nothing; never
                             // downgrade mounted tools, streamed output or a handled call.
@@ -517,6 +594,9 @@ export function createOpenAIChatRuntime(options) {
                             continue;
                         }
                         if (toolFailed) {
+                            // A failed or denied tool op ends the turn: the final answer is
+                            // not an execution receipt, and a person's "no" must never be
+                            // answered with a prompt to run the same thing again.
                             stopReason = "tool_error";
                             throw new ChatProtocolError("One or more tool operations failed or were denied. See the tool results; the final response is not an execution receipt.");
                         }
@@ -531,8 +611,9 @@ export function createOpenAIChatRuntime(options) {
                             throw new ChatProtocolError("provider reused a tool-call ID; refusing to repeat an operation");
                         seenCalls.add(call.id);
                     }
-                    if (seenCalls.size > MAX_CHAT_TOOL_CALLS)
-                        throw new ChatProtocolError("tool-call limit reached");
+                    // The whole batch is refused before any of it runs.
+                    if (seenCalls.size > MAX_TURN_TOOL_CALLS)
+                        throw new ChatProtocolError(stoppedAfter(`${MAX_TURN_TOOL_CALLS} tool calls`));
                     messages.push({ role: "assistant", content: completion.text || null, tool_calls: completion.toolCalls,
                         ...(completion.protocolReasoning && !reasoningReplayRejected.has(model) ? { [options.reasoningReplayField ?? "reasoning_content"]: completion.protocolReasoning } : {}),
                         ...(completion.protocolReasoningDetails.length ? { reasoning_details: completion.protocolReasoningDetails } : {}),
@@ -645,7 +726,7 @@ export function createOpenAIChatRuntime(options) {
                         messages.push({ role: "user", content: screenshotParts });
                 }
                 if (!ok)
-                    throw new ChatProtocolError("model-call limit reached before a final response");
+                    throw new ChatProtocolError(stoppedAfter(`${MAX_CHAT_ROUNDS} steps`));
             }
             catch (value) {
                 stopReason = abort.signal.aborted ? "interrupted" : stopReason ?? "error";
@@ -670,6 +751,27 @@ export function createOpenAIChatRuntime(options) {
                 if (failure && (!abort.signal.aborted || cleanupFailed)) {
                     emit({ ...base(turn.threadId, turnId), type: "runtime.error", message: failure, terminal: !abort.signal.aborted });
                 }
+                // Automatic continuity: a resumable terminal (budget cap or tool
+                // errors) persists a handoff and raises cap.exhausted so the harness
+                // can start a `Continue:` thread. Interruptions and provider config
+                // errors are excluded by classifyContinuable.
+                if (!ok && !abort.signal.aborted) {
+                    const continuable = classifyContinuable(stopReason, failure);
+                    if (continuable) {
+                        const handoffPath = writeTurnHandoff({
+                            threadId: turn.threadId,
+                            turnId,
+                            model,
+                            usage,
+                            hasUsage,
+                            failure,
+                            toolCalls: seenCalls.size,
+                            messages,
+                        });
+                        if (handoffPath)
+                            emit({ ...base(turn.threadId, turnId), type: "cap.exhausted", handoffPath, reason: continuable });
+                    }
+                }
                 active.delete(turn.threadId);
                 emit({ ...base(turn.threadId, turnId), type: "turn.completed", ok, stopReason, cost: null,
                     ...(hasUsage && (options.includeUsageInCompleted || seenCalls.size) ? { usage } : {}),