talon-agent 1.12.0 → 1.34.0

package/src/backend/claude-sdk/stream.ts

@@ -12,11 +12,13 @@ import type {
   SDKPartialAssistantMessage,
   SDKAssistantMessage,
   SDKResultMessage,
+  SDKUserMessage,
   ModelUsage,
 } from "@anthropic-ai/claude-agent-sdk";
 import type { BetaRawContentBlockDeltaEvent } from "@anthropic-ai/sdk/resources/beta/messages/messages.mjs";
 import { STREAM_INTERVAL } from "./constants.js";
 import { log } from "../../util/log.js";
+import { checkModelDrift } from "./model-drift.js";
 
 // ── Stream state accumulator ────────────────────────────────────────────────
 
@@ -61,6 +63,29 @@ export type StreamState = {
    * may have appeared in the same assistant message before the terminator.
    */
   turnTerminated: boolean;
+  /**
+   * Per-token text chunks accumulated since the last throttled flush.
+   * Drained into a `text_delta` event when `processStreamDelta` decides
+   * the throttle interval has elapsed.
+   */
+  unflushedTextDelta: string;
+  /**
+   * Same as `unflushedTextDelta` but for thinking-phase tokens — drained
+   * into a `reasoning` event. Tracked separately so a thinking burst
+   * doesn't poison the visible-text delta buffer.
+   */
+  unflushedThinkingDelta: string;
+  /**
+   * Set when the SDK's final result message reported a failed turn —
+   * either an error subtype (`error_during_execution`, `error_max_turns`,
+   * …) or `is_error: true` on a `success` result. The latter is how API
+   * errors surface: the SDK converts them (usage limits, 429s, auth
+   * failures) into a synthetic assistant message and finishes the turn
+   * "successfully" with the error text in `result` — it never throws.
+   * Carries the best error text available so the handler can fail the
+   * turn with the REAL message instead of treating it as a normal reply.
+   */
+  resultErrorText: string | undefined;
 };
 
 export function createStreamState(): StreamState {
@@ -80,6 +105,9 @@ export function createStreamState(): StreamState {
     lastTrailingText: "",
     deliveredTextNorms: [],
     turnTerminated: false,
+    unflushedTextDelta: "",
+    unflushedThinkingDelta: "",
+    resultErrorText: undefined,
   };
 }
 
@@ -99,47 +127,75 @@ export function isAssistant(msg: SDKMessage): msg is SDKAssistantMessage {
   return msg.type === "assistant";
 }
 
+export function isUserMessage(msg: SDKMessage): msg is SDKUserMessage {
+  return msg.type === "user" && "message" in msg;
+}
+
 export function isResult(msg: SDKMessage): msg is SDKResultMessage {
   return msg.type === "result";
 }
 
 // ── Message processors ──────────────────────────────────────────────────────
 
+/** Output of `processStreamDelta` when the throttle interval has elapsed. */
+export type StreamDeltaEmit =
+  { phase: "text"; text: string } | { phase: "thinking"; text: string };
+
 /**
- * Process a streaming delta event — accumulates text and fires throttled
- * callbacks for thinking and text phases.
+ * Process a streaming delta event — accumulates per-token chunks
+ * into `state.currentBlockText` (text) / unflushed buffers, and
+ * returns the chunk to emit when the throttle interval has elapsed.
+ *
+ * Returns `null` when nothing should be emitted yet (either the delta
+ * wasn't a content-block-delta, or the throttle window is still open).
+ * Callers yield a `text_delta` / `reasoning` event with the returned
+ * `text`. The throttle keeps the event volume bounded — Telegram /
+ * terminal renderers re-accumulate, but at human-readable cadence.
  */
 export function processStreamDelta(
   msg: SDKPartialAssistantMessage,
   state: StreamState,
-  onStreamDelta?: (accumulated: string, phase?: "thinking" | "text") => void,
-): void {
-  if (!onStreamDelta) return;
-
+): StreamDeltaEmit | null {
   const event = msg.event;
-  if (event.type !== "content_block_delta") return;
+  if (event.type !== "content_block_delta") return null;
 
   const deltaEvent = event as BetaRawContentBlockDeltaEvent;
   const delta = deltaEvent.delta;
 
   if (delta.type === "thinking_delta") {
+    // The SDK's typed thinking_delta carries `.thinking`; treat
+    // missing/non-string defensively so a schema drift can't crash
+    // the loop.
+    const chunk =
+      typeof (delta as { thinking?: unknown }).thinking === "string"
+        ? (delta as { thinking: string }).thinking
+        : "";
+    if (chunk) state.unflushedThinkingDelta += chunk;
     const now = Date.now();
     if (now - state.lastStreamUpdate >= STREAM_INTERVAL) {
       state.lastStreamUpdate = now;
-      onStreamDelta(state.currentBlockText, "thinking");
+      const out = state.unflushedThinkingDelta;
+      state.unflushedThinkingDelta = "";
+      if (out.length > 0) return { phase: "thinking", text: out };
     }
   } else if (delta.type === "text_delta") {
     state.currentBlockText += delta.text;
+    state.unflushedTextDelta += delta.text;
     const now = Date.now();
     if (now - state.lastStreamUpdate >= STREAM_INTERVAL) {
       state.lastStreamUpdate = now;
-      onStreamDelta(state.currentBlockText, "text");
+      const out = state.unflushedTextDelta;
+      state.unflushedTextDelta = "";
+      if (out.length > 0) return { phase: "text", text: out };
     }
   }
+  return null;
 }
 
 /** A tool call extracted from an assistant message. */
 export type ToolCall = {
+  /** The SDK's tool_use block id — matches the later tool_result. */
+  id: string;
   name: string;
   input: Record<string, unknown>;
 };
@@ -181,7 +237,7 @@ export function processAssistantMessage(
         typeof block.input === "object" && block.input !== null
           ? (block.input as Record<string, unknown>)
           : {};
-      tools.push({ name: block.name, input });
+      tools.push({ id: block.id, name: block.name, input });
       // Text before this tool call is a progress message
       if (blockText.trim()) {
         progressTexts.push(blockText.trim());
@@ -201,6 +257,62 @@ export function processAssistantMessage(
   return { progressTexts, tools, trailingText };
 }
 
+/** One completed tool execution, extracted from an SDK user message. */
+export type ToolResultInfo = {
+  toolUseId: string;
+  /** Present when the tool failed — first ~500 chars of the error text. */
+  error?: string;
+};
+
+/**
+ * Extract tool results from an SDK user message. Tool executions come
+ * back as `tool_result` content blocks (keyed by `tool_use_id`) on
+ * synthetic user messages — the missing half of the tool lifecycle:
+ * without these, a UI that shows a spinner on `tool_call` never gets
+ * the event that stops it.
+ */
+export function extractToolResults(msg: SDKUserMessage): ToolResultInfo[] {
+  const content = msg.message?.content;
+  if (!Array.isArray(content)) return [];
+  const results: ToolResultInfo[] = [];
+  for (const block of content) {
+    if (
+      !block ||
+      typeof block !== "object" ||
+      (block as { type?: string }).type !== "tool_result"
+    ) {
+      continue;
+    }
+    const b = block as {
+      tool_use_id?: string;
+      is_error?: boolean;
+      content?: unknown;
+    };
+    if (typeof b.tool_use_id !== "string") continue;
+    let error: string | undefined;
+    if (b.is_error) {
+      const text =
+        typeof b.content === "string"
+          ? b.content
+          : Array.isArray(b.content)
+            ? b.content
+                .filter(
+                  (c): c is { type: "text"; text: string } =>
+                    !!c &&
+                    typeof c === "object" &&
+                    (c as { type?: string }).type === "text" &&
+                    typeof (c as { text?: unknown }).text === "string",
+                )
+                .map((c) => c.text)
+                .join("\n")
+            : "";
+      error = (text || "tool failed").slice(0, 500);
+    }
+    results.push({ toolUseId: b.tool_use_id, error });
+  }
+  return results;
+}
+
 /**
  * Process the final result message — extracts token counts, context info,
  * and API call counts from the typed SDK result.
@@ -227,6 +339,11 @@ export function processResultMessage(
   // and contains cumulative session totals per model — summing all entries
   // double-counts when switching models mid-session.
   const modelUsage: Record<string, ModelUsage> = msg.modelUsage;
+  // Drift check: modelUsage is keyed by the model that ACTUALLY served
+  // the turn. If none of the keys is (an alias of) the model we asked
+  // for, the API substituted — warn instead of burying it in the
+  // accounting line.
+  checkModelDrift(sdkModel, Object.keys(modelUsage ?? {}));
   const mu = modelUsage[sdkModel] ?? Object.values(modelUsage).at(-1);
   if (mu) {
     state.sdkInputTokens = mu.inputTokens ?? 0;
@@ -253,41 +370,32 @@ export function processResultMessage(
   ) {
     state.currentBlockText = msg.result;
   }
-}
-
-// ── Trailing-text fallback dedup ────────────────────────────────────────────
 
-/**
- * Normalize text for fuzzy comparison — trim, lowercase, collapse whitespace,
- * strip emoji. Used to detect whether trailing prose duplicates content
- * already delivered via `end_turn` / `send(type="text")`.
- */
-export function normalizeForDedupe(text: string): string {
-  return text
-    .trim()
-    .toLowerCase()
-    .replace(/\p{Emoji_Presentation}|\p{Extended_Pictographic}/gu, "")
-    .replace(/\s+/g, " ")
-    .trim();
+  // Failed turn. Two shapes (see StreamState.resultErrorText):
+  //  - error subtype: no `result` field, but `errors[]` carries diagnostics.
+  //  - success subtype with is_error: `result` (and the trailing assistant
+  //    text) IS the API error message, e.g. "You've hit your weekly limit
+  //    · resets Jul 10, 9am". Prefer that text — it's the user-facing one.
+  if (msg.subtype !== "success") {
+    const diagnostics = (msg.errors ?? [])
+      .filter((e) => typeof e === "string" && !e.startsWith("[ede_diagnostic]"))
+      .join("; ")
+      .slice(0, 500);
+    state.resultErrorText =
+      state.lastTrailingText.trim() ||
+      diagnostics ||
+      `Claude SDK turn failed (${msg.subtype})`;
+  } else if (msg.is_error) {
+    state.resultErrorText =
+      (typeof msg.result === "string" && msg.result.trim()) ||
+      state.lastTrailingText.trim() ||
+      "Claude SDK turn failed (API error)";
+  }
 }
 
-const MIN_DEDUP_LENGTH = 10;
-
-/**
- * Returns true if `candidate` is substantively the same as any text in
- * `deliveredNorms`. "Substantively" = one is a substring of the other after
- * normalization; both must be at least MIN_DEDUP_LENGTH chars to avoid
- * dropping short legitimate replies.
- */
-export function isDuplicateOfDelivered(
-  candidate: string,
-  deliveredNorms: string[],
-): boolean {
-  if (deliveredNorms.length === 0) return false;
-  const norm = normalizeForDedupe(candidate);
-  if (norm.length < MIN_DEDUP_LENGTH) return false;
-  return deliveredNorms.some(
-    (d) =>
-      d.length >= MIN_DEDUP_LENGTH && (norm.includes(d) || d.includes(norm)),
-  );
-}
+// ── Trailing-text fallback dedup ────────────────────────────────────────────
+// Re-export from shared so legacy imports do not grow a second implementation.
+export {
+  normalizeForDedupe,
+  isDuplicateOfDelivered,
+} from "../shared/delivered-text.js";

package/src/backend/claude-sdk/warm.ts

@@ -23,10 +23,18 @@ export async function warmSession(chatId: string): Promise<void> {
 
   const abort = new AbortController();
   try {
-    // Warm-up always rebuilds the system prompt (it's effectively a
-    // fresh session). `previousTurns: 0` triggers the rebuild branch.
-    prepareSystemPrompt({ config: getConfig(), previousTurns: 0 });
-    const { options } = buildSdkOptions(chatId);
+    // Snapshot the prompt under this chat's fresh session epoch. The
+    // first real turn finds the same snapshot (same epoch) and sends a
+    // byte-identical prompt — so the warm-up's cache write is actually
+    // reused instead of being invalidated by a re-timestamped rebuild.
+    const session = getSession(chatId);
+    const prepared = prepareSystemPrompt({
+      config: getConfig(),
+      previousTurns: session.turns,
+      chatId,
+      sessionEpoch: session.createdAt,
+    });
+    const { options } = buildSdkOptions(chatId, undefined, undefined, prepared);
 
     // Streaming input mode: pass an async iterable that never yields a user message
     const neverYield = async function* (): AsyncGenerator<never> {
@@ -69,7 +77,6 @@ export async function warmSession(chatId: string): Promise<void> {
     } finally {
       if (timeoutId !== undefined) clearTimeout(timeoutId);
     }
-    const session = getSession(chatId);
     if (ctx.maxTokens > 0) session.usage.contextWindow = ctx.maxTokens;
     if (ctx.totalTokens > 0) session.usage.contextTokens = ctx.totalTokens;
     log(

package/src/backend/codex/auth.ts

@@ -4,10 +4,11 @@
  * The Codex CLI supports two distinct authentication modes, with
  * materially different capabilities:
  *
- *   - **API key** (`OPENAI_API_KEY` env var, or `apiKey` passed to the
- *     SDK's `Codex` constructor, or `OPENAI_API_KEY` stored in
- *     `~/.codex/auth.json`). Full model catalog access, billed via the
- *     standard OpenAI API. `gpt-5-codex` is the flagship.
+ *   - **API key** (`CODEX_API_KEY` / `TALON_CODEX_KEY` env var,
+ *     `codexApiKey` passed to the SDK's `Codex` constructor, or
+ *     `OPENAI_API_KEY` stored in `~/.codex/auth.json`). Full model
+ *     catalog access, billed via the configured OpenAI-compatible API.
+ *     `gpt-5-codex` is the flagship on OpenAI's native endpoint.
  *
  *   - **ChatGPT OAuth** (`~/.codex/auth.json` `auth_mode: "chatgpt"`
  *     after running `codex login`). Restricted to a subset of models —
@@ -22,12 +23,21 @@
  *
  * Detection order (each step short-circuits if it succeeds):
  *
- *   1. `OPENAI_API_KEY` env var → `"api-key"`.
- *   2. `openaiApiKey` in Talon config → `"api-key"`.
- *   3. `~/.codex/auth.json` exists + `auth_mode` field is read → returns
+ *   1. `CODEX_API_KEY` env var → `"api-key"` (Codex CLI convention).
+ *   2. `TALON_CODEX_KEY` env var → `"api-key"` (Talon-scoped alias).
+ *   3. `codexApiKey` in Talon config → `"api-key"`.
+ *      Any Codex-specific API key is paired with `openaiBaseUrl` when
+ *      configured; the SDK maps that to Codex's `openai_base_url`
+ *      override.
+ *   4. `~/.codex/auth.json` exists + `auth_mode` field is read → returns
  *      that value (`"chatgpt"` for OAuth, `"api-key"` if the JSON also
  *      has a non-null `OPENAI_API_KEY`).
- *   4. Nothing → `"none"`. First turn will fail with an auth error;
+ *   5. `OPENAI_API_KEY` env var → `"api-key"` as a generic fallback.
+ *   6. `openaiApiKey` in Talon config → `"api-key"` as a legacy fallback.
+ *      These shared OpenAI credentials are deliberately after the Codex
+ *      auth file so other Talon backends can keep their credentials
+ *      without hijacking a logged-in Codex CLI.
+ *   7. Nothing → `"none"`. First turn will fail with an auth error;
  *      caller emits a startup warning pointing to `codex login`.
  */
 
@@ -37,55 +47,157 @@ import { join } from "node:path";
 /** Detected auth mode. */
 export type CodexAuthMode = "api-key" | "chatgpt" | "none";
 
+export type CodexApiKeySource =
+  | "env:CODEX_API_KEY"
+  | "env:TALON_CODEX_KEY"
+  | "config:codexApiKey"
+  | "env:OPENAI_API_KEY"
+  | "config:openaiApiKey";
+
 /** Resolved auth state plus diagnostics for the startup log. */
 export interface CodexAuthInfo {
   mode: CodexAuthMode;
   /** Where the credential was found, for logging. */
-  source:
-    | "env:OPENAI_API_KEY"
-    | "config:openaiApiKey"
-    | "file:~/.codex/auth.json"
-    | "missing";
+  source: CodexApiKeySource | "file:~/.codex/auth.json" | "missing";
+  /** API key to pass into the Codex SDK, when auth is explicit. */
+  apiKey?: string;
+  /** Base URL to pass into the Codex SDK alongside explicit API-key auth. */
+  baseUrl?: string;
   /** Path to the auth file when present (for diagnostics). */
   authFilePath?: string;
   /** Whether the auth file (if present) parsed correctly. */
   authFileParsed: boolean;
   /** Raw parse error when the file existed but couldn't be parsed. */
   parseError?: string;
+  /** Diagnostics about credential resolution. */
+  diagnostics: string[];
+}
+
+export interface DetectCodexAuthInput {
+  codexApiKey?: string;
+  openaiApiKey?: string;
+  openaiBaseUrl?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export function normalizeCodexBaseUrl(
+  baseUrl: string | undefined,
+): string | undefined {
+  const trimmed = baseUrl?.trim();
+  if (!trimmed) return undefined;
+  return trimmed;
+}
+
+function normalizeSecret(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) return undefined;
+  return trimmed;
+}
+
+export function resolveCodexApiKey(input: DetectCodexAuthInput): {
+  apiKey?: string;
+  baseUrl?: string;
+  source?: CodexApiKeySource;
+  diagnostics: string[];
+} {
+  const env = input.env ?? process.env;
+  const baseUrl = normalizeCodexBaseUrl(input.openaiBaseUrl);
+  const diagnostics: string[] = [];
+
+  const codexApiKeyEnv = normalizeSecret(env.CODEX_API_KEY);
+  if (codexApiKeyEnv) {
+    return {
+      apiKey: codexApiKeyEnv,
+      baseUrl,
+      source: "env:CODEX_API_KEY",
+      diagnostics,
+    };
+  }
+
+  const talonCodexKeyEnv = normalizeSecret(env.TALON_CODEX_KEY);
+  if (talonCodexKeyEnv) {
+    return {
+      apiKey: talonCodexKeyEnv,
+      baseUrl,
+      source: "env:TALON_CODEX_KEY",
+      diagnostics,
+    };
+  }
+
+  const configCodexApiKey = normalizeSecret(input.codexApiKey);
+  if (configCodexApiKey) {
+    return {
+      apiKey: configCodexApiKey,
+      baseUrl,
+      source: "config:codexApiKey",
+      diagnostics,
+    };
+  }
+
+  return { diagnostics };
+}
+
+function resolveGenericOpenAiApiKey(input: DetectCodexAuthInput): {
+  apiKey?: string;
+  baseUrl?: string;
+  source?: Extract<
+    CodexApiKeySource,
+    "env:OPENAI_API_KEY" | "config:openaiApiKey"
+  >;
+  diagnostics: string[];
+} {
+  const env = input.env ?? process.env;
+  const baseUrl = normalizeCodexBaseUrl(input.openaiBaseUrl);
+  const diagnostics: string[] = [];
+
+  const openAiApiKeyEnv = normalizeSecret(env.OPENAI_API_KEY);
+  if (openAiApiKeyEnv) {
+    return {
+      apiKey: openAiApiKeyEnv,
+      baseUrl,
+      source: "env:OPENAI_API_KEY",
+      diagnostics,
+    };
+  }
+
+  const configOpenAiApiKey = normalizeSecret(input.openaiApiKey);
+  if (configOpenAiApiKey) {
+    return {
+      apiKey: configOpenAiApiKey,
+      baseUrl,
+      source: "config:openaiApiKey",
+      diagnostics,
+    };
+  }
+
+  return { diagnostics };
 }
 
 /**
  * Detect the active Codex auth mode.
  *
- * `configKey` is the value of `config.openaiApiKey` from Talon's main
- * config — passed in by the caller so this module doesn't depend on
- * the config module. `envOverride` defaults to `process.env` so tests
- * can substitute a frozen env map.
+ * All config values are passed in by the caller so this module doesn't
+ * depend on the config module.
  */
 export function detectCodexAuth(
-  configKey?: string,
-  envOverride: NodeJS.ProcessEnv = process.env,
+  input: DetectCodexAuthInput = {},
 ): CodexAuthInfo {
-  // 1. Explicit API key in the environment.
-  if (envOverride.OPENAI_API_KEY) {
+  const env = input.env ?? process.env;
+  const explicitKey = resolveCodexApiKey(input);
+  if (explicitKey.apiKey && explicitKey.source) {
     return {
       mode: "api-key",
-      source: "env:OPENAI_API_KEY",
+      source: explicitKey.source,
+      apiKey: explicitKey.apiKey,
+      baseUrl: explicitKey.baseUrl,
       authFileParsed: false,
+      diagnostics: explicitKey.diagnostics,
     };
   }
 
-  // 2. Explicit API key in Talon's config.
-  if (configKey) {
-    return {
-      mode: "api-key",
-      source: "config:openaiApiKey",
-      authFileParsed: false,
-    };
-  }
-
-  // 3. Codex CLI auth file (created by `codex login`).
-  const home = envOverride.HOME ?? envOverride.USERPROFILE;
+  let authFileResult: CodexAuthInfo | null = null;
+  // Codex CLI auth file (created by `codex login`).
+  const home = env.HOME ?? env.USERPROFILE;
   if (home) {
     const authFilePath = join(home, ".codex", "auth.json");
     if (existsSync(authFilePath)) {
@@ -98,15 +210,18 @@ export function detectCodexAuth(
         // The auth.json schema includes `OPENAI_API_KEY` as a top-level
         // field even on ChatGPT-mode installs; when it's non-null it
         // takes precedence (mirrors what the CLI itself does).
-        if (
-          parsed.OPENAI_API_KEY &&
+        const fileApiKey =
           typeof parsed.OPENAI_API_KEY === "string"
-        ) {
+            ? normalizeSecret(parsed.OPENAI_API_KEY)
+            : undefined;
+        if (fileApiKey) {
           return {
             mode: "api-key",
             source: "file:~/.codex/auth.json",
+            apiKey: fileApiKey,
             authFilePath,
             authFileParsed: true,
+            diagnostics: explicitKey.diagnostics,
           };
         }
         if (parsed.auth_mode === "chatgpt") {
@@ -115,33 +230,53 @@ export function detectCodexAuth(
             source: "file:~/.codex/auth.json",
             authFilePath,
             authFileParsed: true,
+            diagnostics: explicitKey.diagnostics,
           };
         }
         // File parsed but doesn't carry a recognised mode — treat as
-        // missing so the caller surfaces a `codex login` reminder.
-        return {
+        // missing for now; generic OpenAI fallback may still be usable.
+        authFileResult = {
           mode: "none",
           source: "missing",
           authFilePath,
           authFileParsed: true,
+          diagnostics: explicitKey.diagnostics,
         };
       } catch (err) {
-        return {
+        authFileResult = {
           mode: "none",
           source: "missing",
           authFilePath,
           authFileParsed: false,
           parseError: err instanceof Error ? err.message : String(err),
+          diagnostics: explicitKey.diagnostics,
         };
       }
     }
   }
 
-  // 4. Nothing.
+  const genericKey = resolveGenericOpenAiApiKey(input);
+  if (genericKey.apiKey && genericKey.source) {
+    return {
+      mode: "api-key",
+      source: genericKey.source,
+      apiKey: genericKey.apiKey,
+      baseUrl: genericKey.baseUrl,
+      authFileParsed: authFileResult?.authFileParsed ?? false,
+      authFilePath: authFileResult?.authFilePath,
+      parseError: authFileResult?.parseError,
+      diagnostics: [...explicitKey.diagnostics, ...genericKey.diagnostics],
+    };
+  }
+
+  if (authFileResult) return authFileResult;
+
+  // Nothing.
   return {
     mode: "none",
     source: "missing",
     authFileParsed: false,
+    diagnostics: explicitKey.diagnostics,
   };
 }
 
@@ -163,3 +298,44 @@ export function isChatGptModelMismatchError(message: string): boolean {
     message,
   );
 }
+
+/**
+ * Detect the *silent* OAuth-incompat exit shape — the one that hit
+ * Pandario on 2026-05-20 at 23:13Z.
+ *
+ * On a free ChatGPT-OAuth credential the Codex CLI silently rejects
+ * most model strings (only `gpt-5.5` is verified working). Crucially,
+ * for some rejected models the CLI exits 1 *without* emitting a
+ * structured `error` or `turn.failed` event over the JSON stream, AND
+ * without writing the canonical
+ * `"not supported when using Codex with a ChatGPT account"` text to
+ * stderr. The only signal the SDK surfaces is:
+ *
+ *   `Codex Exec exited with code 1: Reading prompt from stdin...\n`
+ *
+ * (`"Reading prompt from stdin..."` is the CLI's startup banner — it
+ * always prints that and then exits before the prompt even reaches
+ * the model.)
+ *
+ * The detector heuristic:
+ *   - Error text contains `"Codex Exec exited"` (SDK's wrapper);
+ *   - Error text contains `"Reading prompt from stdin"` (CLI banner);
+ *   - Error text does NOT contain the explicit mismatch phrase (the
+ *     other detector handles that case).
+ *
+ * Callers MUST additionally check `authInfo.mode === "chatgpt"` and
+ * that the model isn't already the OAuth default before falling back —
+ * a silent exit-1 on api-key auth is a different bug class (network,
+ * config error, etc.) and shouldn't be misclassified.
+ *
+ * Case-insensitive; whitespace-tolerant. Matches both `code 1` and
+ * `code 2` (the CLI has been observed using both).
+ */
+export function isSilentOAuthExitError(message: string): boolean {
+  if (!message) return false;
+  if (isChatGptModelMismatchError(message)) return false;
+  return (
+    /Codex\s+Exec\s+exited\s+with\s+code\s+\d+/i.test(message) &&
+    /Reading\s+prompt\s+from\s+stdin/i.test(message)
+  );
+}