@steipete/oracle 0.12.0 → 0.12.1

package/dist/src/browser/actions/modelSelection.js

@@ -59,7 +59,7 @@ function assertResolvedModelSelection(desiredModel, resolvedLabel) {
     }
     if (!hasCurrentProSignal(resolved) ||
         hasLegacyProVersionLabel(resolved) ||
-        (resolved.includes("thinking") && !resolved.includes("pro"))) {
+        resolved.includes("thinking")) {
         throw new Error(`Model picker selected "${resolvedLabel}" while "${desiredModel}" requires GPT-5.5 Pro. Use model "gpt-5.5" with browser thinking time for the Thinking variant.`);
     }
 }
@@ -70,12 +70,7 @@ function normalizeResolvedModelLabel(value) {
         .trim();
 }
 function hasCurrentProSignal(resolved) {
-    return (resolved.includes(" pro") ||
-        resolved.endsWith("pro") ||
-        resolved.includes("pro ") ||
-        resolved.includes("extended") ||
-        resolved.includes("gpt-5.5-pro") ||
-        resolved.includes("gpt 5 5 pro"));
+    return normalizeResolvedModelLabel(resolved).split(" ").includes("pro");
 }
 function hasLegacyProVersionLabel(resolved) {
     const normalized = normalizeResolvedModelLabel(resolved);
@@ -128,6 +123,7 @@ function buildModelSelectionExpression(targetModel, strategy) {
         .replace(/\\s+/g, ' ')
         .trim();
     };
+    const hasToken = (value, token) => normalizeText(value).split(' ').includes(token);
     // Normalize every candidate token to keep fuzzy matching deterministic.
     const normalizedTarget = normalizeText(PRIMARY_LABEL);
     const normalizedTokens = Array.from(new Set([normalizedTarget, ...LABEL_TOKENS]))
@@ -173,7 +169,17 @@ function buildModelSelectionExpression(targetModel, strategy) {
       return false;
     };
     const hasProComposerPill = () => Boolean(
-      document.querySelector('button.__composer-pill, button[aria-label="Pro, click to remove"]')
+      Array.from(document.querySelectorAll('button.__composer-pill, button[aria-label]'))
+        .filter((node) => {
+          const label = normalizeText(node.getAttribute?.('aria-label') ?? '');
+          return node.matches?.('button.__composer-pill') || label.includes('click to remove');
+        })
+        .some((node) => {
+          const label = normalizeText(
+            (node.getAttribute?.('aria-label') ?? '') + ' ' + (node.textContent ?? '')
+          );
+          return hasToken(label, 'pro') && !hasToken(label, 'thinking');
+        })
     );
 
     const button = document.querySelector(BUTTON_SELECTOR);
@@ -209,7 +215,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
       const resolved = label || '';
       if (!wantsPro || !hasProComposerPill()) return resolved;
       const normalized = normalizeText(resolved);
-      if (!normalized || normalized.includes('pro')) return resolved;
+      if (!normalized) return resolved;
+      if (normalized.includes('thinking')) return 'Pro';
+      if (normalized.includes('pro')) return resolved;
       return resolved + ' + Pro';
     };
     const getResolvedLabel = (fallback) =>
@@ -225,7 +233,15 @@ function buildModelSelectionExpression(targetModel, strategy) {
       const normalizedLabel = normalizeText(getButtonLabel());
       if (!normalizedLabel) return false;
       if (isTargetGpt55VisibleAlias(normalizedLabel)) return true;
-      if (wantsPro && normalizedLabel === 'chatgpt' && hasProComposerPill()) {
+      if (
+        wantsPro &&
+        hasProComposerPill() &&
+        (normalizedLabel === 'chatgpt' ||
+          normalizedLabel === 'extended' ||
+          normalizedLabel === 'standard' ||
+          normalizedLabel === 'heavy' ||
+          normalizedLabel === 'light')
+      ) {
         return true;
       }
       if (desiredVersion) {

package/dist/src/browser/actions/promptComposer.js

@@ -183,6 +183,7 @@ export async function submitPrompt(deps, prompt, logger) {
     else {
         logger("Clicked send button");
     }
+    await deps.onPromptSubmitted?.();
     const commitTimeoutMs = Math.max(60_000, deps.inputTimeoutMs ?? 0);
     // Learned: the send button can succeed but the turn doesn't appear immediately; verify commit via turns/stop button.
     return await verifyPromptCommitted(runtime, prompt, commitTimeoutMs, logger, deps.baselineTurns ?? undefined);

package/dist/src/browser/actions/thinkingTime.js

@@ -11,9 +11,11 @@ import { buildClickDispatcher } from "./domEvents.js";
  *
  * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
  */
-export async function ensureThinkingTime(Runtime, level, logger) {
-    const result = await evaluateThinkingTimeSelection(Runtime, level);
+export async function ensureThinkingTime(Runtime, level, logger, desiredModel) {
+    const result = await evaluateThinkingTimeSelection(Runtime, level, desiredModel);
     const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
+    const targetModelKind = inferThinkingTargetModelKind(desiredModel);
+    const strictProEffort = targetModelKind === "pro" && level === "extended";
     switch (result?.status) {
         case "already-selected":
             logger(`Thinking time: ${result.label ?? capitalizedLevel} (already selected)`);
@@ -23,13 +25,26 @@ export async function ensureThinkingTime(Runtime, level, logger) {
             return;
         case "chip-not-found":
         case "menu-not-found":
-        case "option-not-found": {
+        case "option-not-found":
+        case "model-kind-not-found": {
             await logDomFailure(Runtime, logger, `thinking-${result.status}`);
-            logger(`Thinking time: ${result.status.replaceAll("-", " ")} (requested ${capitalizedLevel}); continuing with ChatGPT default.`);
+            const kindHint = result.status === "model-kind-not-found" && result.modelKind
+                ? ` for ${result.modelKind}`
+                : targetModelKind
+                    ? ` for ${targetModelKind}`
+                    : "";
+            const message = `Thinking time: ${result.status.replaceAll("-", " ")}${kindHint} (requested ${capitalizedLevel})`;
+            if (strictProEffort) {
+                throw new Error(`${message}; refusing to submit without confirmed Pro Extended.`);
+            }
+            logger(`${message}; continuing with ChatGPT default.`);
             return;
         }
         default: {
             await logDomFailure(Runtime, logger, "thinking-time-unknown");
+            if (strictProEffort) {
+                throw new Error(`Thinking time: unknown outcome selecting ${capitalizedLevel}; refusing to submit without confirmed Pro Extended.`);
+            }
             logger(`Thinking time: unknown outcome selecting ${capitalizedLevel}; continuing with ChatGPT default.`);
             return;
         }
@@ -40,9 +55,9 @@ export async function ensureThinkingTime(Runtime, level, logger) {
  * Safe by default: if the pill/menu/option isn't present, we continue without throwing.
  * @param level - The thinking time intensity: 'light', 'standard', 'extended', or 'heavy'
  */
-export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
+export async function ensureThinkingTimeIfAvailable(Runtime, level, logger, desiredModel) {
     try {
-        const result = await evaluateThinkingTimeSelection(Runtime, level);
+        const result = await evaluateThinkingTimeSelection(Runtime, level, desiredModel);
         const capitalizedLevel = level.charAt(0).toUpperCase() + level.slice(1);
         switch (result?.status) {
             case "already-selected":
@@ -54,6 +69,7 @@ export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
             case "chip-not-found":
             case "menu-not-found":
             case "option-not-found":
+            case "model-kind-not-found":
                 if (logger.verbose) {
                     logger(`Thinking time: ${result.status.replaceAll("-", " ")}; continuing with default.`);
                 }
@@ -74,19 +90,20 @@ export async function ensureThinkingTimeIfAvailable(Runtime, level, logger) {
         return false;
     }
 }
-async function evaluateThinkingTimeSelection(Runtime, level) {
+async function evaluateThinkingTimeSelection(Runtime, level, desiredModel) {
     const outcome = await Runtime.evaluate({
-        expression: buildThinkingTimeExpression(level),
+        expression: buildThinkingTimeExpression(level, desiredModel),
         awaitPromise: true,
         returnByValue: true,
     });
     return outcome.result?.value;
 }
-function buildThinkingTimeExpression(level) {
+function buildThinkingTimeExpression(level, desiredModel) {
     const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
     const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
     const modelButtonLiteral = JSON.stringify(MODEL_BUTTON_SELECTOR);
     const targetLevelLiteral = JSON.stringify(level.toLowerCase());
+    const targetModelKindLiteral = JSON.stringify(inferThinkingTargetModelKind(desiredModel));
     return `(async () => {
     ${buildClickDispatcher()}
 
@@ -94,6 +111,7 @@ function buildThinkingTimeExpression(level) {
     const MENU_ITEM_SELECTOR = ${menuItemLiteral};
     const MODEL_BUTTON_SELECTOR = ${modelButtonLiteral};
     const TARGET_LEVEL = ${targetLevelLiteral};
+    const TARGET_MODEL_KIND = ${targetModelKindLiteral};
 
     // Bilingual matchers: English level token + observed Chinese variants.
     const LEVEL_TOKENS = {
@@ -119,6 +137,7 @@ function buildThinkingTimeExpression(level) {
       const t = normalize(text);
       return targetTokens.some((tok) => t.includes(String(tok).toLowerCase()));
     };
+    const hasToken = (text, token) => normalize(text).split(' ').includes(token);
     const optionIsSelected = (node) => {
       if (!(node instanceof HTMLElement)) return false;
       const ariaChecked = node.getAttribute('aria-checked');
@@ -207,6 +226,7 @@ function buildThinkingTimeExpression(level) {
 
     const findModelButton = () => document.querySelector(MODEL_BUTTON_SELECTOR);
     const findTrailingButtons = () => Array.from(document.querySelectorAll(TRAILING_SELECTOR));
+    const KIND_NOT_FOUND = { kindNotFound: true };
     const findEffortRow = (node) => {
       let current = node instanceof HTMLElement ? node.parentElement : null;
       while (current && current !== document.body) {
@@ -227,6 +247,58 @@ function buildThinkingTimeExpression(level) {
         ),
       );
     };
+    const rowForTrailing = (trailing) =>
+      trailing.closest('[role="menuitem"], [role="menuitemradio"], [data-radix-collection-item]');
+    const rowTextForTrailing = (trailing) => {
+      const row = rowForTrailing(trailing) || findEffortRow(trailing);
+      return normalize(
+        (row?.getAttribute?.('aria-label') ?? '') + ' ' +
+        (row?.getAttribute?.('data-testid') ?? '') + ' ' +
+        (row?.textContent ?? '') + ' ' +
+        (trailing.getAttribute?.('aria-label') ?? '') + ' ' +
+        (trailing.getAttribute?.('data-testid') ?? '')
+      );
+    };
+    const testIdTextForTrailing = (trailing) => {
+      const row = rowForTrailing(trailing) || findEffortRow(trailing);
+      return normalize(
+        (row?.getAttribute?.('data-testid') ?? '') + ' ' +
+        (trailing.getAttribute?.('data-testid') ?? '')
+      );
+    };
+    const modelKindFromTrailing = (trailing) => {
+      const idText = testIdTextForTrailing(trailing);
+      if (!idText.includes('model switcher')) return null;
+      const modelPart = normalize(idText.replace(/\\bthinking effort\\b.*$/, ''));
+      if (hasToken(modelPart, 'pro')) return 'pro';
+      if (hasToken(modelPart, 'thinking')) return 'thinking';
+      if (hasToken(modelPart, 'instant')) return 'instant';
+      return null;
+    };
+    const trailingMatchesTargetModelKind = (trailing) => {
+      if (!TARGET_MODEL_KIND) return false;
+      const idKind = modelKindFromTrailing(trailing);
+      if (idKind) return idKind === TARGET_MODEL_KIND;
+      const text = rowTextForTrailing(trailing);
+      if (TARGET_MODEL_KIND === 'pro') {
+        return hasToken(text, 'pro') && !hasToken(text, 'thinking');
+      }
+      if (TARGET_MODEL_KIND === 'thinking') {
+        return hasToken(text, 'thinking') && !hasToken(text, 'pro');
+      }
+      if (TARGET_MODEL_KIND === 'instant') {
+        return hasToken(text, 'instant') && !hasToken(text, 'thinking') && !hasToken(text, 'pro');
+      }
+      return false;
+    };
+    const hasStableBox = (node) => {
+      const r = node.getBoundingClientRect?.();
+      return Boolean(r && r.width > 0 && r.height > 0 && node.getAttribute?.('aria-hidden') !== 'true');
+    };
+    const pickSingleStableTrailing = (trailings) => {
+      const visible = trailings.filter((t) => hasStableBox(t));
+      return visible.length === 1 ? visible[0] : null;
+    };
     const pickTrailingForCurrentModel = () => {
       const trailings = findTrailingButtons();
       if (trailings.length === 0) return null;
@@ -236,6 +308,10 @@ function buildThinkingTimeExpression(level) {
         const row = findEffortRow(t);
         if (rowIsSelected(row)) return t;
       }
+      if (TARGET_MODEL_KIND) {
+        const targetTrailings = trailings.filter((t) => trailingMatchesTargetModelKind(t));
+        return pickSingleStableTrailing(targetTrailings) || KIND_NOT_FOUND;
+      }
       return null;
     };
 
@@ -243,7 +319,6 @@ function buildThinkingTimeExpression(level) {
     if (!modelBtn) {
       return { status: 'chip-not-found' };
     }
-
     // Open model menu (idempotent — leaves it open if already open).
     if (modelBtn.getAttribute('aria-expanded') !== 'true') {
       dispatchClickSequence(modelBtn);
@@ -261,6 +336,10 @@ function buildThinkingTimeExpression(level) {
       closeOpenMenus();
       return { status: 'chip-not-found' };
     }
+    if (trailing.kindNotFound) {
+      closeOpenMenus();
+      return { status: 'model-kind-not-found', modelKind: TARGET_MODEL_KIND };
+    }
 
     dispatchClickSequence(trailing);
     await sleep(STEP_WAIT_MS);
@@ -313,6 +392,26 @@ function buildThinkingTimeExpression(level) {
     return { status: already ? 'already-selected' : 'switched', label };
   })()`;
 }
-export function buildThinkingTimeExpressionForTest(level = "extended") {
-    return buildThinkingTimeExpression(level);
+export function buildThinkingTimeExpressionForTest(level = "extended", desiredModel) {
+    return buildThinkingTimeExpression(level, desiredModel);
+}
+function inferThinkingTargetModelKind(desiredModel) {
+    const normalized = (desiredModel ?? "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized)
+        return null;
+    const tokens = normalized.split(" ");
+    if (tokens.includes("pro"))
+        return "pro";
+    if (tokens.includes("thinking"))
+        return "thinking";
+    if (tokens.includes("instant"))
+        return "instant";
+    return null;
+}
+export function inferThinkingTargetModelKindForTest(desiredModel) {
+    return inferThinkingTargetModelKind(desiredModel);
 }

package/dist/src/browser/index.js

@@ -327,6 +327,7 @@ export async function runBrowserMode(options) {
     const runtimeHintCb = options.runtimeHintCb;
     let lastTargetId;
     let lastUrl;
+    let promptSubmitted = false;
     let tabLease = null;
     const emitRuntimeHint = async () => {
         if (!chrome?.port) {
@@ -340,6 +341,7 @@ export async function runBrowserMode(options) {
             chromeTargetId: lastTargetId,
             tabUrl: lastUrl,
             conversationId,
+            promptSubmitted,
             userDataDir,
             controllerPid: process.pid,
         };
@@ -357,6 +359,13 @@ export async function runBrowserMode(options) {
             logger(`Failed to persist runtime hint: ${message}`);
         }
     };
+    const markPromptSubmitted = async () => {
+        if (promptSubmitted) {
+            return;
+        }
+        promptSubmitted = true;
+        await emitRuntimeHint();
+    };
     if (config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") {
         logger(`[browser-mode] config: ${JSON.stringify({
             ...redactBrowserConfigForDebugLog(config),
@@ -725,7 +734,8 @@ export async function runBrowserMode(options) {
         // Handle thinking time selection if specified. Deep Research owns its own effort flow.
         const thinkingTime = config.thinkingTime;
         if (thinkingTime && !deepResearch) {
-            await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
+            const thinkingTargetModel = modelStrategy === "select" ? config.desiredModel : null;
+            await raceWithDisconnect(withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger, thinkingTargetModel), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
@@ -803,6 +813,7 @@ export async function runBrowserMode(options) {
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
                 baselineTurns: baselineTurns ?? undefined,
                 attachmentNames,
+                onPromptSubmitted: markPromptSubmitted,
             };
             await runProviderSubmissionFlow(chatgptDomProvider, {
                 prompt,
@@ -811,6 +822,7 @@ export async function runBrowserMode(options) {
                 log: logger,
                 state: providerState,
             });
+            await markPromptSubmitted();
             const providerBaselineTurns = providerState.baselineTurns;
             if (typeof providerBaselineTurns === "number" && Number.isFinite(providerBaselineTurns)) {
                 baselineTurns = providerBaselineTurns;
@@ -912,6 +924,7 @@ export async function runBrowserMode(options) {
                 chromeTargetId: lastTargetId,
                 tabUrl: lastUrl,
                 conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                promptSubmitted,
                 controllerPid: process.pid,
             };
         }
@@ -996,6 +1009,7 @@ export async function runBrowserMode(options) {
                         chromeTargetId: lastTargetId,
                         tabUrl: lastUrl,
                         conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                        promptSubmitted,
                         controllerPid: process.pid,
                     },
                 });
@@ -1051,6 +1065,7 @@ export async function runBrowserMode(options) {
                             chromeTargetId: lastTargetId,
                             tabUrl: lastUrl,
                             conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                            promptSubmitted,
                             controllerPid: process.pid,
                         };
                         throw new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime, diagnostics }, error);
@@ -1298,6 +1313,7 @@ export async function runBrowserMode(options) {
             chromeTargetId: lastTargetId,
             tabUrl: lastUrl,
             conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+            promptSubmitted,
             controllerPid: process.pid,
         };
     }
@@ -1315,6 +1331,7 @@ export async function runBrowserMode(options) {
                 userDataDir,
                 chromeTargetId: lastTargetId,
                 tabUrl: lastUrl,
+                promptSubmitted,
                 controllerPid: process.pid,
             };
             const reuseProfileHint = `oracle --engine browser --browser-manual-login ` +
@@ -1355,6 +1372,7 @@ export async function runBrowserMode(options) {
                 userDataDir,
                 chromeTargetId: lastTargetId,
                 tabUrl: lastUrl,
+                promptSubmitted,
                 controllerPid: process.pid,
             },
         }, normalizedError);
@@ -1703,6 +1721,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     let remoteTargetId = null;
     let tabLease = null;
     let lastUrl;
+    let promptSubmitted = false;
     let attachedExistingTab = false;
     let ownsTarget = true;
     const runtimeHintCb = options.runtimeHintCb;
@@ -1718,6 +1737,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 chromeTargetId: remoteTargetId ?? undefined,
                 tabUrl: lastUrl,
                 conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                promptSubmitted,
                 controllerPid: process.pid,
             });
             await tabLease?.update({
@@ -1732,6 +1752,13 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             logger(`Failed to persist runtime hint: ${message}`);
         }
     };
+    const markPromptSubmitted = async () => {
+        if (promptSubmitted) {
+            return;
+        }
+        promptSubmitted = true;
+        await emitRuntimeHint();
+    };
     const startedAt = Date.now();
     let answerText = "";
     let answerMarkdown = "";
@@ -1848,7 +1875,8 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         // Handle thinking time selection if specified. Deep Research owns its own effort flow.
         const thinkingTime = config.thinkingTime;
         if (thinkingTime && !deepResearch) {
-            await withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger), {
+            const thinkingTargetModel = modelStrategy === "select" ? config.desiredModel : null;
+            await withRetries(() => ensureThinkingTime(Runtime, thinkingTime, logger, thinkingTargetModel), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
@@ -1904,6 +1932,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 inputTimeoutMs: config.inputTimeoutMs ?? undefined,
                 baselineTurns: baselineTurns ?? undefined,
                 attachmentNames,
+                onPromptSubmitted: markPromptSubmitted,
             };
             await runProviderSubmissionFlow(chatgptDomProvider, {
                 prompt,
@@ -1912,6 +1941,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 log: logger,
                 state: providerState,
             });
+            await markPromptSubmitted();
             const providerBaselineTurns = providerState.baselineTurns;
             if (typeof providerBaselineTurns === "number" && Number.isFinite(providerBaselineTurns)) {
                 baselineTurns = providerBaselineTurns;
@@ -1985,6 +2015,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 chromeTargetId: remoteTargetId ?? undefined,
                 tabUrl: lastUrl,
                 conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                promptSubmitted,
                 controllerPid: process.pid,
             };
         }
@@ -2068,6 +2099,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                         chromeTargetId: remoteTargetId ?? undefined,
                         tabUrl: lastUrl,
                         conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                        promptSubmitted,
                         controllerPid: process.pid,
                     },
                 });
@@ -2136,6 +2168,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                             chromeTargetId: remoteTargetId ?? undefined,
                             tabUrl: lastUrl,
                             conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                            promptSubmitted,
                             controllerPid: process.pid,
                         };
                         throw new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime, diagnostics }, error);
@@ -2338,6 +2371,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             chromeTargetId: remoteTargetId ?? undefined,
             tabUrl: lastUrl,
             conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+            promptSubmitted,
             artifacts: savedArtifacts,
             archive,
             modelSelection: modelSelectionEvidence,
@@ -2364,6 +2398,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 chromeProfileRoot,
                 chromeTargetId: remoteTargetId ?? undefined,
                 tabUrl: lastUrl,
+                promptSubmitted,
                 controllerPid: process.pid,
             },
         });

package/dist/src/browser/providers/chatgptDomProvider.js

@@ -23,6 +23,7 @@ async function submitPromptViaAdapter(ctx) {
         attachmentNames: state.attachmentNames ?? [],
         baselineTurns: state.baselineTurns ?? undefined,
         inputTimeoutMs: state.inputTimeoutMs ?? undefined,
+        onPromptSubmitted: state.onPromptSubmitted,
     }, ctx.prompt, state.logger);
     state.committedTurns =
         typeof committedTurns === "number" && Number.isFinite(committedTurns) ? committedTurns : null;

package/dist/src/browser/reattachability.js

@@ -0,0 +1,22 @@
+export function hasRecoverableChatGptConversation(runtime) {
+    if (!runtime) {
+        return false;
+    }
+    if (runtime.conversationId?.trim()) {
+        return true;
+    }
+    const tabUrl = runtime.tabUrl?.trim();
+    if (!tabUrl) {
+        return false;
+    }
+    try {
+        const url = new URL(tabUrl);
+        if (url.hostname !== "chatgpt.com" && url.hostname !== "chat.openai.com") {
+            return false;
+        }
+        return /(?:^|\/)c\/[^/]+/.test(url.pathname);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/browser/sessionRunner.js

@@ -214,6 +214,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             chromeTargetId: browserResult.chromeTargetId,
             tabUrl: browserResult.tabUrl,
             conversationId: browserResult.conversationId,
+            promptSubmitted: browserResult.promptSubmitted,
             controllerPid: browserResult.controllerPid ?? process.pid,
         },
         archive: browserResult.archive,

package/dist/src/cli/sessionDisplay.js

@@ -6,6 +6,7 @@ import { formatFinishLine } from "../oracle/finishLine.js";
 import { sessionStore, wait } from "../sessionStore.js";
 import { formatTokenCount, formatTokenValue } from "../oracle/runUtils.js";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "../browser/artifacts.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatSessionTableHeader, formatSessionTableRow, resolveSessionCost, } from "./sessionTable.js";
@@ -174,9 +175,16 @@ export async function attachSession(sessionId, options) {
         hasFallbackSessionInfo &&
         isDeepResearchPlaceholderCapture(metadata, await sessionStore.readLog(sessionId).catch(() => ""));
     const completedDeepResearchPlaceholder = metadata.status === "completed" && deepResearchPlaceholderCapture;
+    const hasRecoverableConversation = hasRecoverableChatGptConversation(runtime);
+    const hasLiveChromeFallback = Boolean((metadata.status === "running" || hasIncompleteCapture || completedDeepResearchPlaceholder) &&
+        (runtime?.chromePort || runtime?.chromeBrowserWSEndpoint || runtime?.chromeProfileRoot));
     const canReattach = (statusAllowsReattach || completedDeepResearchPlaceholder) &&
         metadata.mode === "browser" &&
         hasFallbackSessionInfo &&
+        (hasRecoverableConversation ||
+            runtime?.promptSubmitted ||
+            hasLiveChromeFallback ||
+            completedDeepResearchPlaceholder) &&
         (hasChromeDisconnect ||
             hasIncompleteCapture ||
             completedDeepResearchPlaceholder ||

package/dist/src/cli/sessionRunner.js

@@ -21,6 +21,7 @@ import { sanitizeOscProgress } from "./oscUtils.js";
 import { readFiles } from "../oracle/files.js";
 import { cwd as getCwd } from "node:process";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatElapsed } from "../oracle/format.js";
 const isTty = process.stdout.isTTY;
@@ -390,6 +391,40 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         if (connectionLost && mode === "browser") {
             const runtime = userError.details
                 ?.runtime;
+            const recoverableRuntime = runtime ?? sessionMeta.browser?.runtime;
+            if (!hasRecoverableChatGptConversation(recoverableRuntime) &&
+                recoverableRuntime?.promptSubmitted !== true) {
+                log(dim("Chrome disconnected before a ChatGPT conversation was created; marking session error."));
+                if (modelForStatus) {
+                    await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                        status: "error",
+                        completedAt: new Date().toISOString(),
+                        response: { status: "error", incompleteReason: "chrome-disconnected" },
+                        error: {
+                            category: userError.category,
+                            message: userError.message,
+                            details: userError.details,
+                        },
+                    });
+                }
+                await sessionStore.updateSession(sessionMeta.id, {
+                    status: "error",
+                    completedAt: new Date().toISOString(),
+                    errorMessage: message,
+                    mode,
+                    browser: {
+                        config: browserConfig,
+                        runtime: recoverableRuntime,
+                    },
+                    response: { status: "error", incompleteReason: "chrome-disconnected" },
+                    error: {
+                        category: userError.category,
+                        message: userError.message,
+                        details: userError.details,
+                    },
+                });
+                throw error;
+            }
             log(dim("Chrome disconnected before completion; keeping session running for reattach."));
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
@@ -576,13 +611,22 @@ function sanitizeMultiModelFailureForThrow(error, context) {
     if (!(error instanceof Error)) {
         return new Error(message);
     }
-    error.message = message;
+    let sanitized;
+    if (error instanceof OracleTransportError) {
+        sanitized = new OracleTransportError(error.reason, message);
+    }
+    else if (error instanceof OracleResponseError) {
+        sanitized = new OracleResponseError(message, error.response);
+    }
+    else {
+        sanitized = new Error(message);
+        sanitized.name = error.name;
+    }
     if (error.stack) {
-        const [firstLine, ...rest] = error.stack.split("\n");
-        const prefix = firstLine.includes(":") ? firstLine.split(":", 1)[0] : error.name;
-        error.stack = [prefix ? `${prefix}: ${message}` : message, ...rest].join("\n");
+        const [, ...rest] = error.stack.split("\n");
+        sanitized.stack = [sanitized.name ? `${sanitized.name}: ${message}` : message, ...rest].join("\n");
     }
-    return error;
+    return sanitized;
 }
 export function deriveOutputManifestPath(basePath) {
     const ext = path.extname(basePath);

package/dist/src/oracle/providerRoutePlan.js

@@ -8,7 +8,14 @@ const DEFAULT_PROVIDER_HOSTS = {
     openai: "api.openai.com",
     xai: "api.x.ai",
 };
+export function resolveProviderRoute(input) {
+    return buildResolvedProviderRoute(input);
+}
 export function buildProviderRoutePlan(input) {
+    const { apiKey: _apiKey, baseUrl: _baseUrl, nativeProvider: _nativeProvider, openRouterFallback: _openRouterFallback, azureEndpoint: _azureEndpoint, ...plan } = buildResolvedProviderRoute(input);
+    return plan;
+}
+function buildResolvedProviderRoute(input) {
     const env = input.env ?? process.env;
     const providerMode = input.providerMode ?? "auto";
     const azureConfigured = Boolean(input.azure?.endpoint?.trim());
@@ -49,7 +56,12 @@ export function buildProviderRoutePlan(input) {
             keySource: key.source,
             keyPreview: key.preview,
             keyPresent: key.present,
+            apiKey: key.value,
+            nativeProvider: provider,
+            baseUrl: input.baseUrl,
+            openRouterFallback: false,
             isAzureOpenAI,
+            azureEndpoint: state?.azureEndpoint ?? input.azure?.endpoint,
             azureConfigured,
             azureDeploymentName: state?.azureDeploymentName,
             azureNote: azureNote(providerMode, azureConfigured, isAzureOpenAI),
@@ -145,7 +157,12 @@ export function buildProviderRoutePlan(input) {
         keySource: key.source,
         keyPreview: key.preview,
         keyPresent: key.present,
+        apiKey: key.value,
+        nativeProvider: provider,
+        baseUrl,
+        openRouterFallback,
         isAzureOpenAI,
+        azureEndpoint: state.azureEndpoint,
         azureConfigured,
         azureDeploymentName: state.azureDeploymentName,
         azureNote: azureNote(providerMode, azureConfigured, isAzureOpenAI),
@@ -166,7 +183,12 @@ function getNativeKey({ model, provider, providerMode, isAzureOpenAI, apiKey, en
 }
 function getKeyForRoute({ model, provider, providerMode, isAzureOpenAI, baseUrl, openRouterFallback, apiKey, env, }) {
     if (apiKey) {
-        return { source: "apiKey option", preview: maskApiKey(apiKey) ?? "set", present: true };
+        return {
+            source: "apiKey option",
+            preview: maskApiKey(apiKey) ?? "set",
+            present: true,
+            value: apiKey,
+        };
     }
     if (isAzureOpenAI) {
         return readKey(["AZURE_OPENAI_API_KEY", "OPENAI_API_KEY"], env);
@@ -201,7 +223,12 @@ function readKey(names, env) {
     for (const name of names) {
         const value = env[name]?.trim();
         if (value) {
-            return { source: name, preview: `${name}=${maskApiKey(value) ?? "set"}`, present: true };
+            return {
+                source: name,
+                preview: `${name}=${maskApiKey(value) ?? "set"}`,
+                present: true,
+                value,
+            };
         }
     }
     return { source: names.join("|"), preview: "missing", present: false };

package/dist/src/oracle/run.js

@@ -14,7 +14,7 @@ import { getFileTokenStats, printFileTokenStats } from "./tokenStats.js";
 import { OracleResponseError, OracleTransportError, PromptValidationError, describeTransportError, toTransportError, } from "./errors.js";
 import { isCustomBaseUrl } from "./baseUrl.js";
 import { createDefaultClientFactory } from "./client.js";
-import { formatBaseUrlForLog, maskApiKey } from "./logging.js";
+import { maskApiKey } from "./logging.js";
 import { startHeartbeat } from "../heartbeat.js";
 import { startOscProgress } from "./oscProgress.js";
 import { createFsAdapter } from "./fsAdapter.js";
@@ -25,60 +25,49 @@ import { createMarkdownStreamer } from "markdansi";
 import { executeBackgroundResponse } from "./background.js";
 import { formatTokenEstimate, formatTokenValue, resolvePreviewMode } from "./runUtils.js";
 import { estimateUsdCost } from "tokentally";
-import { defaultOpenRouterBaseUrl, isOpenRouterBaseUrl, isProModel, resolveModelConfig, normalizeOpenRouterBaseUrl, } from "./modelResolver.js";
+import { isOpenRouterBaseUrl, isProModel, resolveModelConfig } from "./modelResolver.js";
 import { validateProviderRouting } from "./providerRouting.js";
+import { formatRouteTargetForLog, resolveProviderRoute, } from "./providerRoutePlan.js";
 const isStdoutTty = process.stdout.isTTY && chalk.level > 0;
 const dim = (text) => (isStdoutTty ? kleur.dim(text) : text);
 // Default timeout for non-pro API runs (fast models) — give them up to 120s.
 const DEFAULT_TIMEOUT_NON_PRO_MS = 120_000;
 const DEFAULT_TIMEOUT_PRO_MS = 60 * 60 * 1000;
-const DEFAULT_PROVIDER_HOSTS = {
-    anthropic: "api.anthropic.com",
-    google: "generativelanguage.googleapis.com",
-    openai: "api.openai.com",
-    xai: "api.x.ai",
-};
 const defaultWait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
-function formatRouteTargetForLog(raw, fallbackHost = "") {
-    if (!raw)
-        return fallbackHost;
-    try {
-        const parsed = new URL(raw);
-        const segments = parsed.pathname.split("/").filter(Boolean);
-        let path = "";
-        if (segments.length > 0) {
-            path = `/${segments[0]}`;
-            if (segments.length > 1) {
-                path += "/...";
-            }
-        }
-        return `${parsed.host}${path}`;
-    }
-    catch {
-        const formatted = formatBaseUrlForLog(raw).replace(/^https?:\/\//u, "");
-        return formatted || fallbackHost;
+function formatProviderRouteLogLine(route, keySource) {
+    if (route.isAzureOpenAI) {
+        return `Provider: Azure OpenAI | endpoint: ${formatRouteTargetForLog(route.azureEndpoint)} | deployment: ${route.azureDeploymentName || "none"} | key: ${keySource}`;
     }
+    return `Provider: ${route.providerLabel} | base: ${route.base} | key: ${keySource}`;
 }
-function formatProviderRouteLogLine({ provider, baseUrl, openRouterFallback, isAzureOpenAI, azureEndpoint, azureDeploymentName, envVar, }) {
-    if (isAzureOpenAI) {
-        return `Provider: Azure OpenAI | endpoint: ${formatRouteTargetForLog(azureEndpoint)} | deployment: ${azureDeploymentName || "none"} | key: ${envVar}`;
+function runtimeKeySource({ route, providerMode, optionsApiKey, }) {
+    if (optionsApiKey &&
+        (route.isAzureOpenAI ||
+            providerMode === "openai" ||
+            route.provider === "openai" ||
+            route.providerLabel === "OpenAI-compatible")) {
+        return "apiKey option";
     }
-    const isOpenRouter = isOpenRouterBaseUrl(baseUrl) || openRouterFallback;
-    const routeProvider = isOpenRouter
-        ? "OpenRouter"
-        : baseUrl && isCustomBaseUrl(baseUrl)
-            ? "OpenAI-compatible"
-            : provider === "anthropic"
-                ? "Anthropic"
-                : provider === "google"
-                    ? "Google Gemini"
-                    : provider === "xai"
-                        ? "xAI"
-                        : "OpenAI";
-    const fallbackHost = DEFAULT_PROVIDER_HOSTS[provider] ?? DEFAULT_PROVIDER_HOSTS.openai;
-    return `Provider: ${routeProvider} | base: ${formatRouteTargetForLog(baseUrl, fallbackHost)} | key: ${envVar}`;
+    if (route.isAzureOpenAI) {
+        return "AZURE_OPENAI_API_KEY|OPENAI_API_KEY";
+    }
+    if (providerMode === "openai") {
+        return "OPENAI_API_KEY";
+    }
+    if (isOpenRouterBaseUrl(route.baseUrl) || route.openRouterFallback || route.model.includes("/")) {
+        return "OPENROUTER_API_KEY";
+    }
+    if (route.model.startsWith("gpt"))
+        return "OPENAI_API_KEY";
+    if (route.model.startsWith("gemini"))
+        return "GEMINI_API_KEY";
+    if (route.model.startsWith("claude"))
+        return "ANTHROPIC_API_KEY";
+    if (route.model.startsWith("grok"))
+        return "XAI_API_KEY";
+    return optionsApiKey ? "apiKey option" : route.keySource;
 }
 export async function runOracle(options, deps = {}) {
     const { apiKey: optionsApiKey = options.apiKey, cwd = process.cwd(), fs: fsModule = createFsAdapter(fs), log = console.log, write: sinkWrite = (_text) => true, allowStdout = true, stdoutWrite: stdoutWriteDep, now = () => performance.now(), clientFactory = createDefaultClientFactory(), client, wait = defaultWait, } = deps;
@@ -86,13 +75,10 @@ export async function runOracle(options, deps = {}) {
         ? (stdoutWriteDep ?? process.stdout.write.bind(process.stdout))
         : () => true;
     const isTty = allowStdout && isStdoutTty;
-    const resolvedXaiBaseUrl = process.env.XAI_BASE_URL?.trim() || "https://api.x.ai/v1";
-    const openRouterApiKey = process.env.OPENROUTER_API_KEY?.trim();
-    const defaultOpenRouterBase = defaultOpenRouterBaseUrl();
     const previewMode = resolvePreviewMode(options.previewMode ?? options.preview);
     const isPreview = Boolean(previewMode);
     const providerMode = options.provider ?? "auto";
-    const routing = validateProviderRouting({
+    validateProviderRouting({
         model: options.model,
         providerMode,
         azure: options.azure,
@@ -103,99 +89,23 @@ export async function runOracle(options, deps = {}) {
             }
         },
     });
-    const { provider, isAzureOpenAI, azureEndpoint, azureDeploymentName } = routing;
-    const hasOpenAIKey = Boolean(optionsApiKey) ||
-        Boolean(process.env.OPENAI_API_KEY) ||
-        Boolean(providerMode !== "openai" && process.env.AZURE_OPENAI_API_KEY && options.azure?.endpoint);
-    const hasAnthropicKey = Boolean(optionsApiKey) || Boolean(process.env.ANTHROPIC_API_KEY);
-    const hasGeminiKey = Boolean(optionsApiKey) || Boolean(process.env.GEMINI_API_KEY);
-    const hasXaiKey = Boolean(optionsApiKey) || Boolean(process.env.XAI_API_KEY);
-    let baseUrl = options.baseUrl?.trim();
-    const providerQualifiedOpenRouterCandidate = !isAzureOpenAI && providerMode !== "openai" && options.model.includes("/");
-    if (baseUrl &&
-        providerQualifiedOpenRouterCandidate &&
-        !isOpenRouterBaseUrl(baseUrl) &&
-        !isCustomBaseUrl(baseUrl)) {
-        baseUrl = undefined;
-    }
-    if (!baseUrl) {
-        let envBaseUrl;
-        if (options.model.startsWith("grok")) {
-            envBaseUrl = resolvedXaiBaseUrl;
-        }
-        else if (provider === "anthropic") {
-            envBaseUrl = process.env.ANTHROPIC_BASE_URL?.trim();
-        }
-        else {
-            envBaseUrl = process.env.OPENAI_BASE_URL?.trim();
-        }
-        if (!providerQualifiedOpenRouterCandidate || (envBaseUrl && isCustomBaseUrl(envBaseUrl))) {
-            baseUrl = envBaseUrl;
-        }
-    }
-    const providerKeyMissing = !isAzureOpenAI &&
-        (providerMode === "openai"
-            ? !hasOpenAIKey
-            : (provider === "openai" && !hasOpenAIKey) ||
-                (provider === "anthropic" && !hasAnthropicKey) ||
-                (provider === "google" && !hasGeminiKey) ||
-                (provider === "xai" && !hasXaiKey) ||
-                provider === "other");
-    const providerQualifiedOpenRouterRoute = providerQualifiedOpenRouterCandidate && !baseUrl;
-    const openRouterFallback = !baseUrl &&
-        (providerQualifiedOpenRouterRoute ||
-            (providerMode !== "openai" &&
-                providerKeyMissing &&
-                (provider === "other" || Boolean(openRouterApiKey))));
-    if (!baseUrl || openRouterFallback) {
-        if (openRouterFallback) {
-            baseUrl = defaultOpenRouterBase;
-        }
-    }
-    if (baseUrl && isOpenRouterBaseUrl(baseUrl)) {
-        baseUrl = normalizeOpenRouterBaseUrl(baseUrl);
-    }
+    const route = resolveProviderRoute({
+        model: options.model,
+        providerMode,
+        azure: options.azure,
+        baseUrl: options.baseUrl,
+        apiKey: optionsApiKey,
+        env: process.env,
+    });
+    const { isAzureOpenAI, azureDeploymentName } = route;
+    const baseUrl = route.baseUrl;
+    const openRouterFallback = route.openRouterFallback;
     const logVerbose = (message) => {
         if (options.verbose) {
             log(dim(`[verbose] ${message}`));
         }
     };
-    const getApiKeyForModel = (model) => {
-        if (isAzureOpenAI) {
-            if (optionsApiKey)
-                return { key: optionsApiKey, source: "apiKey option" };
-            const key = process.env.AZURE_OPENAI_API_KEY ?? process.env.OPENAI_API_KEY;
-            return { key, source: "AZURE_OPENAI_API_KEY|OPENAI_API_KEY" };
-        }
-        if (providerMode === "openai") {
-            if (optionsApiKey)
-                return { key: optionsApiKey, source: "apiKey option" };
-            return { key: process.env.OPENAI_API_KEY, source: "OPENAI_API_KEY" };
-        }
-        if (isOpenRouterBaseUrl(baseUrl) || openRouterFallback) {
-            return { key: optionsApiKey ?? openRouterApiKey, source: "OPENROUTER_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("gpt")) {
-            if (optionsApiKey)
-                return { key: optionsApiKey, source: "apiKey option" };
-            return { key: process.env.OPENAI_API_KEY, source: "OPENAI_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("gemini")) {
-            return { key: optionsApiKey ?? process.env.GEMINI_API_KEY, source: "GEMINI_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("claude")) {
-            return { key: optionsApiKey ?? process.env.ANTHROPIC_API_KEY, source: "ANTHROPIC_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("grok")) {
-            return { key: optionsApiKey ?? process.env.XAI_API_KEY, source: "XAI_API_KEY" };
-        }
-        return {
-            key: optionsApiKey ?? openRouterApiKey,
-            source: optionsApiKey ? "apiKey option" : "OPENROUTER_API_KEY",
-        };
-    };
-    const apiKeyResult = getApiKeyForModel(options.model);
-    const apiKey = apiKeyResult.key;
+    const apiKey = route.apiKey;
     if (!apiKey) {
         const envVar = isAzureOpenAI
             ? "AZURE_OPENAI_API_KEY (or OPENAI_API_KEY)"
@@ -203,15 +113,7 @@ export async function runOracle(options, deps = {}) {
                 ? "OPENAI_API_KEY"
                 : isOpenRouterBaseUrl(baseUrl) || openRouterFallback
                     ? "OPENROUTER_API_KEY"
-                    : options.model.startsWith("gpt")
-                        ? "OPENAI_API_KEY"
-                        : options.model.startsWith("gemini")
-                            ? "GEMINI_API_KEY"
-                            : options.model.startsWith("claude")
-                                ? "ANTHROPIC_API_KEY"
-                                : options.model.startsWith("grok")
-                                    ? "XAI_API_KEY"
-                                    : "OPENROUTER_API_KEY";
+                    : route.keySource;
         const browserModeHint = options.model.startsWith("gpt")
             ? ' If you have a ChatGPT Pro subscription, retry with --engine browser (or MCP engine:"browser" / preset:"chatgpt-pro-heavy"); browser mode uses your signed-in ChatGPT session instead of an API key.'
             : "";
@@ -219,7 +121,7 @@ export async function runOracle(options, deps = {}) {
             env: envVar,
         });
     }
-    const envVar = apiKeyResult.source;
+    const envVar = runtimeKeySource({ route, providerMode, optionsApiKey });
     const minPromptLength = Number.parseInt(process.env.ORACLE_MIN_PROMPT_CHARS ?? "10", 10);
     const promptLength = options.prompt?.trim().length ?? 0;
     // Enforce the short-prompt guardrail on pro-tier models because they're costly; cheaper models can run short prompts without blocking.
@@ -227,7 +129,7 @@ export async function runOracle(options, deps = {}) {
     if (isProTierModel && !Number.isNaN(minPromptLength) && promptLength < minPromptLength) {
         throw new PromptValidationError(`Prompt is too short (<${minPromptLength} chars). This was likely accidental; please provide more detail.`, { minPromptLength, promptLength });
     }
-    const resolverOpenRouterApiKey = openRouterFallback || isOpenRouterBaseUrl(baseUrl) ? (openRouterApiKey ?? apiKey) : undefined;
+    const resolverOpenRouterApiKey = openRouterFallback || isOpenRouterBaseUrl(baseUrl) ? apiKey : undefined;
     const modelConfig = await resolveModelConfig(options.model, {
         baseUrl,
         openRouterApiKey: resolverOpenRouterApiKey,
@@ -326,15 +228,7 @@ export async function runOracle(options, deps = {}) {
     if (!isPreview) {
         if (!options.suppressHeader) {
             log(headerLine);
-            log(dim(formatProviderRouteLogLine({
-                provider,
-                baseUrl,
-                openRouterFallback,
-                isAzureOpenAI,
-                azureEndpoint,
-                azureDeploymentName,
-                envVar,
-            })));
+            log(dim(formatProviderRouteLogLine(route, envVar)));
         }
         const maskedKey = maskApiKey(apiKey);
         if (maskedKey && options.verbose) {
@@ -409,7 +303,7 @@ export async function runOracle(options, deps = {}) {
             : proxyCompatibleBaseUrl
                 ? proxyCompatibleBaseUrl
                 : modelConfig.model.startsWith("claude")
-                    ? (process.env.ANTHROPIC_BASE_URL ?? baseUrl)
+                    ? baseUrl
                     : baseUrl;
     const clientInstance = client ??
         clientFactory(apiKey, {

package/dist/src/sessionManager.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import fs from "node:fs/promises";
-import { createWriteStream } from "node:fs";
+import { createWriteStream, mkdirSync } from "node:fs";
 import net from "node:net";
 import { DEFAULT_MODEL } from "./oracle/config.js";
 import { formatElapsed } from "./oracle/format.js";
@@ -86,14 +86,26 @@ async function fileExists(targetPath) {
         return false;
     }
 }
-async function ensureUniqueSessionId(baseSlug) {
+function isFileExistsError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+async function reserveUniqueSessionDir(baseSlug) {
     let candidate = baseSlug;
     let suffix = 2;
-    while (await fileExists(sessionDir(candidate))) {
+    for (;;) {
+        const dir = sessionDir(candidate);
+        try {
+            await fs.mkdir(dir, { recursive: false });
+            return candidate;
+        }
+        catch (error) {
+            if (!isFileExistsError(error)) {
+                throw error;
+            }
+        }
         candidate = `${baseSlug}-${suffix}`;
         suffix += 1;
     }
-    return candidate;
 }
 async function listModelRunFiles(sessionId) {
     const dir = modelsDir(sessionId);
@@ -153,9 +165,7 @@ export async function readModelRunMetadata(sessionId, model) {
 export async function initializeSession(options, cwd, notifications, baseSlugOverride) {
     await ensureSessionStorage();
     const baseSlug = baseSlugOverride || createSessionId(options.prompt || DEFAULT_SLUG, options.slug);
-    const sessionId = await ensureUniqueSessionId(baseSlug);
-    const dir = sessionDir(sessionId);
-    await ensureDir(dir);
+    const sessionId = await reserveUniqueSessionDir(baseSlug);
     const mode = options.mode ?? "api";
     const browserConfig = options.browserConfig;
     const modelList = Array.isArray(options.models) && options.models.length > 0
@@ -239,25 +249,25 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
     return metadata;
 }
 export async function readSessionMetadata(sessionId) {
-    const modern = await readModernSessionMetadata(sessionId);
+    const modern = await readModernSessionMetadata(sessionId, { reconcile: true, persist: false });
     if (modern) {
         return modern;
     }
-    const legacy = await readLegacySessionMetadata(sessionId);
+    const legacy = await readLegacySessionMetadata(sessionId, { reconcile: true, persist: false });
     if (legacy) {
         return legacy;
     }
     return null;
 }
 export async function updateSessionMetadata(sessionId, updates) {
-    const existing = (await readModernSessionMetadata(sessionId)) ??
-        (await readLegacySessionMetadata(sessionId)) ??
+    const existing = (await readModernSessionMetadata(sessionId, { reconcile: false, persist: false })) ??
+        (await readLegacySessionMetadata(sessionId, { reconcile: false, persist: false })) ??
         { id: sessionId };
     const next = { ...existing, ...updates };
     await fs.writeFile(metaPath(sessionId), JSON.stringify(next, null, 2), "utf8");
     return next;
 }
-async function readModernSessionMetadata(sessionId) {
+async function readModernSessionMetadata(sessionId, options) {
     try {
         const raw = await fs.readFile(metaPath(sessionId), "utf8");
         const parsed = JSON.parse(raw);
@@ -265,25 +275,31 @@ async function readModernSessionMetadata(sessionId) {
             return null;
         }
         const enriched = await attachModelRuns(parsed, sessionId);
-        const runtimeChecked = await markDeadBrowser(enriched, { persist: false });
-        return await markZombie(runtimeChecked, { persist: false });
+        return options.reconcile ? reconcileSessionMetadata(enriched, options) : enriched;
     }
     catch {
         return null;
     }
 }
-async function readLegacySessionMetadata(sessionId) {
+async function readLegacySessionMetadata(sessionId, options) {
     try {
         const raw = await fs.readFile(legacySessionPath(sessionId), "utf8");
         const parsed = JSON.parse(raw);
         const enriched = await attachModelRuns(parsed, sessionId);
-        const runtimeChecked = await markDeadBrowser(enriched, { persist: false });
-        return await markZombie(runtimeChecked, { persist: false });
+        return options.reconcile ? reconcileSessionMetadata(enriched, options) : enriched;
     }
     catch {
         return null;
     }
 }
+async function readRawSessionMetadata(sessionId) {
+    return ((await readModernSessionMetadata(sessionId, { reconcile: false, persist: false })) ??
+        (await readLegacySessionMetadata(sessionId, { reconcile: false, persist: false })));
+}
+async function reconcileSessionMetadata(meta, { persist }) {
+    const runtimeChecked = await markDeadBrowser(meta, { persist });
+    return await markZombie(runtimeChecked, { persist });
+}
 function isSessionMetadataRecord(value) {
     return Boolean(value && typeof value.id === "string" && value.status);
 }
@@ -297,7 +313,7 @@ async function attachModelRuns(meta, sessionId) {
 export function createSessionLogWriter(sessionId, model) {
     const targetPath = model ? modelLogPath(sessionId, model) : logPath(sessionId);
     if (model) {
-        void ensureDir(modelsDir(sessionId));
+        mkdirSync(modelsDir(sessionId), { recursive: true });
     }
     const stream = createWriteStream(targetPath, { flags: "a" });
     const logLine = (line = "") => {
@@ -314,10 +330,10 @@ export async function listSessionsMetadata() {
     const entries = await fs.readdir(getSessionsDir()).catch(() => []);
     const metas = [];
     for (const entry of entries) {
-        let meta = await readSessionMetadata(entry);
+        let meta = await readRawSessionMetadata(entry);
         if (meta) {
-            meta = await markDeadBrowser(meta, { persist: true });
-            meta = await markZombie(meta, { persist: true }); // keep stored metadata consistent with zombie detection
+            // Keep stored metadata consistent with status reconciliation done by `oracle status`.
+            meta = await reconcileSessionMetadata(meta, { persist: true });
             metas.push(meta);
         }
     }
@@ -388,7 +404,7 @@ export async function readModelLog(sessionId, model) {
     }
 }
 export async function readSessionRequest(sessionId) {
-    const modern = await readModernSessionMetadata(sessionId);
+    const modern = await readModernSessionMetadata(sessionId, { reconcile: false, persist: false });
     if (modern?.options) {
         return modern.options;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.5 Pro, GPT-5.5, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
   "homepage": "https://github.com/steipete/oracle#readme",
@@ -46,7 +46,7 @@
     "test": "vitest run",
     "test:mcp": "pnpm run build && pnpm run test:mcp:unit && pnpm run test:mcp:mcporter",
     "test:mcp:unit": "vitest run tests/mcp*.test.ts tests/mcp/**/*.test.ts",
-    "test:mcp:mcporter": "pnpm dlx mcporter list oracle-local --schema --config config/mcporter.json && pnpm dlx mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
+    "test:mcp:mcporter": "CHROME_DEVTOOLS_URL=http://127.0.0.1:0 pnpm dlx mcporter list oracle-local --schema --config config/mcporter.json && CHROME_DEVTOOLS_URL=http://127.0.0.1:0 pnpm dlx mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
     "test:browser": "pnpm run build && tsx scripts/test-browser.ts && ./scripts/browser-smoke.sh",
     "test:packed-cli": "node scripts/packed-cli-smoke.mjs",
     "test:live": "ORACLE_LIVE_TEST=1 vitest run tests/live --exclude tests/live/openai-live.test.ts",
@@ -61,7 +61,7 @@
     "@google/genai": "^2.0.1",
     "@google/generative-ai": "^0.24.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@steipete/sweet-cookie": "^0.2.0",
+    "@steipete/sweet-cookie": "^0.3.0",
     "chalk": "^5.6.2",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.34.0",
@@ -70,11 +70,11 @@
     "dotenv": "^17.4.2",
     "fast-glob": "^3.3.3",
     "gpt-tokenizer": "^3.4.0",
-    "inquirer": "13.4.2",
+    "inquirer": "13.4.3",
     "json5": "^2.2.3",
     "kleur": "^4.1.5",
     "markdansi": "0.2.1",
-    "openai": "^6.35.0",
+    "openai": "^6.38.0",
     "osc-progress": "^0.3.0",
     "qs": "^6.15.1",
     "shiki": "^4.0.2",
@@ -84,17 +84,17 @@
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@types/chrome-remote-interface": "^0.33.0",
+    "@types/chrome-remote-interface": "^0.34.0",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.6.0",
-    "@typescript/native-preview": "7.0.0-dev.20260508.1",
-    "@vitest/coverage-v8": "4.1.5",
-    "devtools-protocol": "0.0.1627472",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1",
+    "@vitest/coverage-v8": "4.1.6",
+    "devtools-protocol": "0.0.1629771",
     "es-toolkit": "^1.46.1",
     "esbuild": "^0.28.0",
-    "oxfmt": "0.48.0",
+    "oxfmt": "0.50.0",
     "oxlint": "^1.62.0",
-    "puppeteer-core": "^24.42.0",
+    "puppeteer-core": "^25.0.2",
     "tsx": "^4.21.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"
@@ -113,7 +113,8 @@
   "packageManager": "pnpm@10.33.2",
   "pnpm": {
     "overrides": {
-      "devtools-protocol": "0.0.1627472"
+      "devtools-protocol": "0.0.1629771",
+      "vite": "7.3.2"
     },
     "onlyBuiltDependencies": [
       "esbuild"