openmausbot 0.1.79 → 0.1.80

package/dist-server/openmausbot.js

@@ -19049,7 +19049,7 @@ var init_registry = __esm({
         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)) {
           await this.dispose(instanceId);
           const driver = this.driversByKind.get(entry.driver);
@@ -19078,7 +19078,7 @@ var init_registry = __esm({
               enabled: entry.enabled ?? true,
               config: config2
             });
-            this.byId.set(instanceId, { instanceId, live });
+            this.byId.set(instanceId, { instanceId, live: decorate ? decorate(live) : live });
           } catch (e) {
             this.byId.set(instanceId, {
               instanceId,
@@ -19600,6 +19600,8 @@ var init_redact = __esm({
     REDACTION_MARKER = /^«redacted \d+ chars»$/;
     mask = (value) => REDACTION_MARKER.test(value) ? value : `\xABredacted ${value.length} chars\xBB`;
     KEY_PREFIXES = [
+      /\bom[dg]_[A-Za-z0-9_-]{43}(?![A-Za-z0-9_-])/g,
+      // desktop device and model-only credentials
       /\bsk-(?:ant-|proj-|live-|test-)?[A-Za-z0-9_-]{16,}/g,
       // anthropic / openai / stripe
       /\bxai-[A-Za-z0-9_-]{20,}/g,
@@ -22637,21 +22639,17 @@ function claudeCliUpdate(version2, cli) {
   if (!parsed || versionAtLeast(parsed, CLAUDE_CONTEXT_CONTROL_MIN_VERSION)) return void 0;
   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.",
+    message: `Claude Code ${parsed.join(".")} predates ${floor}, so bots run without ${missing.join(", ")}: ${effects.join("; ")}. Update it, then refresh Engines.`,
     command: cli === "claude" ? "claude update" : `${cli} update`
   };
 }
-function claudeCliHelpSupportsFlag(help, flag) {
-  if (!help) return false;
-  const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`^\\s*${escaped}\\b`, "m").test(help);
-}
-function claudeAutoCompactSupported(version2, help) {
-  if (help !== null) return claudeCliHelpSupportsFlag(help, "--autocompact");
-  return claudeCliSupports(version2, "--autocompact");
-}
 async function resolveClaudeTurnModel(model, env) {
   if (!model || decodeInjectId(model) || STATIC_CLAUDE_MODELS.options.some((option) => option.id === model)) {
     return model;
@@ -22914,6 +22912,7 @@ function decodeConfig2(raw) {
   return {
     cli: typeof o.cli === "string" ? o.cli : "claude",
     ...configDir ? { configDir } : {},
+    ...o.managed === true ? { managed: true } : {},
     permissionMode: mode ?? "acceptEdits",
     ...tools !== void 0 ? { tools } : {},
     ...disallowedTools !== void 0 ? { disallowedTools } : {}
@@ -23003,9 +23002,12 @@ var init_claude = __esm({
     CLAUDE_FLAG_FLOORS = {
       "--strict-mcp-config": [1, 0, 60],
       "--setting-sources": [1, 0, 122],
-      "--autocompact": [2, 1, 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]
     };
-    CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--autocompact"];
+    CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--system-prompt-snapshot"];
     DRIVER_KIND2 = "claudeAgent";
     STATIC_CLAUDE_MODELS = {
       default: "claude-sonnet-5",
@@ -23044,10 +23046,11 @@ var init_claude = __esm({
       defaultConfig: () => decodeConfig2({}),
       async create(input) {
         const { instanceId, config: config2 } = input;
-        const environment = (model) => claudeEnvironment(model, { ...process.env, ...input.environment }, config2.configDir, input.environment);
+        const environment = (model) => claudeEnvironment(config2.managed ? void 0 : model, { ...process.env, ...input.environment }, config2.configDir, input.environment);
         const catalogEnv = environment();
         let models2 = STATIC_CLAUDE_MODELS;
         const refreshModels = async () => {
+          if (config2.managed) return;
           try {
             const resolved = await mergeLocalInject(readClaudeModelCatalog(catalogEnv), catalogEnv);
             if (resolved.options.length) models2 = resolved;
@@ -23056,8 +23059,15 @@ var init_claude = __esm({
         };
         await refreshModels();
         let cliVersion = null;
-        let cliHelp = null;
-        let cliHelpVersion = null;
+        let cliVersionChecked = false;
+        const readCliVersion = (env) => new Promise((resolve12) => {
+          execCli(
+            config2.cli,
+            ["--version"],
+            { timeout: 8e3, env },
+            (err, stdout2) => resolve12(err ? null : stdout2.trim() || null)
+          );
+        });
         const listeners = /* @__PURE__ */ new Set();
         const active = /* @__PURE__ */ new Map();
         const sessions = /* @__PURE__ */ new Map();
@@ -23124,6 +23134,9 @@ var init_claude = __esm({
         });
         const retryState = /* @__PURE__ */ new Map();
         const sendTurn = async (turn, logicalTurnId) => {
+          if (config2.managed && (!turn.model || turn.model.includes("::") || !config2.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;
           const relaunch = logicalTurnId !== void 0;
           if (active.has(threadId) && !relaunch) throw new Error("a turn is already running on this thread");
@@ -23160,17 +23173,27 @@ var init_claude = __esm({
             args.push("--disallowedTools", config2.disallowedTools.join(","));
           }
           const turnEnvironment = environment();
+          if (turn.refreshSystemPrompt && !cliVersionChecked) {
+            const version2 = await readCliVersion(turnEnvironment);
+            if (version2) {
+              cliVersion = parseClaudeCliVersion(version2);
+              cliVersionChecked = true;
+            }
+          }
           const isolated = !inheritsUserConfig(turnEnvironment);
           if (isolated) {
             if (claudeCliSupports(cliVersion, "--strict-mcp-config")) args.push("--strict-mcp-config");
             if (claudeCliSupports(cliVersion, "--setting-sources")) 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);
+          if (turn.refreshSystemPrompt && cliVersionChecked && claudeCliSupports(cliVersion, "--system-prompt-snapshot")) {
+            args.push("--system-prompt-snapshot", "off");
+          }
+          const turnModel = config2.managed ? turn.model : await resolveClaudeTurnModel(turn.model, turnEnvironment);
+          const injected = config2.managed ? { model: turnModel ?? null, injected: false } : applyClaudeInject({ ...turnEnvironment }, turnModel);
           if (injected.model) args.push("--model", injected.model);
           if (turn.effort) args.push("--effort", turn.effort);
           let systemPromptPath = null;
@@ -23506,7 +23529,10 @@ var init_claude = __esm({
                     type: "thread.token-usage.updated",
                     input: (msg.usage.input_tokens || 0) + (msg.usage.cache_read_input_tokens || 0),
                     output: msg.usage.output_tokens || 0,
-                    ...typeof msg.usage.cache_read_input_tokens === "number" ? { cachedInput: msg.usage.cache_read_input_tokens } : {}
+                    ...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;
@@ -23739,38 +23765,13 @@ var init_claude = __esm({
         } });
         const snapshot = async () => {
           const env = environment();
-          const version2 = await new Promise((resolve12) => {
-            execCli(
-              config2.cli,
-              ["--version"],
-              { timeout: 8e3, env },
-              (err, stdout2) => resolve12(err ? null : stdout2.trim())
-            );
-          });
+          const version2 = await readCliVersion(env);
           if (!version2) return { state: "unavailable", reason: `\`${config2.cli}\` CLI not found` };
           cliVersion = parseClaudeCliVersion(version2);
-          if (version2 !== cliHelpVersion) {
-            cliHelp = await new Promise((resolve12) => {
-              execCli(
-                config2.cli,
-                ["--help"],
-                { timeout: 8e3, env },
-                (err, stdout2) => resolve12(err ? null : stdout2)
-              );
-            });
-            cliHelpVersion = version2;
-          }
-          const features = cliHelp !== null ? { autocompact: claudeCliHelpSupportsFlag(cliHelp, "--autocompact") } : void 0;
+          cliVersionChecked = true;
           const auth = await claudeAuthStatus(config2.cli, env);
           const update = claudeCliUpdate(version2, config2.cli);
-          return {
-            state: "available",
-            version: version2,
-            ...auth,
-            ...update ? { update } : {},
-            ...features ? { features } : {},
-            billing: "subscription"
-          };
+          return { state: "available", version: version2, ...auth, ...update ? { update } : {}, billing: "subscription" };
         };
         const generateReview = (prompt, signal) => new Promise((resolve12, reject) => {
           const child = spawnCli(
@@ -24709,6 +24710,9 @@ var init_codex_identity = __esm({
 // server/drivers/codex.ts
 import { existsSync as existsSync10 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
+function missingNativeCodexThread(error51, cursor3) {
+  return error51 instanceof CodexRpcError && error51.code === -32600 && error51.message === `no rollout found for thread id ${cursor3}`;
+}
 function codexPredatesAstra(version2) {
   const value = version2.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);
@@ -24743,9 +24747,39 @@ function decodeConfig3(raw) {
   const o = raw ?? {};
   return {
     cli: typeof o.cli === "string" ? o.cli : "codex",
-    fullAuto: o.fullAuto === true
+    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 url2 = new URL(value.url);
+  if (url2.username || url2.password || url2.search || url2.hash || !["https:", "http:"].includes(url2.protocol)) throw new Error("Invalid Company Codex endpoint.");
+  return { url: url2.href.replace(/\/$/, ""), models: value.models };
+}
+function managedCodexArgs(config2) {
+  return [
+    "-c",
+    'model_provider="openmaus_company"',
+    "-c",
+    'model_providers.openmaus_company.name="Company"',
+    "-c",
+    `model_providers.openmaus_company.base_url=${JSON.stringify(config2.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"
+  ];
+}
 function grantedPermissions(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
   return Object.fromEntries(
@@ -24961,7 +24995,7 @@ function mountMcpServer(appServerArgs, env, name, server, preApproved = true) {
     appServerArgs.push("-c", `${prefix}.default_tools_approval_mode="auto"`);
   }
 }
-var DRIVER_KIND3, ASTRA_MODEL_ID, ASTRA_MIN_CODEX_VERSION, QUESTION_TIMEOUT_NOTE2, DENY_TIMEOUT_NOTE2, plainRecord, containsControlCharacter, CodexDriver;
+var DRIVER_KIND3, ASTRA_MODEL_ID, ASTRA_MIN_CODEX_VERSION, CodexRpcError, QUESTION_TIMEOUT_NOTE2, DENY_TIMEOUT_NOTE2, plainRecord, containsControlCharacter, CodexDriver;
 var init_codex = __esm({
   "server/drivers/codex.ts"() {
     "use strict";
@@ -24978,10 +25012,18 @@ var init_codex = __esm({
     init_codex_instructions();
     init_codex_device_auth();
     init_codex_identity();
+    init_resume_recovery();
     init_codex_catalog();
     DRIVER_KIND3 = "codex";
     ASTRA_MODEL_ID = "gpt-6-astra";
     ASTRA_MIN_CODEX_VERSION = [0, 153, 1];
+    CodexRpcError = class extends Error {
+      code;
+      constructor(error51) {
+        super(error51.message ?? JSON.stringify(error51));
+        this.code = error51.code;
+      }
+    };
     QUESTION_TIMEOUT_NOTE2 = "No answer was given \u2014 use your best judgment.";
     DENY_TIMEOUT_NOTE2 = "OpenMausBot: nobody answered this permission request in time. Skip this action and finish what you can without it.";
     plainRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -25022,8 +25064,9 @@ var init_codex = __esm({
           return env;
         };
         const catalogEnv = childEnv();
-        let models2 = STATIC_CODEX_MODELS;
+        let models2 = config2.managed ? { default: config2.managed.models[0], options: config2.managed.models.map((id) => ({ id, label: id })) } : STATIC_CODEX_MODELS;
         const refreshModels = async () => {
+          if (config2.managed) return;
           try {
             const resolved = await readCodexModelCatalog(catalogEnv, fetch, config2.cli);
             if (resolved.options.length) models2 = resolved;
@@ -25049,7 +25092,12 @@ var init_codex = __esm({
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         const sendTurn = async (turn) => {
+          if (config2.managed && (!turn.model || !config2.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.");
+          }
           let stopRequested = false;
+          let promptSubmitted = false;
+          let recoveredMissingSession = false;
           const stopSignal = new AbortController();
           const { threadId } = turn;
           const approvalMode = turn.approvalMode ?? (config2.fullAuto ? "full" : "ask");
@@ -25065,7 +25113,7 @@ var init_codex = __esm({
           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", ...config2.managed ? managedCodexArgs(config2.managed) : codexLocalProviderArgs(env, turn.model)];
             if (turn.integrations?.composio) {
               mountMcpServer(appServerArgs, env, "openmausbot_connectors", turn.integrations.composio);
             }
@@ -25111,9 +25159,12 @@ var init_codex = __esm({
               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
-              usage: void 0
+              // 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: void 0,
+              usageBaseline: void 0
             };
             const asks = /* @__PURE__ */ new Map();
             let nextId = 1;
@@ -25140,6 +25191,12 @@ var init_codex = __esm({
               rpcPending.set(id, {
                 resolve: (v) => {
                   clearTimeout(timer);
+                  if (method === "thread/start" || method === "thread/resume") {
+                    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"));
@@ -25268,6 +25325,11 @@ var init_codex = __esm({
               const connectionError = msg.method === "error" && !("threadId" in p) && !("turnId" in p);
               if (!connectionError) {
                 if (!codexThreadId || p.threadId !== codexThreadId) return;
+                if (!codexTurnId && msg.method === "thread/tokenUsage/updated" && p.tokenUsage?.total) {
+                  const t2 = p.tokenUsage.total;
+                  state.usageBaseline = { input: t2.inputTokens ?? 0, output: t2.outputTokens ?? 0, cachedInput: t2.cachedInputTokens ?? 0 };
+                  return;
+                }
                 if (!codexTurnId) {
                   if (startingNativeTurn) {
                     if (earlyNotifications.length >= 1024) {
@@ -25351,22 +25413,35 @@ var init_codex = __esm({
                   break;
                 }
                 case "thread/tokenUsage/updated": {
-                  const turnUsage = p.tokenUsage?.last ?? p.tokenUsage?.total;
-                  if (turnUsage) {
+                  const t2 = p.tokenUsage?.total;
+                  const last = p.tokenUsage?.last;
+                  const shape = (u4) => ({
+                    input: u4.inputTokens ?? 0,
+                    output: u4.outputTokens ?? 0,
+                    cachedInput: u4.cachedInputTokens ?? 0
+                  });
+                  if (t2) {
+                    const b = state.usageBaseline ?? { input: 0, output: 0, cachedInput: 0 };
+                    const now = shape(t2);
                     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 t2.cachedInputTokens === "number" ? { cachedInput: Math.max(0, now.cachedInput - b.cachedInput) } : {}
                     };
+                  } else if (last) {
+                    state.usage = { input: last.inputTokens ?? 0, output: last.outputTokens ?? 0, ...typeof last.cachedInputTokens === "number" ? { cachedInput: last.cachedInputTokens } : {} };
                   }
-                  const t2 = p.tokenUsage?.total;
                   if (t2) {
+                    const window = p.tokenUsage?.modelContextWindow;
                     emit({
                       ...base2(threadId, turnId),
                       type: "thread.token-usage.updated",
                       input: t2.inputTokens ?? 0,
                       output: t2.outputTokens ?? 0,
-                      ...typeof t2.cachedInputTokens === "number" ? { cachedInput: t2.cachedInputTokens } : {}
+                      ...typeof t2.cachedInputTokens === "number" ? { cachedInput: t2.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;
@@ -25420,7 +25495,7 @@ var init_codex = __esm({
                   const pend = rpcPending.get(msg.id);
                   if (pend) {
                     rpcPending.delete(msg.id);
-                    if (msg.error) pend.reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
+                    if (msg.error) pend.reject(new CodexRpcError(msg.error));
                     else pend.resolve(msg.result);
                   }
                 } else if (msg.id !== void 0 && msg.method) {
@@ -25451,7 +25526,7 @@ var init_codex = __esm({
               }
               const recentStderr = stderrSinceOutput.trim();
               const hadStreamedOutput = codexTurnId !== null || state.sawStreamDelta;
-              const verdict = classifyError({ exitCode: code, stderr: recentStderr || stderr });
+              const verdict = signal !== null ? { transient: false, reason: "interrupted" } : classifyError({ exitCode: code, stderr: recentStderr });
               if (!stopRequested && codexTurnId === null && earlyNotifications.length === 0 && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1) {
                 const delayMs = computeBackoff(attempt);
                 attempt++;
@@ -25518,30 +25593,39 @@ var init_codex = __esm({
               autoAcceptPermissions = approvalMode === "full";
               const cursor3 = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
               let startedModel = null;
+              let resumedNativeThread = false;
+              let promptText = turn.text;
               if (cursor3) {
+                const resumeThread = () => request("thread/resume", {
+                  threadId: cursor3,
+                  developerInstructions,
+                  ...approvalParams.thread
+                });
                 try {
-                  const resumed = await request("thread/resume", {
-                    threadId: cursor3,
-                    developerInstructions,
-                    ...approvalParams.thread
-                  });
-                  codexThreadId = resumed?.thread?.id ?? cursor3;
-                } catch (error51) {
-                  if (approvalParams.fallback && permissionProfileUnsupported(error51)) {
+                  let resumed;
+                  try {
+                    resumed = await resumeThread();
+                  } catch (error51) {
+                    if (!approvalParams.fallback || !permissionProfileUnsupported(error51)) throw error51;
                     approvalParams = approvalParams.fallback;
-                    const resumed = await request("thread/resume", {
-                      threadId: cursor3,
-                      developerInstructions,
-                      ...approvalParams.thread
-                    });
-                    codexThreadId = resumed?.thread?.id ?? cursor3;
-                  } else {
-                    throw error51;
+                    resumed = await resumeThread();
                   }
+                  codexThreadId = resumed?.thread?.id ?? cursor3;
+                  resumedNativeThread = true;
+                } catch (error51) {
+                  const failure = classifyResumeFailure({
+                    attempted: true,
+                    rejected: error51 instanceof CodexRpcError,
+                    promptSubmitted,
+                    producedOutput: state.sawStreamDelta
+                  });
+                  if (!config2.managed || recoveredMissingSession || stopRequested || state.settled || !turn.recoveryText?.trim() || !missingNativeCodexThread(error51, cursor3) || !mayReplay(failure)) throw error51;
+                  recoveredMissingSession = true;
+                  promptText = recoveryPromptFor({ recoveryText: turn.recoveryText, currentText: turn.text, failure }).text;
                 }
               }
               if (!codexThreadId) {
-                const selection = decodeCodexSelection(turn.model);
+                const selection = config2.managed ? { model: turn.model, modelProvider: "openmaus_company" } : decodeCodexSelection(turn.model);
                 const startThread = () => request("thread/start", {
                   developerInstructions,
                   cwd: turn.cwd ?? homedir13(),
@@ -25562,14 +25646,14 @@ var init_codex = __esm({
                 startedModel = started?.model ?? null;
               }
               if (!codexThreadId) throw new Error("Codex did not return a native thread id");
-              await syncCodexInstructions(threadId, codexThreadId, developerInstructions, Boolean(cursor3), request);
+              await syncCodexInstructions(threadId, codexThreadId, developerInstructions, resumedNativeThread, request);
               emit({ ...base2(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,
@@ -25599,7 +25683,7 @@ var init_codex = __esm({
               const message2 = e instanceof Error ? e.message : String(e);
               const needsAuth = /(?:\b401\b|unauthorized|missing bearer|authentication required)/i.test(message2);
               const verdict = classifyError(failure);
-              if (!state.settled && !abandoned && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
+              if (!state.settled && !abandoned && !recoveredMissingSession && !stopRequested && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
                 const delayMs = computeBackoff(attempt);
                 attempt++;
                 emit({
@@ -25649,6 +25733,7 @@ var init_codex = __esm({
             );
           });
           if (!version2) return { state: "unavailable", reason: `\`${config2.cli}\` CLI not found` };
+          if (config2.managed) return { state: "available", version: version2, authenticated: Boolean(input.environment.OPENMAUSBOT_COMPANY_API_KEY && input.environment.CODEX_HOME), billing: "metered" };
           const authenticated = await new Promise((resolve12) => {
             execCli(
               config2.cli,