openmausbot 0.1.79 → 0.1.81

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

@@ -24,10 +24,25 @@ import { commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { codexDeveloperInstructions, syncCodexInstructions } from "./codex-instructions.js";
 import { CodexDeviceAuthController } from "./codex-device-auth.js";
 import { codexAccountEmail } from "./codex-identity.js";
+import { classifyResumeFailure, mayReplay, recoveryPromptFor } from "../resume-recovery.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) {
+        super(error.message ?? JSON.stringify(error));
+        this.code = error.code;
+    }
+}
+function missingNativeCodexThread(error, cursor) {
+    // Codex's local thread/resume rejection, verified with an empty native home.
+    // A generic 404, auth error, timeout or prose mentioning a missing thread is
+    // not evidence that the native history was lost. Unknown versions fail closed.
+    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. */
@@ -79,10 +94,50 @@ function decodeConfig(raw) {
     return {
         cli: typeof o.cli === "string" ? o.cli : "codex",
         fullAuto: o.fullAuto === true,
+        ...(o.managed && typeof o.managed === "object" ? { managed: decodeManagedCodex(o.managed) } : {}),
     };
 }
+function decodeManagedCodex(raw) {
+    const value = raw;
+    if (typeof value.url !== "string" || !Array.isArray(value.models) || !value.models.length || value.models.some(model => typeof model !== "string" || !/^[\w][\w./+-]*$/.test(model))) {
+        throw new Error("Invalid Company Codex configuration.");
+    }
+    const url = new URL(value.url);
+    // Plain HTTP leaks the Company API key; allow it only on loopback hosts,
+    // where a local proxy terminates TLS on the trusted machine instead.
+    const loopback = url.hostname === "localhost" || url.hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(url.hostname);
+    if (url.username || url.password || url.search || url.hash || (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)))
+        throw new Error("Invalid Company Codex endpoint.");
+    return { url: url.href.replace(/\/$/, ""), models: value.models };
+}
+export function managedCodexArgs(config) {
+    // Credential stays in the instance environment, never argv or config.toml.
+    // https://learn.chatgpt.com/docs/config-file/config-reference
+    return [
+        "-c", 'model_provider="openmaus_company"',
+        "-c", 'model_providers.openmaus_company.name="Company"',
+        "-c", `model_providers.openmaus_company.base_url=${JSON.stringify(config.url)}`,
+        "-c", 'model_providers.openmaus_company.env_key="OPENMAUSBOT_COMPANY_API_KEY"',
+        "-c", 'model_providers.openmaus_company.wire_api="responses"',
+        "-c", "model_providers.openmaus_company.requires_openai_auth=false",
+        "-c", 'cli_auth_credentials_store="ephemeral"',
+        "-c", "shell_environment_policy.ignore_default_excludes=false",
+    ];
+}
 const QUESTION_TIMEOUT_NOTE = "No answer was given — use your best judgment.";
 const DENY_TIMEOUT_NOTE = "OpenMausBot: nobody answered this permission request in time. Skip this action and finish what you can without it.";
+const skippedSseServers = new Set();
+function noteSkippedSseServer(name) {
+    if (skippedSseServers.has(name))
+        return;
+    skippedSseServers.add(name);
+    console.error(`codex: MCP server ${JSON.stringify(name)} uses the SSE transport, which codex does not speak — it is available to Claude bots only`);
+}
+/** A TOML inline table for a `-c key=value` override; JSON string quoting
+ * is valid TOML basic-string quoting. */
+function tomlInlineTable(entries) {
+    return `{ ${Object.entries(entries).map(([key, value]) => `${JSON.stringify(key)} = ${JSON.stringify(value)}`).join(", ")} }`;
+}
 /** RequestPermissionProfile uses null for permission families that were not
  * requested; GrantedPermissionProfile requires those keys to be absent. */
 function grantedPermissions(raw) {
@@ -370,12 +425,39 @@ export function codexNativeIncomingLogMessage(message, sensitiveResponseIds) {
     return message;
 }
 function mountMcpServer(appServerArgs, env, name, server, preApproved = true) {
-    Object.assign(env, server.env);
     const prefix = `mcp_servers.${name}`;
-    appServerArgs.push("-c", `${prefix}.command=${JSON.stringify(server.command)}`, "-c", `${prefix}.args=${JSON.stringify(server.args)}`, 
-    // Values stay in the child environment; argv contains names only so
-    // credentials never appear in process listings or diagnostics.
-    "-c", `${prefix}.env_vars=${JSON.stringify(Object.keys(server.env))}`);
+    if ("url" in server) {
+        // A remote server: codex connects itself. Header values are credentials
+        // (Authorization: Bearer …) and travel like env values — the child env
+        // holds them under harness-generated names, argv names only the variables.
+        // A bearer token goes through codex's own bearer setting, the path its
+        // remote servers are documented and exercised with; any other header
+        // rides env_http_headers.
+        appServerArgs.push("-c", `${prefix}.url=${JSON.stringify(server.url)}`);
+        const stem = `OMB_MCP_HEADER_${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
+        const variables = {};
+        Object.entries(server.headers).forEach(([header, value], index) => {
+            const bearer = header.toLowerCase() === "authorization" ? /^Bearer\s+(\S+)$/i.exec(value) : null;
+            if (bearer) {
+                env[`${stem}_BEARER`] = bearer[1];
+                appServerArgs.push("-c", `${prefix}.bearer_token_env_var=${JSON.stringify(`${stem}_BEARER`)}`);
+                return;
+            }
+            const variable = `${stem}_${index}`;
+            env[variable] = value;
+            variables[header] = variable;
+        });
+        if (Object.keys(variables).length) {
+            appServerArgs.push("-c", `${prefix}.env_http_headers=${tomlInlineTable(variables)}`);
+        }
+    }
+    else {
+        Object.assign(env, server.env);
+        appServerArgs.push("-c", `${prefix}.command=${JSON.stringify(server.command)}`, "-c", `${prefix}.args=${JSON.stringify(server.args)}`, 
+        // Values stay in the child environment; argv contains names only so
+        // credentials never appear in process listings or diagnostics.
+        "-c", `${prefix}.env_vars=${JSON.stringify(Object.keys(server.env))}`);
+    }
     // Harness-owned servers are pre-quieted; a user-configured server keeps
     // codex's on-request policy so its tool calls become approval cards.
     if (preApproved) {
@@ -416,8 +498,10 @@ export const CodexDriver = {
             return env;
         };
         const catalogEnv = childEnv();
-        let models = STATIC_CODEX_MODELS;
+        let models = config.managed ? { default: config.managed.models[0], options: config.managed.models.map(id => ({ id, label: id })) } : STATIC_CODEX_MODELS;
         const refreshModels = async () => {
+            if (config.managed)
+                return;
             try {
                 const resolved = await readCodexModelCatalog(catalogEnv, fetch, config.cli);
                 if (resolved.options.length)
@@ -447,9 +531,27 @@ export const CodexDriver = {
             createdAt: new Date().toISOString(),
         });
         const sendTurn = async (turn) => {
+            if (config.managed) {
+                // One blanket refusal hides which prerequisite broke; name it so the
+                // person can fix the actual gap instead of reconnecting blind.
+                if (!turn.model) {
+                    throw new Error("Company model access is unavailable: no model is selected. Reconnect your organization; personal billing will not be used.");
+                }
+                if (!config.managed.models.includes(turn.model)) {
+                    throw new Error("Company model access is unavailable: " + turn.model + " is not approved for your organization. Reconnect your organization; personal billing will not be used.");
+                }
+                if (!input.environment.OPENMAUSBOT_COMPANY_API_KEY) {
+                    throw new Error("Company model access is unavailable: OPENMAUSBOT_COMPANY_API_KEY is missing. Reconnect your organization; personal billing will not be used.");
+                }
+                if (!input.environment.CODEX_HOME) {
+                    throw new Error("Company model access is unavailable: CODEX_HOME is missing. Reconnect your organization; personal billing will not be used.");
+                }
+            }
             // One driver instance serves many threads. Interrupt state belongs to
             // this turn so activity elsewhere cannot cancel or revive its retry.
             let stopRequested = false;
+            let promptSubmitted = false;
+            let recoveredMissingSession = false;
             // Wakes a retry backoff the moment Stop arrives, so the turn settles
             // now rather than after the full wait.
             const stopSignal = new AbortController();
@@ -459,6 +561,8 @@ export const CodexDriver = {
             // explicit mode, which takes precedence.
             const approvalMode = turn.approvalMode ?? (config.fullAuto ? "full" : "ask");
             for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
+                if ("url" in server)
+                    continue;
                 const reserved = Object.keys(server.env).find(isHarnessOwnedMcpEnvName);
                 if (reserved) {
                     throw new Error(`Custom MCP server “${name}” cannot set reserved environment variable “${reserved}”`);
@@ -473,7 +577,7 @@ export const CodexDriver = {
             const retryScale = Number(process.env.FAKE_CODEX_RETRY_SCALE ?? "1");
             const launchAttempt = async (attempt) => {
                 const env = childEnv();
-                const appServerArgs = ["app-server", ...codexLocalProviderArgs(env, turn.model)];
+                const appServerArgs = ["app-server", ...(config.managed ? managedCodexArgs(config.managed) : codexLocalProviderArgs(env, turn.model))];
                 if (turn.integrations?.composio) {
                     mountMcpServer(appServerArgs, env, "openmausbot_connectors", turn.integrations.composio);
                 }
@@ -489,6 +593,13 @@ export const CodexDriver = {
                     mountMcpServer(appServerArgs, env, "browser", turn.integrations.browser);
                 }
                 for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
+                    // codex speaks streamable HTTP to a remote server, not the older
+                    // SSE transport: such an entry still reaches Claude bots, and is
+                    // left out here rather than mounted as something it is not
+                    if ("url" in server && server.type === "sse") {
+                        noteSkippedSseServer(name);
+                        continue;
+                    }
                     mountMcpServer(appServerArgs, env, name, server, false);
                 }
                 if (turn.integrations?.phone) {
@@ -512,9 +623,12 @@ export const CodexDriver = {
                     lastError: "",
                     lastText: "",
                     sawStreamDelta: false,
-                    // codex reports token usage as a running THREAD total; the harness
-                    // wants this turn's figure, so the last report is banked on settle
+                    // codex reports token usage as a running total for this app-server
+                    // process. The harness wants this turn's figure: the total minus
+                    // whatever the process already carried before turn/start (a resumed
+                    // thread may restore earlier usage), banked on settle.
                     usage: undefined,
+                    usageBaseline: undefined,
                 };
                 const asks = new Map();
                 let nextId = 1;
@@ -546,6 +660,18 @@ export const CodexDriver = {
                     rpcPending.set(id, {
                         resolve: (v) => {
                             clearTimeout(timer);
+                            if (method === "thread/start" || method === "thread/resume") {
+                                // Notifications can follow the thread response in the same
+                                // stdout chunk, before the handshake await resumes.
+                                const returnedId = v?.thread?.id;
+                                const requestedId = method === "thread/resume"
+                                    && params && typeof params === "object" && "threadId" in params
+                                    ? params.threadId : null;
+                                if (typeof returnedId === "string" && returnedId)
+                                    codexThreadId = returnedId;
+                                else if (typeof requestedId === "string" && requestedId)
+                                    codexThreadId = requestedId;
+                            }
                             if (method === "turn/start") {
                                 if (typeof v?.turn?.id !== "string" || !v.turn.id) {
                                     reject(new Error("Codex did not return a native turn id"));
@@ -641,6 +767,27 @@ export const CodexDriver = {
                         }
                         return;
                     }
+                    // One ask card carries one question honestly: its choices would come
+                    // from the first question alone and its one reply (including the
+                    // timeout note) would be copied into every question id (#1237).
+                    // Refuse the bundled call with a teaching error instead of
+                    // fabricating per-question answers.
+                    if (isQuestion && (!Array.isArray(params.questions) || params.questions.length !== 1)) {
+                        const bundled = Array.isArray(params.questions) && params.questions.length > 1;
+                        send({
+                            jsonrpc: "2.0",
+                            id: msg.id,
+                            error: {
+                                code: -32602,
+                                message: bundled
+                                    ? `ask supports one question per call; this request bundled ${params.questions.length}. Split it into separate asks, one question each.`
+                                    : Array.isArray(params.questions)
+                                        ? "ask supports one question per call; this request sent none."
+                                        : "ask supports one question per call; params.questions must be an array with exactly one question.",
+                            },
+                        });
+                        return;
+                    }
                     const mcpTool = isLegacyMcpPermission
                         ? String(params.message ?? "").match(/tool "([^"]+)"/)?.[1]
                         : undefined;
@@ -730,6 +877,17 @@ export const CodexDriver = {
                     if (!connectionError) {
                         if (!codexThreadId || p.threadId !== codexThreadId)
                             return;
+                        if (!codexTurnId && msg.method === "thread/tokenUsage/updated" && p.tokenUsage?.total) {
+                            // A total reported before this turn exists is what the process
+                            // carried in — a resumed thread restoring earlier usage. It is the
+                            // baseline this turn's figure is measured from, never a reading to
+                            // buffer and replay as if this turn produced it. (Codex names the
+                            // turn before any model call, so a genuine first reading cannot
+                            // land here.)
+                            const t = p.tokenUsage.total;
+                            state.usageBaseline = { input: t.inputTokens ?? 0, output: t.outputTokens ?? 0, cachedInput: t.cachedInputTokens ?? 0 };
+                            return;
+                        }
                         if (!codexTurnId) {
                             // Some servers stream before acknowledging turn/start. Retain a
                             // bounded prefix, then filter against the authoritative response.
@@ -835,32 +993,44 @@ export const CodexDriver = {
                             break;
                         }
                         case "thread/tokenUsage/updated": {
-                            // `last` is the most recent turn when the server sends it;
-                            // `total` is the thread so far — a fresh app-server per turn
-                            // makes that this turn's figure too
-                            const turnUsage = p.tokenUsage?.last ?? p.tokenUsage?.total;
-                            // codex's inputTokens already includes cachedInputTokens; the
-                            // cached share is carried alongside so the UI can say how much
-                            // of a turn was context re-read rather than new text
-                            if (turnUsage) {
+                            // `total` is everything this app-server process has used; `last`
+                            // is the most recent model call. This turn's figure is the total
+                            // minus what the process carried before turn/start went out (a
+                            // resumed thread can restore earlier usage), so it never grows by
+                            // the whole thread per message and never counts only the final
+                            // call of a multi-step turn. codex's inputTokens already includes
+                            // cachedInputTokens; the cached share rides alongside so the UI
+                            // can say how much was context re-read rather than new text.
+                            const t = p.tokenUsage?.total;
+                            const last = p.tokenUsage?.last;
+                            const shape = (u) => ({
+                                input: u.inputTokens ?? 0, output: u.outputTokens ?? 0, cachedInput: u.cachedInputTokens ?? 0,
+                            });
+                            // (A total that arrived before this turn was named became the
+                            // baseline upstream and never reaches this switch.)
+                            if (t) {
+                                const b = state.usageBaseline ?? { input: 0, output: 0, cachedInput: 0 };
+                                const now = shape(t);
                                 state.usage = {
-                                    input: turnUsage.inputTokens ?? 0,
-                                    output: turnUsage.outputTokens ?? 0,
-                                    ...(typeof turnUsage.cachedInputTokens === "number"
-                                        ? { cachedInput: turnUsage.cachedInputTokens }
-                                        : {}),
+                                    input: Math.max(0, now.input - b.input),
+                                    output: Math.max(0, now.output - b.output),
+                                    ...(typeof t.cachedInputTokens === "number" ? { cachedInput: Math.max(0, now.cachedInput - b.cachedInput) } : {}),
                                 };
                             }
-                            const t = p.tokenUsage?.total;
+                            else if (last) {
+                                state.usage = { input: last.inputTokens ?? 0, output: last.outputTokens ?? 0, ...(typeof last.cachedInputTokens === "number" ? { cachedInput: last.cachedInputTokens } : {}) };
+                            }
                             if (t) {
+                                const window = p.tokenUsage?.modelContextWindow;
                                 emit({
                                     ...base(threadId, turnId),
                                     type: "thread.token-usage.updated",
                                     input: t.inputTokens ?? 0,
                                     output: t.outputTokens ?? 0,
-                                    ...(typeof t.cachedInputTokens === "number"
-                                        ? { cachedInput: t.cachedInputTokens }
-                                        : {}),
+                                    ...(typeof t.cachedInputTokens === "number" ? { cachedInput: t.cachedInputTokens } : {}),
+                                    // the last call's prompt is what fills the window
+                                    ...(last && typeof last.inputTokens === "number" ? { contextTokens: last.inputTokens } : {}),
+                                    ...(typeof window === "number" && window > 0 ? { contextWindow: window } : {}),
                                 });
                             }
                             break;
@@ -920,7 +1090,7 @@ export const CodexDriver = {
                             if (pend) {
                                 rpcPending.delete(msg.id);
                                 if (msg.error)
-                                    pend.reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
+                                    pend.reject(new CodexRpcError(msg.error));
                                 else
                                     pend.resolve(msg.result);
                             }
@@ -971,7 +1141,16 @@ export const CodexDriver = {
                     // websocket 426 logged at turn start.
                     const recentStderr = stderrSinceOutput.trim();
                     const hadStreamedOutput = codexTurnId !== null || state.sawStreamDelta;
-                    const verdict = classifyError({ exitCode: code, stderr: recentStderr || stderr });
+                    // A signal exit is terminal no matter what the stderr says:
+                    // something killed the process (OOM, kill -9), and classifyError
+                    // cannot see the signal — with code null, transient-looking recent
+                    // stderr could still mark a killed attempt retryable.
+                    // Classification also reads only stderr received after the last
+                    // protocol output; the lifetime buffer's tail can name a
+                    // long-past event (the websocket-426 misattribution).
+                    const verdict = signal !== null
+                        ? { transient: false, reason: "interrupted" }
+                        : classifyError({ exitCode: code, stderr: recentStderr });
                     // Safe re-dispatch: relaunch only when the app-server never
                     // acknowledged turn/start — no native turn began, nothing was
                     // streamed, so replaying the input cannot duplicate work. After
@@ -1069,35 +1248,48 @@ export const CodexDriver = {
                     // Removed bot rules are cleared without dropping native configured rules.
                     const cursor = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
                     let startedModel = null;
+                    let resumedNativeThread = false;
+                    let promptText = turn.text;
                     if (cursor) {
+                        const resumeThread = () => request("thread/resume", {
+                            threadId: cursor,
+                            developerInstructions,
+                            ...approvalParams.thread,
+                        });
                         try {
-                            const resumed = await request("thread/resume", {
-                                threadId: cursor,
-                                developerInstructions,
-                                ...approvalParams.thread,
-                            });
+                            let resumed;
+                            try {
+                                resumed = await resumeThread();
+                            }
+                            catch (error) {
+                                if (!approvalParams.fallback || !permissionProfileUnsupported(error))
+                                    throw error;
+                                // Older servers may require the legacy permission selector, but
+                                // still resume the same native thread before any user submission.
+                                approvalParams = approvalParams.fallback;
+                                resumed = await resumeThread();
+                            }
                             codexThreadId = resumed?.thread?.id ?? cursor;
+                            resumedNativeThread = true;
                         }
                         catch (error) {
-                            if (approvalParams.fallback && permissionProfileUnsupported(error)) {
-                                // A server can understand config/read before it understands the
-                                // profile selector. Retry the same resume safely rather than
-                                // losing the native thread or inheriting its previous mode.
-                                approvalParams = approvalParams.fallback;
-                                const resumed = await request("thread/resume", {
-                                    threadId: cursor,
-                                    developerInstructions,
-                                    ...approvalParams.thread,
-                                });
-                                codexThreadId = resumed?.thread?.id ?? cursor;
-                            }
-                            else {
+                            const failure = classifyResumeFailure({
+                                attempted: true,
+                                rejected: error instanceof CodexRpcError,
+                                promptSubmitted,
+                                producedOutput: state.sawStreamDelta,
+                            });
+                            if (!config.managed || recoveredMissingSession || stopRequested || state.settled ||
+                                !turn.recoveryText?.trim() || !missingNativeCodexThread(error, cursor) || !mayReplay(failure))
                                 throw error;
-                            }
+                            // The prompt has never been submitted. Rebuild only missing Company
+                            // histories, once, through the same approved model/provider below.
+                            recoveredMissingSession = true;
+                            promptText = recoveryPromptFor({ recoveryText: turn.recoveryText, currentText: turn.text, failure }).text;
                         }
                     }
                     if (!codexThreadId) {
-                        const selection = decodeCodexSelection(turn.model);
+                        const selection = config.managed ? { model: turn.model, modelProvider: "openmaus_company" } : decodeCodexSelection(turn.model);
                         const startThread = () => request("thread/start", {
                             developerInstructions,
                             cwd: turn.cwd ?? homedir(),
@@ -1121,14 +1313,14 @@ export const CodexDriver = {
                     }
                     if (!codexThreadId)
                         throw new Error("Codex did not return a native thread id");
-                    await syncCodexInstructions(threadId, codexThreadId, developerInstructions, Boolean(cursor), request);
+                    await syncCodexInstructions(threadId, codexThreadId, developerInstructions, resumedNativeThread, request);
                     emit({ ...base(threadId, turnId), type: "session.started", sessionId: codexThreadId, model: startedModel ?? turn.model ?? null });
-                    const promptText = turn.text;
                     const turnInput = [
                         ...(promptText ? [{ type: "text", text: promptText }] : []),
                         ...(turn.images ?? []).map((image) => ({ type: "localImage", path: image.path })),
                     ];
                     const startTurn = () => {
+                        promptSubmitted = true;
                         startingNativeTurn = true;
                         return request("turn/start", {
                             threadId: codexThreadId,
@@ -1161,7 +1353,10 @@ export const CodexDriver = {
                     const message = e instanceof Error ? e.message : String(e);
                     const needsAuth = /(?:\b401\b|unauthorized|missing bearer|authentication required)/i.test(message);
                     const verdict = classifyError(failure);
-                    if (!state.settled && !abandoned && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
+                    // Three guards hold here: main's abandoned attempt never retries,
+                    // neither does a Company session already recovered once from canonical
+                    // history, and a Stop already asked for must not be undone by a relaunch.
+                    if (!state.settled && !abandoned && !recoveredMissingSession && !stopRequested && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
                         const delayMs = computeBackoff(attempt);
                         attempt++;
                         emit({
@@ -1210,6 +1405,8 @@ export const CodexDriver = {
             });
             if (!version)
                 return { state: "unavailable", reason: `\`${config.cli}\` CLI not found` };
+            if (config.managed)
+                return { state: "available", version, authenticated: Boolean(input.environment.OPENMAUSBOT_COMPANY_API_KEY && input.environment.CODEX_HOME), billing: "metered" };
             const authenticated = await new Promise((resolve) => {
                 execCli(config.cli, ["login", "status"], { timeout: 8000, env }, (err, stdout, stderr) => resolve(!err && /^logged in\b/im.test(`${stdout}\n${stderr ?? ""}`)));
             });

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

@@ -6,14 +6,19 @@ import { appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { NATIVE_DIR } from "../config.js";
 import { redactSecrets } from "../redact.js";
+import { capThreadLog, currentThreadLogCap } from "../thread-log-rotation.js";
 export function appendNative(threadId, entry) {
+    const file = join(NATIVE_DIR, `${threadId}.ndjson`);
     try {
         // The session-setup messages carry the credentials the agent is handed —
         // the box and comms tokens ride inside session/new's mcpServers env, and
         // an MCP header can carry a Composio key. These files are ordinary
         // 0644 files people paste into bug reports, so values are masked while
         // the shape stays intact.
-        appendFileSync(join(NATIVE_DIR, `${threadId}.ndjson`), JSON.stringify({ at: new Date().toISOString(), ...entry, msg: redactSecrets(entry.msg) }) + "\n", { mode: 0o600 });
+        appendFileSync(file, JSON.stringify({ at: new Date().toISOString(), ...entry, msg: redactSecrets(entry.msg) }) + "\n", { mode: 0o600 });
+        // Best-effort size cap (#1280) — same rule as the write itself: never
+        // let logging break the run it is observing.
+        capThreadLog(file, currentThreadLogCap());
     }
     catch {
         /* never let logging break a run */

package/dist-server/server/harness/bus.js

@@ -8,6 +8,7 @@ import { appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { EVENTS_DIR } from "../config.js";
 import { redactSecrets } from "../redact.js";
+import { capThreadLog, currentThreadLogCap } from "../thread-log-rotation.js";
 import { newId } from "../contracts.js";
 const INCOMPLETE_LOG_MESSAGE = "Canonical event history is incomplete: OpenMausBot could not write one or more events to disk. Live updates will continue.";
 export class EventBus {
@@ -43,6 +44,9 @@ export class EventBus {
             this.appendLog(join(EVENTS_DIR, `${event.threadId}.ndjson`), persistedEvents.map((entry) => JSON.stringify(entry)).join("\n") + "\n", { mode: 0o600 });
             if (pendingWarning)
                 this.pendingLogWarnings.delete(event.threadId);
+            // Best-effort size cap (#1280): an open thread's canonical log
+            // otherwise grows without bound for as long as the thread stays open.
+            capThreadLog(join(EVENTS_DIR, `${event.threadId}.ndjson`), currentThreadLogCap());
         }
         catch (error) {
             // Never feed this warning back through publish(): that would retry the

package/dist-server/server/harness/registry.js

@@ -46,7 +46,7 @@ export class ProviderRegistry {
         this.npmPresent = options.npmAvailable ?? npmAvailable;
         this.driversByKind = new Map(drivers.map((d) => [d.driverKind, d]));
     }
-    async load(configs) {
+    async load(configs, decorate) {
         for (const [instanceId, entry] of Object.entries(configs)) {
             // Account edits replace only their own process/session state.
             await this.dispose(instanceId);
@@ -80,7 +80,7 @@ export class ProviderRegistry {
                     enabled: entry.enabled ?? true,
                     config,
                 });
-                this.byId.set(instanceId, { instanceId, live });
+                this.byId.set(instanceId, { instanceId, live: decorate ? decorate(live) : live });
             }
             catch (e) {
                 this.byId.set(instanceId, {
@@ -225,6 +225,7 @@ export class ProviderRegistry {
                     browserMcp: inst.adapter.capabilities.browserMcp === true,
                     images: inst.adapter.capabilities.images === true,
                     effortLevels: inst.adapter.capabilities.effortLevels,
+                    modelVariants: inst.adapter.capabilities.modelVariants === true,
                     queueing: inst.adapter.capabilities.queueing === true,
                     localComputerMcp: inst.adapter.capabilities.localComputerMcp === true,
                     approvalReview: inst.reviewPermission !== undefined,