openmausbot 0.1.79 → 0.1.80

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

@@ -243,11 +243,14 @@ export const CLAUDE_FLAG_FLOORS = {
     "--strict-mcp-config": [1, 0, 60],
     "--setting-sources": [1, 0, 122],
     "--autocompact": [2, 1, 122],
+    // 2.1.267 is the first CLI that accepts it; below that the recorded prompt
+    // simply is not refreshed, which is the pre-existing behaviour.
+    "--system-prompt-snapshot": [2, 1, 267],
 };
 /** The newest floor above: a CLI at or past it accepts everything the
  * harness sends. Below it the engine still works, minus the flags the CLI
  * predates, and the Engines page suggests an update. */
-export const CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--autocompact"];
+export const CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--system-prompt-snapshot"];
 /** `claude --version` prints "2.1.232 (Claude Code)"; the first dotted triple
  * is the version. Null when nothing parses, e.g. a wrapper that prints its
  * own banner first — see claudeCliSupports for how that is treated. */
@@ -273,9 +276,7 @@ export function claudeCliSupports(version, flag) {
     return version === null || versionAtLeast(version, CLAUDE_FLAG_FLOORS[flag]);
 }
 /** The Engines-page notice for a CLI older than the newest floor. The engine
- * keeps working: turns run without the flags the CLI predates, which means
- * no harness-picked compaction window and, on a very old CLI, no isolation
- * from this machine's own Claude Code setup. */
+ * keeps working without the flags its CLI predates. */
 export function claudeCliUpdate(version, cli) {
     const parsed = parseClaudeCliVersion(version);
     if (!parsed || versionAtLeast(parsed, CLAUDE_CONTEXT_CONTROL_MIN_VERSION))
@@ -283,39 +284,18 @@ export function claudeCliUpdate(version, cli) {
     const floor = CLAUDE_CONTEXT_CONTROL_MIN_VERSION.join(".");
     const missing = Object.keys(CLAUDE_FLAG_FLOORS)
         .filter((flag) => !claudeCliSupports(parsed, flag));
+    const effects = [
+        ...(missing.includes("--autocompact") ? ["no compaction window picked by OpenMausBot"] : []),
+        ...(missing.includes("--setting-sources") ? ["bots still see this machine's own Claude Code setup"] : []),
+        ...(missing.includes("--system-prompt-snapshot") ? ["coordinated resumed turns cannot refresh stale system prompts"] : []),
+    ];
     return {
         title: "Update Claude Code for context controls",
         message: `Claude Code ${parsed.join(".")} predates ${floor}, so bots run without ${missing.join(", ")}: ` +
-            "no compaction window picked by OpenMausBot" +
-            (missing.includes("--setting-sources") ? ", and bots still see this machine's own Claude Code setup" : "") +
-            ". Update it, then refresh Engines.",
+            `${effects.join("; ")}. Update it, then refresh Engines.`,
         command: cli === "claude" ? "claude update" : `${cli} update`,
     };
 }
-/** Whether `claude --help` output lists `flag` as a supported option.
- *
- * A wrapper may print its own banner before the real options list, and the
- * flag may appear only in an example or description rather than as an
- * option. We scan for a line that begins with the flag (after optional
- * leading whitespace), which is how the real CLI formats its `--help`.
- */
-export function claudeCliHelpSupportsFlag(help, flag) {
-    if (!help)
-        return false;
-    const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`^\\s*${escaped}\\b`, "m").test(help);
-}
-/** Whether the installed CLI supports `--autocompact`.
- *
- * When `snapshot()` has already probed `claude --help`, use that. If the
- * probe has not run or `--help` failed, fall back to the version floor so
- * the pre-snapshot behavior is preserved.
- */
-export function claudeAutoCompactSupported(version, help) {
-    if (help !== null)
-        return claudeCliHelpSupportsFlag(help, "--autocompact");
-    return claudeCliSupports(version, "--autocompact");
-}
 const DRIVER_KIND = "claudeAgent";
 // model catalog ported from upstream packages/contracts/src/model.ts
 export const STATIC_CLAUDE_MODELS = {
@@ -707,6 +687,7 @@ function decodeConfig(raw) {
     return {
         cli: typeof o.cli === "string" ? o.cli : "claude",
         ...(configDir ? { configDir } : {}),
+        ...(o.managed === true ? { managed: true } : {}),
         permissionMode: mode ?? "acceptEdits",
         ...(tools !== undefined ? { tools } : {}),
         ...(disallowedTools !== undefined ? { disallowedTools } : {}),
@@ -793,10 +774,12 @@ export const ClaudeDriver = {
     defaultConfig: () => decodeConfig({}),
     async create(input) {
         const { instanceId, config } = input;
-        const environment = (model) => claudeEnvironment(model, { ...process.env, ...input.environment }, config.configDir, input.environment);
+        const environment = (model) => claudeEnvironment(config.managed ? undefined : model, { ...process.env, ...input.environment }, config.configDir, input.environment);
         const catalogEnv = environment();
         let models = STATIC_CLAUDE_MODELS;
         const refreshModels = async () => {
+            if (config.managed)
+                return;
             try {
                 const resolved = await mergeLocalInject(readClaudeModelCatalog(catalogEnv), catalogEnv);
                 if (resolved.options.length)
@@ -807,16 +790,19 @@ export const ClaudeDriver = {
             }
         };
         await refreshModels();
-        // The installed CLI's version and `--help` output as snapshot() last read
-        // them, so a flag the CLI does not know is never passed to it. The harness
-        // snapshots every instance whenever it describes them — app load, the
-        // Engines page, and right after `claude update` — which is exactly when
-        // the answer changes, so a turn normally finds it filled. A turn before
-        // any snapshot falls back to the version floor for the flags that are not
-        // known yet.
+        // The installed CLI's version as snapshot() last read it, so a flag the
+        // CLI does not know is never passed to it (CLAUDE_FLAG_FLOORS). The
+        // harness snapshots every instance whenever it describes them — app
+        // load, the Engines page, and right after `claude update`, which is
+        // exactly when the answer changes — so a turn normally finds it filled.
+        // Most turns before any snapshot assume a current CLI. A coordinated
+        // turn checks first because the snapshot-refresh flag is newer than the
+        // other context controls and an unknown flag would reject that request.
         let cliVersion = null;
-        let cliHelp = null;
-        let cliHelpVersion = null;
+        let cliVersionChecked = false;
+        const readCliVersion = (env) => new Promise((resolve) => {
+            execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout.trim() || null));
+        });
         const listeners = new Set();
         // one active turn per thread; a second send while busy is a caller bug
         const active = new Map();
@@ -901,6 +887,10 @@ export const ClaudeDriver = {
         // is a fresh sendTurn, and the attempt cap must survive across launches
         const retryState = new Map();
         const sendTurn = async (turn, logicalTurnId) => {
+            if (config.managed && (!turn.model || turn.model.includes("::") || !config.configDir ||
+                !input.environment.ANTHROPIC_API_KEY || !input.environment.ANTHROPIC_BASE_URL)) {
+                throw new Error("Company model access is unavailable. Reconnect your organization; personal billing will not be used.");
+            }
             const { threadId, botId } = turn;
             // An internal relaunch (transient failure, rejected resume) keeps the
             // logical turn's stop handle in `active` while it sets up, so Stop is
@@ -957,6 +947,13 @@ export const ClaudeDriver = {
                 args.push("--disallowedTools", config.disallowedTools.join(","));
             }
             const turnEnvironment = environment();
+            if (turn.refreshSystemPrompt && !cliVersionChecked) {
+                const version = await readCliVersion(turnEnvironment);
+                if (version) {
+                    cliVersion = parseClaudeCliVersion(version);
+                    cliVersionChecked = true;
+                }
+            }
             const isolated = !inheritsUserConfig(turnEnvironment);
             if (isolated) {
                 // A bot gets the tools and instructions its owner gave it, not
@@ -974,11 +971,19 @@ export const ClaudeDriver = {
                     args.push("--setting-sources", "project");
             }
             const compactWindow = autoCompactWindow(turnEnvironment);
-            if (compactWindow && claudeAutoCompactSupported(cliVersion, cliHelp)) {
+            if (compactWindow && claudeCliSupports(cliVersion, "--autocompact")) {
                 args.push("--autocompact", compactWindow);
             }
-            const turnModel = await resolveClaudeTurnModel(turn.model, turnEnvironment);
-            const injected = applyClaudeInject({ ...turnEnvironment }, turnModel);
+            // An old pair conversation can still carry its first assignment in
+            // Claude's recorded system prompt. The current brief rides in the user
+            // turn, so refresh the recorded prompt on --resume too. Gated by the
+            // version floor like every other flag the CLI may predate: an unknown
+            // flag is a hard argument error, not a graceful degrade.
+            if (turn.refreshSystemPrompt && cliVersionChecked && claudeCliSupports(cliVersion, "--system-prompt-snapshot")) {
+                args.push("--system-prompt-snapshot", "off");
+            }
+            const turnModel = config.managed ? turn.model : await resolveClaudeTurnModel(turn.model, turnEnvironment);
+            const injected = config.managed ? { model: turnModel ?? null, injected: false } : applyClaudeInject({ ...turnEnvironment }, turnModel);
             if (injected.model)
                 args.push("--model", injected.model);
             if (turn.effort)
@@ -1442,6 +1447,9 @@ export const ClaudeDriver = {
                                 ...(typeof msg.usage.cache_read_input_tokens === "number"
                                     ? { cachedInput: msg.usage.cache_read_input_tokens }
                                     : {}),
+                                // one assistant message = one model call, and its prompt is
+                                // everything in the window: fresh text, cache reads and writes
+                                contextTokens: (msg.usage.input_tokens || 0) + (msg.usage.cache_read_input_tokens || 0) + (msg.usage.cache_creation_input_tokens || 0),
                             });
                         }
                         break;
@@ -1728,32 +1736,17 @@ export const ClaudeDriver = {
         const login = new ClaudeLoginController({ cli: config.cli, environment, onAuthenticated: async () => { await refreshModels(); } });
         const snapshot = async () => {
             const env = environment();
-            const version = await new Promise((resolve) => {
-                execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout.trim()));
-            });
+            const version = await readCliVersion(env);
             if (!version)
                 return { state: "unavailable", reason: `\`${config.cli}\` CLI not found` };
             cliVersion = parseClaudeCliVersion(version);
-            if (version !== cliHelpVersion) {
-                cliHelp = await new Promise((resolve) => {
-                    execCli(config.cli, ["--help"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout));
-                });
-                cliHelpVersion = version;
-            }
-            const features = cliHelp !== null ? { autocompact: claudeCliHelpSupportsFlag(cliHelp, "--autocompact") } : undefined;
+            cliVersionChecked = true;
             const auth = await claudeAuthStatus(config.cli, env);
             // claudeEnvironment strips ANTHROPIC_API_KEY, so turns run on the
             // CLI's own login (Pro/Max): the cost it reports is what the call
             // WOULD bill, not a charge
             const update = claudeCliUpdate(version, config.cli);
-            return {
-                state: "available",
-                version,
-                ...auth,
-                ...(update ? { update } : {}),
-                ...(features ? { features } : {}),
-                billing: "subscription",
-            };
+            return { state: "available", version, ...auth, ...(update ? { update } : {}), billing: "subscription" };
         };
         /** One-shot Claude call with the prompt on stdin, never argv. Approval
          * summaries can contain paths, commands, or secrets, so the generic

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,8 +94,33 @@ 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);
+    if (url.username || url.password || url.search || url.hash || !["https:", "http:"].includes(url.protocol))
+        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.";
 /** RequestPermissionProfile uses null for permission families that were not
@@ -416,8 +456,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 +489,14 @@ export const CodexDriver = {
             createdAt: new Date().toISOString(),
         });
         const sendTurn = async (turn) => {
+            if (config.managed && (!turn.model || !config.managed.models.includes(turn.model) || !input.environment.OPENMAUSBOT_COMPANY_API_KEY || !input.environment.CODEX_HOME)) {
+                throw new Error("Company model access is unavailable. 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();
@@ -473,7 +520,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);
                 }
@@ -512,9 +559,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 +596,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"));
@@ -730,6 +792,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 +908,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 +1005,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 +1056,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 +1163,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 +1228,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 +1268,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 +1320,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/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, {