openmausbot 0.1.87 → 0.1.89

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

@@ -1,6 +1,6 @@
 import { newEventId, newId } from "../contracts.js";
 import { appendNative } from "./native.js";
-import { OMB_ASK_TOOL, answerWithoutPreamble, askQuestionSummary, capAnswerEcho, parseOmbAskQuestions, questionChoices, stripOmbAskBlock, } from "../../shared/ask-question.js";
+import { OMB_ASK_TOOL, answerWithoutPreamble, askQuestionSummary, capAnswerEcho, ombAskProtocolPrompt, parseOmbAskQuestions, questionChoices, stripOmbAskBlock, } from "../../shared/ask-question.js";
 const DRIVER_KIND = "boxAgent";
 // overridable so tests and a dev backend can be pointed at instead of the live provider
 const BOX_API = process.env.OMB_BOX_API || "https://ascii.dev/api/box/v1";
@@ -12,20 +12,6 @@ const MODELS = {
         { id: "gpt-5.4", label: "GPT-5.4 (Codex) · on the box" },
     ],
 };
-/** The ask contract appended to every prompt. The box harness cannot pause
- * mid-run, so a question rides the run's final output as a fenced block and
- * OMB parses it at settle — the turn-held transport. */
-const ASK_PROTOCOL = [
-    "",
-    "## Asking the person a question",
-    "When a decision belongs to the person, end your reply with a fenced block exactly like this:",
-    "",
-    "```omb-ask",
-    '{"questions":[{"question":"Ship the release now?","header":"Release","options":[{"label":"Ship now"},{"label":"Wait for the QA signoff"}]}]}',
-    "```",
-    "",
-    "The block must be the last thing in your reply. You may ask up to 6 questions at once, each with up to 12 options; the person can always answer in their own words. Their answers arrive on your next prompt as `Q:`/`A:` lines — never invent them.",
-].join("\n");
 /** Any fence whose info string names the ask protocol, even when its body
  * does not parse: the marker for "the model tried to ask and failed". */
 const ASK_FENCE_ANY = /(^|\n)[ \t]{0,3}(`{3,}|~{3,})[ \t]*omb-ask\b/;
@@ -118,7 +104,7 @@ export const BoxAgentDriver = {
             const prompt = [
                 turn.system,
                 "You are working on the assigned cloud computer — use its desktop, Chrome, and shell within the access described above.",
-                ASK_PROTOCOL,
+                ombAskProtocolPrompt(),
                 ...(correction ? [correction] : []),
                 "",
                 turn.text,
@@ -388,7 +374,7 @@ export const BoxAgentDriver = {
             snapshot,
             adapter: {
                 provider: DRIVER_KIND,
-                capabilities: { sessionModelSwitch: "in-session" },
+                capabilities: { sessionModelSwitch: "in-session", remoteAgent: true, usesCloudComputer: true },
                 sendTurn,
                 interruptTurn: async (threadId) => active.get(threadId)?.cancel(),
                 respondToRequest: async (threadId, requestId, decision) => {

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

@@ -23,6 +23,8 @@ import { gateServer, resultBudget } from "../mcp-gate-config.js";
 import { newEventId, newId } from "../contracts.js";
 import { askInputSummary, commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
+import { sessionIdlePolicy } from "./session-idle.js";
+import { parseVersionTriple, versionAtLeast } from "./acp/core.js";
 import { applyClaudeInject, decodeInjectId, mergeLocalInject, probeLocalInjects, resolveInjectId, } from "./local-inject.js";
 import { appendNative } from "./native.js";
 import { permissionCommand, permissionLaunchCwd } from "./permission-command.js";
@@ -109,6 +111,17 @@ export function claudeAuthFailure(frame, text) {
         return false;
     return frame.error === "authentication_failed" || classifyError({ text }).reason === "auth";
 }
+/** A model newer than the installed Claude Code: the API refuses it and the
+ * CLI relays that as an api-error frame ("Claude Code 2.1.268 does not
+ * support this model; version 2.1.280 or newer is required. Run 'claude
+ * update'…"). It names no model, so it covers every model it happens for.
+ * Like a signed-out turn, it is fixed by changing the install, not by a
+ * retry, so the UI offers to run the update. */
+export function claudeVersionTooOld(frame, text) {
+    if (frame.is_api_error_message !== true && typeof frame.error !== "string")
+        return false;
+    return /\bClaude Code v?\d+(?:\.\d+)+ does not support this model\b/i.test(text);
+}
 /** The CLI environment shared by auth probes and real turns.
  *
  * Subscription users can be billed pay-as-you-go if an inherited API key
@@ -275,17 +288,7 @@ export const CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--system-p
  * is the version. Null when nothing parses, e.g. a wrapper that prints its
  * own banner first — see claudeCliSupports for how that is treated. */
 export function parseClaudeCliVersion(stdout) {
-    const match = /(\d+)\.(\d+)\.(\d+)/.exec(stdout ?? "");
-    if (!match)
-        return null;
-    return [Number(match[1]), Number(match[2]), Number(match[3])];
-}
-function versionAtLeast(installed, floor) {
-    for (let i = 0; i < 3; i += 1) {
-        if (installed[i] !== floor[i])
-            return installed[i] > floor[i];
-    }
-    return true;
+    return parseVersionTriple(stdout ?? "");
 }
 /** Whether a CLI reporting `version` accepts `flag`. A version that could
  * not be parsed counts as current: every CLI that predates a floor prints a
@@ -857,11 +860,7 @@ export const ClaudeDriver = {
         // one active turn per thread; a second send while busy is a caller bug
         const active = new Map();
         const sessions = new Map();
-        const configuredIdleMinimum = Number(process.env.OMB_CLAUDE_SESSION_IDLE_MIN_MS);
-        const sessionIdleMinimum = Number.isFinite(configuredIdleMinimum) && configuredIdleMinimum > 0
-            ? configuredIdleMinimum
-            : 10_000;
-        const SESSION_IDLE_MS = Math.max(sessionIdleMinimum, Number(process.env.OMB_CLAUDE_SESSION_IDLE_MS) || 10 * 60_000);
+        const { idleMs: SESSION_IDLE_MS } = sessionIdlePolicy("CLAUDE");
         const stopSession = (session) => {
             void killCliTree(session.child).then((stopped) => {
                 if (stopped)
@@ -1446,6 +1445,11 @@ export const ClaudeDriver = {
                 // A settled turn owns no retry budget. Retained CLI sessions may run
                 // many later turns on this thread, and each must start fresh.
                 retryState.delete(threadId);
+                // Updating the executable cannot update code already loaded by this
+                // pooled child. Retire it before announcing completion so an explicit
+                // retry resumes on a fresh process; healthy sibling sessions stay warm.
+                if (stopReason === "update_required")
+                    closeSession(threadId, "update required");
                 emit({ ...base(threadId, t.turnId), type: "turn.completed", ok, stopReason, cost, ...(usage ? { usage } : {}) });
                 if (session.child.exitCode === null && !session.closing)
                     armIdle(threadId);
@@ -1508,6 +1512,12 @@ export const ClaudeDriver = {
                             emit({ ...base(threadId, currentTurnId()), type: "runtime.error", message: text, setup: true });
                             break;
                         }
+                        if (claudeVersionTooOld(o, text)) {
+                            if (session.turn)
+                                session.turn.updateRequired = true;
+                            emit({ ...base(threadId, currentTurnId()), type: "runtime.error", message: text, setup: true, claudeUpdate: true });
+                            break;
+                        }
                         if (text.trim()) {
                             // The CLI's own report of any other API error is still shown,
                             // but marked: the model never produced it.
@@ -1570,7 +1580,11 @@ export const ClaudeDriver = {
                         // are billed (at the cache rate) and they fill the window — but
                         // they are reported separately too, so the UI can show how much
                         // of the figure was context re-read rather than new text.
-                        settle(o.is_error !== true, session.turn?.authFailed ? "auth_required" : o.stop_reason ?? o.terminal_reason ?? null, o.total_cost_usd ?? null, o.usage
+                        settle(o.is_error !== true, session.turn?.authFailed
+                            ? "auth_required"
+                            : session.turn?.updateRequired
+                                ? "update_required"
+                                : o.stop_reason ?? o.terminal_reason ?? null, o.total_cost_usd ?? null, o.usage
                             ? {
                                 input: (o.usage.input_tokens || 0) + (o.usage.cache_read_input_tokens || 0) + (o.usage.cache_creation_input_tokens || 0),
                                 output: o.usage.output_tokens || 0,

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

@@ -6,11 +6,17 @@
 import { readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
+import { qualifiedModelLabel } from "../contracts.js";
 import { killCliTree, spawnCli } from "../procs.js";
+import { codexHome } from "./codex-identity.js";
 import { mergeLocalInject } from "./local-inject.js";
 export const STATIC_CODEX_MODELS = {
     default: "gpt-5.6-sol",
     options: [
+        // Only used when live discovery fails; these rows do not establish account access.
+        { id: "gpt-6-astra", label: "GPT-6 Astra (availability unverified)" },
+        { id: "gpt-6-sol", label: "GPT-6 Sol (availability unverified)" },
+        { id: "gpt-6-luna", label: "GPT-6 Luna (availability unverified)" },
         { id: "gpt-5.6-sol", label: "GPT-5.6 Sol" },
         { id: "gpt-5.6-terra", label: "GPT-5.6 Terra" },
         { id: "gpt-5.6-luna", label: "GPT-5.6 Luna" },
@@ -154,11 +160,6 @@ export function readCodexAppServerModelCatalog(cli, env, timeoutMs = 8_000) {
         request("initialize", { clientInfo: { name: "openmausbot", version: "1" } }, "initialize");
     });
 }
-export function codexHome(env) {
-    if (env.CODEX_HOME)
-        return env.CODEX_HOME;
-    return join(env.HOME || env.USERPROFILE || homedir(), ".codex");
-}
 function unquote(raw) {
     let value = raw.trim();
     const hash = value.indexOf(" #");
@@ -253,7 +254,10 @@ function niceLabel(model, provider, known, named) {
     if (named.has(encoded))
         return named.get(encoded);
     const host = providerName(provider, known);
-    return host === provider ? model : `${model} (${host})`;
+    return qualifiedModelLabel(model, host, {
+        redundantWhen: () => host === provider,
+        decorate: (facet) => ` (${facet})`,
+    });
 }
 function collectCatalogNames(home) {
     const named = new Map();
@@ -338,7 +342,11 @@ async function probeProviderModels(provider, env, fetchImpl) {
 /** Local slugs Codex already knows, plus the three official cloud rows. */
 export async function readCodexModelCatalog(env = process.env, fetchImpl = fetch, cli) {
     const official = (cli ? await readCodexAppServerModelCatalog(cli, env) : null) ?? STATIC_CODEX_MODELS;
+    // Match the identity boundary: an explicitly relative CODEX_HOME or user
+    // home must not load a catalog from a different directory.
     const home = codexHome(env);
+    if (!home)
+        return mergeLocalInject(official, env, fetchImpl);
     const mainText = readText(join(home, "config.toml"));
     if (!mainText)
         return mergeLocalInject(official, env, fetchImpl);

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

@@ -3,6 +3,7 @@
 // old file's email. Only the protocol's display email leaves this helper.
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
+import { userHome } from "../env-path.js";
 import { killCliTree, spawnCli } from "../procs.js";
 const MAX_OUTPUT = 16_384;
 const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
@@ -11,7 +12,7 @@ const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 export function codexHome(env) {
     if (env.CODEX_HOME)
         return isAbsolute(env.CODEX_HOME) ? resolve(env.CODEX_HOME) : null;
-    const home = env.HOME || env.USERPROFILE || homedir();
+    const home = userHome(env);
     return isAbsolute(home) ? join(home, ".codex") : null;
 }
 /** Read-only account metadata. Unsupported CLIs and uncertain responses stay

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

@@ -0,0 +1,48 @@
+// Release freshness is independent of account-specific model availability.
+function parseCodexReleaseVersion(value) {
+    const match = /^(?:.*\bcodex-cli\s+)?v?(\d+)\.(\d+)\.(\d+)(-[0-9a-z.-]+)?(?:\+[0-9a-z.-]+)?$/i.exec(value.trim());
+    return match ? { parts: match.slice(1, 4).map(Number), prerelease: Boolean(match[4]) } : null;
+}
+export function codexVersionBehind(installed, latest) {
+    const a = parseCodexReleaseVersion(installed);
+    const b = parseCodexReleaseVersion(latest);
+    if (!a || !b || b.prerelease)
+        return false;
+    for (let i = 0; i < 3; i++) {
+        if (a.parts[i] !== b.parts[i])
+            return a.parts[i] < b.parts[i];
+    }
+    return a.prerelease;
+}
+export function createCodexReleaseReader(fetchImpl = fetch, now = Date.now) {
+    let cached;
+    let expires = 0;
+    return () => {
+        if (cached && now() < expires)
+            return cached;
+        expires = now() + 60 * 60 * 1000;
+        cached = (async () => {
+            try {
+                const response = await fetchImpl("https://registry.npmjs.org/@openai/codex/latest", {
+                    signal: AbortSignal.timeout(3000),
+                    headers: { Accept: "application/json" },
+                });
+                if (!response.ok)
+                    throw new Error("Release lookup failed");
+                const payload = await response.json();
+                const version = typeof payload.version === "string" ? payload.version : "";
+                const parsed = parseCodexReleaseVersion(version);
+                if (!parsed || parsed.prerelease)
+                    throw new Error("Invalid stable release");
+                return version;
+            }
+            catch {
+                // Offline checks must not make an otherwise usable engine unavailable.
+                expires = now() + 5 * 60 * 1000;
+                return null;
+            }
+        })();
+        return cached;
+    };
+}
+export const readLatestCodexRelease = createCodexReleaseReader();

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

@@ -31,10 +31,9 @@ import { codexAccountEmail } from "./codex-identity.js";
 import { classifyResumeFailure, mayReplay, recoveryPromptFor } from "../resume-recovery.js";
 import { extractMcpImages } from "../mcp-tool-images.js";
 import { parseProtocolAskQuestions, questionAnswersById, questionChoices } from "../../shared/ask-question.js";
+import { codexVersionBehind, readLatestCodexRelease } from "./codex-release.js";
 export { decodeCodexSelection, readCodexModelCatalog, STATIC_CODEX_MODELS } from "./codex-catalog.js";
 const DRIVER_KIND = "codex";
-const ASTRA_MODEL_ID = "gpt-6-astra";
-const ASTRA_MIN_CODEX_VERSION = [0, 153, 1];
 class CodexRpcError extends Error {
     code;
     constructor(error) {
@@ -49,23 +48,6 @@ function missingNativeCodexThread(error, cursor) {
     return error instanceof CodexRpcError && error.code === -32600 &&
         error.message === `no rollout found for thread id ${cursor}`;
 }
-/** Whether an installed Codex predates the release that exposes GPT-6 Astra
- * through app-server. Unknown version formats stay quiet: a bad guess should
- * never nag someone whose custom build may already support the model. */
-export function codexPredatesAstra(version) {
-    const value = version.trim();
-    const match = /\bcodex-cli\s+v?(\d+)\.(\d+)\.(\d+)(?:[-+][0-9a-z.-]+)?(?![\d.])\b/i.exec(value)
-        ?? /^v?(\d+)\.(\d+)\.(\d+)(?:[-+][0-9a-z.-]+)?$/i.exec(value);
-    if (!match)
-        return false;
-    const installed = match.slice(1, 4).map(Number);
-    for (let i = 0; i < ASTRA_MIN_CODEX_VERSION.length; i += 1) {
-        if (installed[i] !== ASTRA_MIN_CODEX_VERSION[i]) {
-            return installed[i] < ASTRA_MIN_CODEX_VERSION[i];
-        }
-    }
-    return false;
-}
 /** Ask the configured executable to update itself. This matters when the user
  * selected a non-PATH Codex: installing a second global copy would leave
  * OpenMausBot pointing at the old binary. */
@@ -85,13 +67,13 @@ export function codexUpdateCommand(cli, platform = process.platform) {
     const command = (tokens.length > 0 ? tokens : [trimmed]).map(quote).join(" ");
     return platform === "win32" ? `& ${command} update` : `${command} update`;
 }
-function codexAstraUpdate(version, models, cli) {
-    if (models.options.some((model) => model.id === ASTRA_MODEL_ID) || !codexPredatesAstra(version)) {
+async function codexReleaseUpdate(version, cli) {
+    const latest = await readLatestCodexRelease();
+    if (!latest || !codexVersionBehind(version, latest))
         return undefined;
-    }
     return {
-        title: "Update Codex for GPT-6 Astra",
-        message: "This Codex version predates Astra support. Update it, then refresh models. Astra must also be available to your signed-in ChatGPT account.",
+        title: `Update Codex to ${latest}`,
+        message: `A newer stable Codex CLI is available (installed: ${version}). Update it, then refresh models. Model availability also depends on your signed-in account.`,
         command: codexUpdateCommand(cli),
     };
 }
@@ -1579,7 +1561,7 @@ export const CodexDriver = {
                 version,
                 authenticated,
                 ...(email ? { account: { email } } : {}),
-                update: codexAstraUpdate(version, models, config.cli),
+                update: await codexReleaseUpdate(version, config.cli),
                 billing: "subscription",
             };
         };

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

@@ -332,7 +332,8 @@ export function createOpenAIChatRuntime(options) {
         });
         let resolveDone;
         const done = new Promise((resolve) => { resolveDone = resolve; });
-        active.set(turn.threadId, { abort, turnId, done, approval });
+        const turnEntry = { abort, turnId, done, approval, asides: [] };
+        active.set(turn.threadId, turnEntry);
         emit({ ...base(turn.threadId, turnId), type: "turn.started" });
         emit({ ...base(turn.threadId, turnId), type: "session.started", sessionId: null, model });
         void (async () => {
@@ -358,6 +359,13 @@ export function createOpenAIChatRuntime(options) {
                 }
                 for (let round = 0; round < 16; 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
+                    // user message lands on a consistent array (never inside a tool
+                    // batch) and the provider sees it as the newest input.
+                    const parked = turnEntry.asides.splice(0);
+                    if (parked.length)
+                        messages.push({ role: "user", content: parked.join("\n\n") });
                     native("out", options.nativeLog.outgoing(turn, messages, model));
                     let attempt = 0;
                     let completion;
@@ -609,9 +617,16 @@ export function createOpenAIChatRuntime(options) {
             : { state: "unavailable", reason: options.unavailableReason },
         adapter: {
             provider: options.driverKind,
-            capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false, cloudComputerMcp: options.tools !== false, localComputerMcp: options.tools !== false,
+            capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false,
+                    // Same gate as cloudComputerMcp: with tools off the runtime cannot
+                    // mount the leased Box descriptor either. The fleet invariant test
+                    // pins usesCloudComputer === (remoteAgent || cloudComputerMcp).
+                    usesCloudComputer: options.tools !== false, cloudComputerMcp: options.tools !== false, localComputerMcp: options.tools !== false,
                     browserMcp: options.tools !== false, nativeImageInput: true, images: true } : {}),
-                sessionModelSwitch: "in-session", customMcp: options.tools !== false, agentsMcp: options.tools !== false, composioMcp: options.tools !== false },
+                sessionModelSwitch: "in-session", customMcp: options.tools !== false, agentsMcp: options.tools !== false, composioMcp: options.tools !== false,
+                // The runtime owns the whole tool loop, so it can always take a
+                // user message mid-turn: park it, deliver before the next completion.
+                queueing: true },
             sendTurn,
             interruptTurn: async (threadId, turnId) => {
                 const turn = active.get(threadId);
@@ -621,6 +636,19 @@ export function createOpenAIChatRuntime(options) {
                 await turn.done;
             },
             respondToRequest: async (threadId, requestId, decision) => active.get(threadId)?.approval.answer(requestId, decision.behavior, decision.message) ?? "unavailable",
+            steer: async (threadId, text) => {
+                // This engine has no external session to respect — parking the
+                // words in the live turn's entry IS delivery into the loop, so a
+                // successful park is "steered" and a missing turn is the only
+                // refusal. The words ride the array at the next round boundary;
+                // if the turn settles first, the harness's transcript record
+                // keeps them for the next turn (they are never re-sent here).
+                const running = active.get(threadId);
+                if (!running)
+                    return "refused";
+                running.asides.push(text);
+                return "steered";
+            },
             hasSession: (threadId) => active.has(threadId),
             stopAll: async () => {
                 const turns = [...active.values()];