polygram 0.21.0 → 0.23.0

package/lib/handlers/config-ui.js

@@ -19,6 +19,160 @@
 const MODEL_OPTIONS = ['opus', 'sonnet', 'haiku'];
 const EFFORT_OPTIONS = ['low', 'medium', 'high', 'xhigh', 'max'];
 
+function isCodexRuntimeView(runtimeView) {
+  return runtimeView?.runtime === 'codex';
+}
+
+function uniqueStrings(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values.filter(
+    (value) => typeof value === 'string' && value.length > 0,
+  ))];
+}
+
+function getCodexCatalogModels(runtimeView) {
+  if (!isCodexRuntimeView(runtimeView) || !Array.isArray(runtimeView.models)) {
+    return [];
+  }
+  const seen = new Set();
+  return runtimeView.models.filter((entry) => {
+    if (
+      !entry
+      || typeof entry.model !== 'string'
+      || entry.model.length === 0
+      || seen.has(entry.model)
+    ) {
+      return false;
+    }
+    seen.add(entry.model);
+    return true;
+  });
+}
+
+function getCodexCatalogEfforts(runtimeView, model = runtimeView?.model) {
+  if (!isCodexRuntimeView(runtimeView)) return [];
+  const catalogEfforts = uniqueStrings(runtimeView.efforts);
+  const modelEntry = getCodexCatalogModels(runtimeView)
+    .find((entry) => entry.model === model);
+  const modelEfforts = uniqueStrings(modelEntry?.supportedReasoningEfforts);
+  if (modelEntry) return modelEfforts;
+  return model === runtimeView.model ? catalogEfforts : [];
+}
+
+function resolveCodexEffortForModel(runtimeView, model, currentEffort) {
+  const modelEntry = getCodexCatalogModels(runtimeView)
+    .find((entry) => entry.model === model);
+  if (!modelEntry) return null;
+  const supported = uniqueStrings(modelEntry.supportedReasoningEfforts);
+  if (supported.includes(currentEffort)) return currentEffort;
+  return supported.includes(modelEntry.defaultReasoningEffort)
+    ? modelEntry.defaultReasoningEffort
+    : null;
+}
+
+function formatSettingsPair(settings) {
+  if (
+    !settings
+    || typeof settings.model !== 'string'
+    || typeof settings.effort !== 'string'
+  ) {
+    return null;
+  }
+  return `${settings.model}/${settings.effort}`;
+}
+
+function sameSettingsPair(left, right) {
+  return (
+    left?.model === right?.model
+    && left?.effort === right?.effort
+  );
+}
+
+function formatCodexSettingsOutcome(result) {
+  const next = formatSettingsPair(result?.nextTurn);
+  switch (result?.outcome) {
+    case 'updated-live': {
+      const current = formatSettingsPair(result.currentTurn);
+      return current
+        ? ` — current turn ${current} unchanged; next turn ${next}`
+        : ' — selected for next turn';
+    }
+    case 'not-loaded':
+      return " — selected for this chat's next session";
+    case 'daemon-busy':
+      return ' — selected; this chat is not loaded; its next message may be busy';
+    case 'unavailable':
+      return ' — selected durably, but the current process did not accept it'
+        + (result.reason ? ` (${result.reason})` : '');
+    case 'live-status-unknown':
+      return ' — selected durably; live status is unknown';
+    default:
+      return ' — selected durably; live status is unknown';
+  }
+}
+
+function withCodexSettingsOutcome(runtimeView, result) {
+  if (!isCodexRuntimeView(runtimeView)) return runtimeView;
+  const desiredSettings = result?.nextTurn ?? runtimeView.desiredSettings ?? {
+    model: runtimeView.model,
+    effort: runtimeView.effort,
+  };
+  let processStatus = runtimeView.processStatus;
+  let activeTurnSettings = runtimeView.activeTurnSettings ?? null;
+  let nextTurnSettings = runtimeView.nextTurnSettings ?? null;
+  let unavailableReason = runtimeView.unavailableReason ?? null;
+  switch (result?.outcome) {
+    case 'updated-live':
+      processStatus = 'loaded';
+      activeTurnSettings = result.currentTurn ?? null;
+      nextTurnSettings = result.nextTurn ?? null;
+      unavailableReason = null;
+      break;
+    case 'not-loaded':
+    case 'daemon-busy':
+      processStatus = result.outcome;
+      activeTurnSettings = null;
+      nextTurnSettings = null;
+      break;
+    case 'unavailable':
+      processStatus = 'unavailable';
+      unavailableReason = result.reason ?? null;
+      break;
+    case 'live-status-unknown':
+      processStatus = 'unknown';
+      break;
+    default:
+      break;
+  }
+  return Object.freeze({
+    ...runtimeView,
+    model: desiredSettings.model,
+    effort: desiredSettings.effort,
+    desiredSettings: Object.freeze({ ...desiredSettings }),
+    activeTurnSettings,
+    nextTurnSettings,
+    processStatus,
+    unavailableReason,
+  });
+}
+
+function configuredRuntimeValue(
+  chatConfig,
+  topicConfig,
+  runtimeView,
+  setting,
+) {
+  const codex = isCodexRuntimeView(runtimeView);
+  const field = codex
+    ? setting === 'model' ? 'codexModel' : 'codexEffort'
+    : setting;
+  return (
+    (topicConfig && topicConfig[field])
+    || chatConfig[field]
+    || (codex ? runtimeView[setting] : null)
+  );
+}
+
 // Runtime callers pass the value resolved from the full config hierarchy.
 // Direct callers may omit it and retain the local topic/chat behavior.
 function resolveDisplayRichText(chatConfig, topicConfig, effectiveRichText) {
@@ -33,7 +187,7 @@ function resolveDisplayRichText(chatConfig, topicConfig, effectiveRichText) {
 // polygram passes the alias (opus / sonnet / haiku) and lets claude
 // resolve. Bump on Claude release.
 const MODEL_VERSIONS_DESC = {
-  opus: 'claude-opus-4-8',
+  opus: 'claude-opus-5',
   sonnet: 'claude-sonnet-4-6',
   haiku: 'claude-haiku-4-5',
 };
@@ -45,18 +199,47 @@ const MODEL_VERSIONS_DESC = {
  * null for the chat-level card) wins over chatConfig so the ✓ matches what a
  * topic actually runs — mirrors the spawn-path precedence (topic > chat).
  */
-function buildConfigKeyboard(chatConfig, show = 'all', topicConfig = null, effectiveRichText) {
-  const model = (topicConfig && topicConfig.model) || chatConfig.model;
-  const effort = (topicConfig && topicConfig.effort) || chatConfig.effort;
+function buildConfigKeyboard(
+  chatConfig,
+  show = 'all',
+  topicConfig = null,
+  effectiveRichText,
+  runtimeView = null,
+) {
+  const codex = isCodexRuntimeView(runtimeView);
+  const model = configuredRuntimeValue(
+    chatConfig,
+    topicConfig,
+    runtimeView,
+    'model',
+  );
+  const effort = configuredRuntimeValue(
+    chatConfig,
+    topicConfig,
+    runtimeView,
+    'effort',
+  );
+  const modelOptions = codex
+    ? getCodexCatalogModels(runtimeView)
+    : MODEL_OPTIONS.map((value) => ({ model: value, displayName: value }));
+  const effortOptions = codex
+    ? getCodexCatalogEfforts(runtimeView, model)
+    : EFFORT_OPTIONS;
   const rows = [];
   if (show === 'model' || show === 'all') {
-    rows.push(MODEL_OPTIONS.map((m) => ({
-      text: m === model ? `✓ ${m}` : m,
-      callback_data: `cfg:model:${m}`,
-    })));
+    rows.push(modelOptions.map((entry) => {
+      const label = (
+        typeof entry.displayName === 'string'
+        && entry.displayName.length > 0
+      ) ? entry.displayName : entry.model;
+      return {
+        text: entry.model === model ? `✓ ${label}` : label,
+        callback_data: `cfg:model:${entry.model}`,
+      };
+    }));
   }
   if (show === 'effort' || show === 'all') {
-    rows.push(EFFORT_OPTIONS.map((e) => ({
+    rows.push(effortOptions.map((e) => ({
       text: e === effort ? `✓ ${e}` : e,
       callback_data: `cfg:effort:${e}`,
     })));
@@ -82,9 +265,22 @@ function buildConfigKeyboard(chatConfig, show = 'all', topicConfig = null, effec
  * @param {object} deps.db
  * @param {(db, sessionKey) => string|null} deps.getClaudeSessionId
  */
-function createFormatConfigInfoText({ pm, db, getClaudeSessionId } = {}) {
-  return function formatConfigInfoText(chatConfig, show, sessionKey, topicConfig = null, effectiveRichText) {
+function createFormatConfigInfoText({
+  pm,
+  db,
+  getClaudeSessionId,
+  resolveRuntimeView = null,
+} = {}) {
+  function formatWithRuntimeView(
+    chatConfig,
+    show,
+    sessionKey,
+    topicConfig,
+    effectiveRichText,
+    runtimeView,
+  ) {
     const alive = pm.has(sessionKey) && !pm.get(sessionKey).closed;
+    const codex = isCodexRuntimeView(runtimeView);
     // Per-topic overrides win over chat-level for the displayed values,
     // mirroring the spawn path (polygram.js: topicConfig.agent ||
     // chatConfig.agent). Pre-fix the card always read chat-level, so a topic's
@@ -92,11 +288,36 @@ function createFormatConfigInfoText({ pm, db, getClaudeSessionId } = {}) {
     // "Agent: shumabit" instead of its music-curation:music-curator override
     // (2026-06-03). topicConfig defaults to null (chat-level) for callers with
     // no active topic.
-    const model = (topicConfig && topicConfig.model) || chatConfig.model;
-    const effort = (topicConfig && topicConfig.effort) || chatConfig.effort;
+    const model = configuredRuntimeValue(
+      chatConfig,
+      topicConfig,
+      runtimeView,
+      'model',
+    );
+    const effort = configuredRuntimeValue(
+      chatConfig,
+      topicConfig,
+      runtimeView,
+      'effort',
+    );
     const agent = (topicConfig && topicConfig.agent) || chatConfig.agent;
-    const ver = MODEL_VERSIONS_DESC[model] || model;
-    const sess = getClaudeSessionId(db, sessionKey)?.slice(0, 8) || 'new';
+    const codexModelEntry = codex
+      ? getCodexCatalogModels(runtimeView)
+        .find((entry) => entry.model === model)
+      : null;
+    const codexDisplayName = codexModelEntry?.displayName;
+    const ver = codex
+      ? (
+        typeof codexDisplayName === 'string'
+        && codexDisplayName.length > 0
+        && codexDisplayName !== model
+          ? codexDisplayName
+          : model
+      )
+      : MODEL_VERSIONS_DESC[model] || model;
+    const sess = codex
+      ? 'managed by Codex'
+      : getClaudeSessionId(db, sessionKey)?.slice(0, 8) || 'new';
     // Running vs configured: cli can't hot-swap model/effort, so a /model or
     // /effort change is PENDING until the session reloads (on the next message).
     // Show the truth — the live proc's spawn-time value (proc.model/proc.effort)
@@ -119,35 +340,169 @@ function createFormatConfigInfoText({ pm, db, getClaudeSessionId } = {}) {
     const richTextLine = richText
       ? 'Rich text: on (headings/tables/checklists on qualifying replies; agent authors for it once this session next (re)spawns)'
       : 'Rich text: off';
-    const head =
-      `${modelLine}\n` +
-      `${effortLine}\n` +
-      `${richTextLine}\n` +
-      `Agent: ${agent}\n` +
-      `Process: ${alive ? 'warm' : 'cold'}\n` +
-      `Session: ${sess}`;
-
-    const modelHelp = [
-      '',
-      '**Models**',
-      '🧠 **opus** — deep analysis, code refactor, multi-source reconciliation. ~5× sonnet cost.',
-      '🤖 **sonnet** — default. Most ops, code review, document summary.',
-      '⚡ **haiku** — quick simple tasks, classification, lookup.',
-    ].join('\n');
-
-    const effortHelp = [
-      '',
-      '**Effort** — ceiling on how much Claude can think. Simple questions get fast replies; hard ones spend more tokens. Safe to set higher — Claude scales down automatically when it doesn\'t need to think.',
-      '• **low** — fast replies, minimum reasoning. Casual chat, simple lookups.',
-      '• **medium** — balanced default. Fits most use cases.',
-      '• **high** — multi-step tasks. Audit, debug, multi-source analysis.',
-      '• **xhigh** / **max** — heaviest. Hard reasoning, edge cases.',
-    ].join('\n');
+    const identityLine = codex
+      ? 'Runtime: Codex app-server'
+      : `Agent: ${agent}`;
+    let head;
+    if (codex) {
+      const desired = runtimeView.desiredSettings ?? { model, effort };
+      const desiredPair = formatSettingsPair(desired) ?? `${model}/${effort}`;
+      const activePair = formatSettingsPair(runtimeView.activeTurnSettings);
+      const nextTurn = runtimeView.nextTurnSettings;
+      const nextTurnPair = formatSettingsPair(nextTurn);
+      const observedPair = formatSettingsPair(
+        runtimeView.observedThreadSettings,
+      );
+      const processStatus = runtimeView.processStatus
+        ?? (alive ? 'loaded' : 'not-loaded');
+      const settingsLines = [];
+      if (processStatus === 'loaded') {
+        if (activePair) {
+          settingsLines.push(`Current turn: ${activePair}`);
+          settingsLines.push(`Next turn: ${nextTurnPair ?? desiredPair}`);
+        } else {
+          settingsLines.push(
+            `Selected for next turn: ${nextTurnPair ?? desiredPair}`,
+          );
+        }
+        if (
+          nextTurnPair
+          && !sameSettingsPair(nextTurn, desired)
+        ) {
+          settingsLines.push(
+            `Saved selection awaiting live reconciliation: ${desiredPair}`,
+          );
+        }
+      } else if (processStatus === 'not-loaded') {
+        settingsLines.push(
+          `Selected for this chat's next session: ${desiredPair}`,
+        );
+      } else {
+        settingsLines.push(`Selected: ${desiredPair}`);
+      }
+      if (observedPair) {
+        settingsLines.push(`Observed thread: ${observedPair}`);
+      }
+      let processLine;
+      if (processStatus === 'daemon-busy') {
+        processLine = 'Process: not loaded; its next message may be busy';
+      } else if (processStatus === 'unavailable') {
+        processLine = 'Process: unavailable'
+          + (
+            runtimeView.unavailableReason
+              ? ` (${runtimeView.unavailableReason})`
+              : ''
+          );
+      } else if (processStatus === 'unknown') {
+        processLine = 'Process: live status unknown';
+      } else {
+        processLine = `Process: ${
+          processStatus === 'loaded' ? 'warm' : 'not loaded'
+        }`;
+      }
+      head = [
+        ...settingsLines,
+        richTextLine,
+        identityLine,
+        processLine,
+        `Session: ${sess}`,
+      ].join('\n');
+    } else {
+      head =
+        `${modelLine}\n` +
+        `${effortLine}\n` +
+        `${richTextLine}\n` +
+        `${identityLine}\n` +
+        `Process: ${alive ? 'warm' : 'cold'}\n` +
+        `Session: ${sess}`;
+    }
+
+    const modelHelp = codex
+      ? [
+        '',
+        '**Models**',
+        ...getCodexCatalogModels(runtimeView).map((entry) => {
+          const displayName = (
+            typeof entry.displayName === 'string'
+            && entry.displayName.length > 0
+            && entry.displayName !== entry.model
+          ) ? ` — ${entry.displayName}` : '';
+          return `• **${entry.model}**${displayName}`;
+        }),
+      ].join('\n')
+      : [
+        '',
+        '**Models**',
+        '🧠 **opus** — deep analysis, code refactor, multi-source reconciliation. ~1.7× sonnet cost.',
+        '🤖 **sonnet** — default. Most ops, code review, document summary.',
+        '⚡ **haiku** — quick simple tasks, classification, lookup.',
+      ].join('\n');
+
+    const effortHelp = codex
+      ? [
+        '',
+        `**Effort** — authenticated options for ${model}:`,
+        ...getCodexCatalogEfforts(runtimeView, model)
+          .map((value) => `• **${value}**`),
+        'Model and effort changes apply to the next turn; an active turn is unchanged.',
+      ].join('\n')
+      : [
+        '',
+        '**Effort** — ceiling on how much Claude can think. Simple questions get fast replies; hard ones spend more tokens. Safe to set higher — Claude scales down automatically when it doesn\'t need to think.',
+        '• **low** — fast replies, minimum reasoning. Casual chat, simple lookups.',
+        '• **medium** — balanced default. Fits most use cases.',
+        '• **high** — multi-step tasks. Audit, debug, multi-source analysis.',
+        '• **xhigh** / **max** — heaviest. Hard reasoning, edge cases.',
+      ].join('\n');
 
     let body = head;
+    if (codex) {
+      body += '\n\nNative macOS beta: command network and web search are disabled. '
+        + 'Product MCP tools and interactive approvals are unavailable. '
+        + 'Detached/background servers are unsupported and may survive hard runtime loss.';
+    }
     if (show === 'model' || show === 'all') body += '\n' + modelHelp;
     if (show === 'effort' || show === 'all') body += '\n' + effortHelp;
     return body;
+  }
+
+  return function formatConfigInfoText(
+    chatConfig,
+    show,
+    sessionKey,
+    topicConfig = null,
+    effectiveRichText,
+    runtimeView = null,
+  ) {
+    if (typeof resolveRuntimeView !== 'function' || runtimeView != null) {
+      return formatWithRuntimeView(
+        chatConfig,
+        show,
+        sessionKey,
+        topicConfig,
+        effectiveRichText,
+        runtimeView,
+      );
+    }
+    const separator = String(sessionKey).indexOf(':');
+    const chatId = separator < 0
+      ? String(sessionKey)
+      : String(sessionKey).slice(0, separator);
+    const threadId = separator < 0
+      ? null
+      : String(sessionKey).slice(separator + 1) || null;
+    return Promise.resolve(resolveRuntimeView({
+      sessionKey,
+      chatId,
+      threadId,
+    })).then((resolvedView) => formatWithRuntimeView(
+      chatConfig,
+      show,
+      sessionKey,
+      topicConfig,
+      effectiveRichText,
+      resolvedView,
+    ));
   };
 }
 
@@ -157,4 +512,11 @@ module.exports = {
   MODEL_OPTIONS,
   EFFORT_OPTIONS,
   MODEL_VERSIONS_DESC,
+  configuredRuntimeValue,
+  getCodexCatalogEfforts,
+  getCodexCatalogModels,
+  isCodexRuntimeView,
+  formatCodexSettingsOutcome,
+  resolveCodexEffortForModel,
+  withCodexSettingsOutcome,
 };

package/lib/handlers/dispatcher.js

@@ -23,6 +23,7 @@
 'use strict';
 
 const { createAuthDisabledGate } = require('../ops/auth-disabled-gate');
+const { normalizeFinalText } = require('../codex/event-normalizer');
 
 const CONCURRENT_WARN_THRESHOLD_DEFAULT = 20;
 
@@ -43,6 +44,7 @@ function createDispatcher({
   // Closures that polygram.js owns; passed in:
   handleMessage,                  // async (sessionKey, chatId, msg, bot)
   sendToProcess,                  // async (sessionKey, prompt, ctx)
+  recoverCodex,                   // async ({ sessionKey, chatId, msg, bot, providerRecovery })
   // Cross-cutting helpers:
   classifyError,                  // (err) → { kind, userMessage, isTransient, autoRecover }
   isAutoResumable,                // ({ error, aborted, replay, shuttingDown }) → boolean
@@ -90,20 +92,52 @@ function createDispatcher({
   // already torn down the wedged subprocess; getOrSpawnForChat creates
   // a new entry that picks up the saved session_id and sets
   // `--resume <id>` on the SDK Options.
-  async function attemptAutoResume(sessionKey, chatId, originalMsg, bot) {
+  async function attemptAutoResume(
+    sessionKey,
+    chatId,
+    originalMsg,
+    bot,
+    { provider = 'claude', providerRecovery = null } = {},
+  ) {
     const threadId = originalMsg.message_thread_id || null;
+    const isCodex = provider === 'codex';
 
     // 1. Tell the user we're auto-resuming so they don't think
     //    nothing happened. Threaded under their original message.
     await tg(bot, 'sendMessage', {
       chat_id: chatId,
-      text: '🔁 Auto-resuming after timeout — continuing where the previous turn left off.',
+      text: isCodex
+        ? '🔁 Retrying because the Codex request was proven not sent.'
+        : '🔁 Auto-resuming after timeout — continuing where the previous turn left off.',
       reply_parameters: { message_id: originalMsg.message_id },
       ...(threadId && { message_thread_id: threadId }),
     }, { source: 'auto-resume-indicator', botName }).catch((sendErr) => {
       logger.error?.(`[${sessionKey}] auto-resume indicator send failed: ${sendErr.message}`);
     });
 
+    if (isCodex) {
+      if (typeof recoverCodex !== 'function') {
+        const error = new Error('Exact Codex recovery path is unavailable');
+        error.code = 'CODEX_RECOVERY_UNAVAILABLE';
+        throw error;
+      }
+      const recovered = await recoverCodex({
+        sessionKey,
+        chatId,
+        msg: originalMsg,
+        bot,
+        providerRecovery,
+      });
+      if (recovered?.ok === false) {
+        const error = new Error(
+          recovered.reason || 'Exact Codex recovery was not dispatched',
+        );
+        error.code = 'CODEX_RECOVERY_NOT_DISPATCHED';
+        throw error;
+      }
+      return recovered;
+    }
+
     // 2. Continuation prompt. Plain text — the SDK Query resumes
     //    the saved session_id, so Claude has full prior transcript
     //    context including its own partially-streamed text and
@@ -139,7 +173,8 @@ function createDispatcher({
     if (result?.error) {
       throw new Error(`auto-resume turn errored: ${String(result.error).slice(0, 200)}`);
     }
-    if (!result?.text) {
+    const resultText = normalizeFinalText(result);
+    if (!resultText) {
       throw new Error('auto-resume turn produced no text');
     }
 
@@ -154,14 +189,14 @@ function createDispatcher({
     if (result.alreadyDelivered) {
       logEvent('auto-resume-already-delivered', {
         chat_id: chatId, session_key: sessionKey, msg_id: originalMsg.message_id,
-        text_len: result.text.length,
+        text_len: resultText.length,
       });
-      return result.text;
+      return resultText;
     }
 
     // Send the continuation reply as regular Telegram messages, threaded under
     // the original user message.
-    const chunks = chunkMarkdownText(result.text, chunkBudget);
+    const chunks = chunkMarkdownText(resultText, chunkBudget);
     await deliverReplies({
       bot,
       send: (b, method, params, m) => tg(b, method, params, m),
@@ -173,7 +208,7 @@ function createDispatcher({
       logger: { error: (m) => logger.error?.(`[${sessionKey}] auto-resume deliver: ${m}`) },
     });
 
-    return result.text;
+    return resultText;
   }
 
   function dispatchHandleMessage(sessionKey, chatId, msg, bot) {
@@ -323,6 +358,29 @@ function createDispatcher({
       //   - shutting down ("Process killed" isn't a real error),
       //   - user just /stop'd (already saw their abort ack).
       if (!wasAborted && !isReplay && !isShuttingDown) {
+        let providerRecovery = null;
+        if (typeof db.getReplayProviderRecovery === 'function') {
+          try {
+            providerRecovery = db.getReplayProviderRecovery({
+              sessionKey,
+              botName,
+              telegramChatId: String(chatId),
+              telegramMessageId: String(msg.message_id),
+            });
+          } catch (recoveryError) {
+            providerRecovery = {
+              provider: 'unknown',
+              reason: 'provider-recovery-unavailable',
+            };
+            logEvent('provider-recovery-unavailable', {
+              chat_id: chatId,
+              session_key: sessionKey,
+              msg_id: msg.message_id,
+              code: recoveryError?.code || recoveryError?.name || 'unknown',
+            });
+          }
+        }
+        const provider = providerRecovery?.provider;
         // Startup auto-retry (option a, 2026-06-04). TMUX_SESSION_GONE = claude
         // exited INSIDE the startup gate, before the dev-channels channel went
         // live — so the user's message was NEVER delivered to claude. That makes
@@ -360,6 +418,8 @@ function createDispatcher({
         const resumable = err.code !== 'SESSION_PROCESS_LOST'
           && isAutoResumable({
             error: err, aborted: wasAborted, replay: isReplay, shuttingDown: isShuttingDown,
+            provider,
+            providerRecovery,
           });
         if (resumable && !autoResumeTracker.isInCooldown(sessionKey)) {
           autoResumeTracker.markAttempt(sessionKey);
@@ -367,7 +427,10 @@ function createDispatcher({
             chat_id: chatId, session_key: sessionKey, msg_id: msg.message_id,
             original_error: err.message?.slice(0, 200),
           });
-          attemptAutoResume(sessionKey, chatId, msg, bot)
+          attemptAutoResume(sessionKey, chatId, msg, bot, {
+            provider,
+            providerRecovery,
+          })
             .then(() => {
               logEvent('auto-resume-success', {
                 chat_id: chatId, session_key: sessionKey, msg_id: msg.message_id,

package/lib/handlers/edit-correction.js

@@ -50,7 +50,17 @@ function createEditCorrectionInjector({
     //   2. session has a turn in flight
     //   3. the edited msg is still in the dispatched/processing pipeline
     if (!pm.has(sessionKey)) return false;
-    if (!pm.get(sessionKey)?.inFlight) return false;
+    const proc = pm.get(sessionKey);
+    if (!proc?.inFlight) return false;
+    const backend = typeof pm.getBackend === 'function'
+      ? pm.getBackend(sessionKey)
+      : proc.backend ?? proc.runtime;
+    // Codex steering is asynchronous and durability-aware. Its edit path
+    // defers a normal visible turn until the current generation is idle; this
+    // synchronous Claude-only injector cannot establish that ownership proof.
+    if (backend === 'codex' || proc.backend === 'codex' || proc.runtime === 'codex') {
+      return false;
+    }
     if (!db.isInboundLive({ chat_id: chatId, msg_id: editedMsg.message_id })) return false;
 
     const newText = editedMsg.text || editedMsg.caption || '';