@steipete/oracle 0.11.1 → 0.12.0

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

@@ -1,6 +1,8 @@
 import { COMPOSER_MODEL_SIGNAL_SELECTOR, MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR, MODEL_BUTTON_SELECTOR, } from "../constants.js";
 import { logDomFailure } from "../domDebug.js";
 import { buildClickDispatcher } from "./domEvents.js";
+const LEGACY_PRO_VERSION_WORD_TOKENS = ["5 4", "5 2", "5 1", "5 0", "gpt 5 pro"];
+const LEGACY_PRO_VERSION_COMPACT_TOKENS = ["gpt54", "gpt52", "gpt51", "gpt50"];
 export async function ensureModelSelection(Runtime, desiredModel, logger, strategy = "select") {
     const outcome = await Runtime.evaluate({
         expression: buildModelSelectionExpression(desiredModel, strategy),
@@ -17,7 +19,15 @@ export async function ensureModelSelection(Runtime, desiredModel, logger, strate
                 assertResolvedModelSelection(desiredModel, label);
             }
             logger(`Model picker: ${label}`);
-            return;
+            return {
+                requestedModel: desiredModel,
+                resolvedLabel: label,
+                strategy,
+                status: result.status,
+                verified: strategy !== "current",
+                source: "chatgpt-model-picker",
+                capturedAt: new Date().toISOString(),
+            };
         }
         case "option-not-found": {
             await logDomFailure(Runtime, logger, "model-switcher-option");
@@ -38,22 +48,39 @@ export async function ensureModelSelection(Runtime, desiredModel, logger, strate
 function assertResolvedModelSelection(desiredModel, resolvedLabel) {
     const desired = desiredModel.toLowerCase();
     const resolved = resolvedLabel.toLowerCase();
-    const wantsGpt55Pro = desired === "gpt-5.5-pro" ||
+    const wantsGpt55Pro = desired === "pro" ||
+        desired === "chatgpt pro" ||
+        desired === "gpt-5.5-pro" ||
         desired.includes("5.5 pro") ||
         desired.includes("5-5 pro") ||
         (desired.includes("pro") && desired.includes("extended"));
     if (!wantsGpt55Pro || !resolved) {
         return;
     }
-    const hasProSignal = resolved.includes(" pro") ||
+    if (!hasCurrentProSignal(resolved) ||
+        hasLegacyProVersionLabel(resolved) ||
+        (resolved.includes("thinking") && !resolved.includes("pro"))) {
+        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.`);
+    }
+}
+function normalizeResolvedModelLabel(value) {
+    return value
+        .replace(/[^a-z0-9]+/g, " ")
+        .replace(/\s+/g, " ")
+        .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");
-    if (!hasProSignal || (resolved.includes("thinking") && !resolved.includes("pro"))) {
-        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.`);
-    }
+        resolved.includes("gpt 5 5 pro"));
+}
+function hasLegacyProVersionLabel(resolved) {
+    const normalized = normalizeResolvedModelLabel(resolved);
+    return (LEGACY_PRO_VERSION_WORD_TOKENS.some((token) => normalized.includes(token)) ||
+        LEGACY_PRO_VERSION_COMPACT_TOKENS.some((token) => resolved.includes(token)));
 }
 export function assertResolvedModelSelectionForTest(desiredModel, resolvedLabel) {
     assertResolvedModelSelection(desiredModel, resolvedLabel);
@@ -121,8 +148,16 @@ function buildModelSelectionExpression(targetModel, strategy) {
     const wantsPro = normalizedTarget.includes(' pro') || normalizedTarget.endsWith(' pro') || normalizedTokens.includes('pro');
     const wantsInstant = normalizedTarget.includes('instant');
     const wantsThinking = normalizedTarget.includes('thinking');
+    const targetUsesCurrentGpt55Alias =
+      desiredVersion === '5-5' || normalizedTarget === 'pro' || normalizedTarget === 'chatgpt pro';
+    const labelHasProWord = (label) => label === 'pro' || label.startsWith('pro ') || label.includes(' pro ') || label.endsWith(' pro');
+    const legacyProVersionTokens = ['5 4', '5 2', '5 1', '5 0', 'gpt54', 'gpt52', 'gpt51', 'gpt50', 'gpt 5 pro'];
+    const labelHasLegacyProVersion = (value) => {
+      const label = normalizeText(value);
+      return legacyProVersionTokens.some((token) => label.includes(token));
+    };
     const isTargetGpt55VisibleAlias = (value) => {
-      if (desiredVersion !== '5-5') return false;
+      if (!targetUsesCurrentGpt55Alias) return false;
       const label = normalizeText(value);
       if (wantsPro) {
         // ChatGPT UI as of 2026-05: the picker shows just "Pro" (no longer "Pro Extended").
@@ -200,7 +235,8 @@ function buildModelSelectionExpression(targetModel, strategy) {
         if (desiredVersion === '5-1' && !normalizedLabel.includes('5 1')) return false;
         if (desiredVersion === '5-0' && !normalizedLabel.includes('5 0')) return false;
       }
-      if (wantsPro && !normalizedLabel.includes(' pro')) return false;
+      if (wantsPro && labelHasLegacyProVersion(normalizedLabel)) return false;
+      if (wantsPro && !labelHasProWord(normalizedLabel)) return false;
       if (wantsInstant && !normalizedLabel.includes('instant')) return false;
       if (wantsThinking && !normalizedLabel.includes('thinking')) return false;
       // Also reject if button has variants we DON'T want
@@ -218,6 +254,9 @@ function buildModelSelectionExpression(targetModel, strategy) {
       if (!signal) {
         return COMPOSER_SIGNAL_ALLOW_BLANK;
       }
+      if (wantsPro && labelHasLegacyProVersion(signal)) {
+        return false;
+      }
       if (COMPOSER_SIGNAL_EXCLUDES.some((token) => token && signal.includes(token))) {
         return false;
       }
@@ -356,15 +395,14 @@ function buildModelSelectionExpression(targetModel, strategy) {
       const candidateGpt55VisibleAlias = isTargetGpt55VisibleAlias(normalizedText);
       const candidateHasThinking =
         normalizedText.includes('thinking') || normalizedTestId.includes('thinking');
+      const candidateHasLegacyProVersion = labelHasLegacyProVersion(normalizedText);
       const candidateHasPro =
         candidateGpt55VisibleAlias ||
-        normalizedText === 'pro' ||
-        normalizedText.startsWith('pro ') ||
-        normalizedText.includes(' pro ') ||
-        normalizedText.endsWith(' pro') ||
+        labelHasProWord(normalizedText) ||
         normalizedText.includes('proresearch') ||
         normalizedTestId.includes('pro');
       if (wantsPro && candidateHasThinking) return 0;
+      if (wantsPro && candidateHasLegacyProVersion) return 0;
       if (wantsPro && !candidateHasPro) return 0;
       if (wantsThinking && candidateHasPro) return 0;
       if (desiredVersion === '5-5' && normalizedText && !candidateGpt55VisibleAlias) {
@@ -407,10 +445,10 @@ function buildModelSelectionExpression(targetModel, strategy) {
       }
       // If the caller didn't explicitly ask for Pro, prefer non-Pro options when both exist.
       if (wantsPro) {
-        if (!normalizedText.includes(' pro')) {
+        if (!labelHasProWord(normalizedText)) {
           score -= 80;
         }
-      } else if (normalizedText.includes(' pro')) {
+      } else if (labelHasProWord(normalizedText)) {
         score -= 40;
       }
       // Similarly for Thinking variant

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

@@ -388,9 +388,8 @@ function buildLoginProbeExpression(timeoutMs) {
         if (!text) return false;
         const normalized = text.toLowerCase().trim();
         return (
-          ['log in', 'login', 'sign in', 'signin', 'continue with', 'sign up for free'].some(
-            (needle) => normalized.startsWith(needle),
-          ) ||
+          ['log in', 'login', 'sign in', 'signin', 'sign up for free'].includes(normalized) ||
+          normalized.startsWith('continue with') ||
           normalized.includes('get responses tailored to you') ||
           normalized.includes('log in to get answers')
         );
@@ -490,3 +489,6 @@ function normalizeLoginProbe(raw) {
         onAuthPage: Boolean(value.onAuthPage),
     };
 }
+export function buildLoginProbeExpressionForTest(timeoutMs = LOGIN_CHECK_TIMEOUT_MS) {
+    return buildLoginProbeExpression(timeoutMs);
+}

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

@@ -290,17 +290,35 @@ function buildAttachmentReadyExpression(attachmentNames) {
       document.querySelector('form') ||
       document.body ||
       document;
-    const labelText = (node) =>
-      [
-        node?.textContent,
-        node?.getAttribute?.('aria-label'),
-        node?.getAttribute?.('title'),
-        node?.getAttribute?.('data-testid'),
-      ]
-        .filter(Boolean)
-        .join(' ')
-        .toLowerCase();
-    const match = (node, name) => labelText(node).includes(name);
+    // Walk node + ancestors (up to grandparent) + descendants to gather every textual hint.
+    // ChatGPT's current chip DOM nests the filename inside truncated child spans, so checking
+    // only the node's own textContent/aria/title misses the match.
+    const collectLabelHaystack = (node) => {
+      if (!node) return '';
+      const pieces = [];
+      const pushAttrs = (el) => {
+        if (!el || typeof el.getAttribute !== 'function') return;
+        for (const attr of ['aria-label', 'title', 'data-testid', 'data-tooltip', 'data-tooltip-content']) {
+          const v = el.getAttribute(attr);
+          if (v) pieces.push(v);
+        }
+      };
+      const pushText = (el) => {
+        if (!el) return;
+        const text = (el.innerText ?? el.textContent ?? '').trim();
+        if (text) pieces.push(text);
+      };
+      pushAttrs(node);
+      pushText(node);
+      const parent = node.parentElement;
+      pushAttrs(parent);
+      pushText(parent);
+      const grandparent = parent?.parentElement;
+      pushAttrs(grandparent);
+      pushText(grandparent);
+      return pieces.join(' ').toLowerCase();
+    };
+    const match = (node, name) => collectLabelHaystack(node).includes(name);
 
     // Restrict to attachment affordances; never scan generic div/span nodes (prompt text can contain the file name).
     const attachmentSelectors = [
@@ -312,13 +330,32 @@ function buildAttachmentReadyExpression(attachmentNames) {
       'button[aria-label*="Remove file"]',
       '[aria-label*="remove file"]',
       'button[aria-label*="remove file"]',
+      '[aria-label*="Remove attachment"]',
+      'button[aria-label*="Remove attachment"]',
+      '[aria-label*="remove attachment"]',
+      'button[aria-label*="remove attachment"]',
     ];
-    const attachmentRoots = Array.from(new Set([composer, document])).filter(Boolean);
+    const attachmentRoots = Array.from(new Set([composer])).filter(Boolean);
+    const collectChipNodes = () => {
+      const seen = new Set();
+      const collected = [];
+      for (const root of attachmentRoots) {
+        for (const node of Array.from(root.querySelectorAll(attachmentSelectors.join(',')))) {
+          if (!(node instanceof HTMLElement)) continue;
+          // Skip elements clearly inside the editable input (composer textarea may contain
+          // filename text in the user's prompt — avoid mistaking that for a chip).
+          if (node.closest('textarea,[contenteditable="true"]')) continue;
+          if (seen.has(node)) continue;
+          seen.add(node);
+          collected.push(node);
+        }
+      }
+      return collected;
+    };
+    const chipNodes = collectChipNodes();
 
     const chipsReady = names.every((name) =>
-      attachmentRoots.some((root) =>
-        Array.from(root.querySelectorAll(attachmentSelectors.join(','))).some((node) => match(node, name)),
-      ),
+      chipNodes.some((node) => match(node, name)),
     );
     const inputsReady = names.every((name) =>
       attachmentRoots.some((root) =>
@@ -329,14 +366,28 @@ function buildAttachmentReadyExpression(attachmentNames) {
         ),
       ),
     );
+    // Count-based fallback: if we cannot match names individually (ChatGPT may strip
+    // the filename out of attribute-readable text into a deeply nested span), but we
+    // do see at least as many distinct chip-shaped nodes as attachments we uploaded,
+    // and a sibling "Remove" affordance exists per chip, trust the upload.
+    const removeAffordanceCount = chipNodes.filter((node) => {
+      const aria = (node.getAttribute?.('aria-label') ?? '').toLowerCase();
+      if (aria.includes('remove')) return true;
+      const removeSibling = node.querySelector?.(
+        '[aria-label*="Remove" i], [aria-label*="remove" i], button[aria-label*="Remove" i], button[aria-label*="remove" i]',
+      );
+      return Boolean(removeSibling);
+    }).length;
+    const countReady = chipNodes.length >= names.length && removeAffordanceCount >= names.length;
 
-    return chipsReady || inputsReady;
+    return chipsReady || inputsReady || countReady;
   })()`;
 }
 export function buildAttachmentReadyExpressionForTest(attachmentNames) {
     return buildAttachmentReadyExpression(attachmentNames);
 }
 async function attemptSendButton(Runtime, _logger, attachmentNames) {
+    const needAttachment = Array.isArray(attachmentNames) && attachmentNames.length > 0;
     const script = `(() => {
     ${buildClickDispatcher()}
     const selectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
@@ -369,9 +420,11 @@ async function attemptSendButton(Runtime, _logger, attachmentNames) {
     dispatchClickSequence(button);
     return 'clicked';
   })()`;
-    const deadline = Date.now() + 20_000;
+    // Give attachment-bearing submissions more headroom. ChatGPT's chip render can
+    // settle slowly for multi-file uploads, but plain text sends should keep the
+    // shorter historical deadline.
+    const deadline = Date.now() + sendButtonTimeoutMs(attachmentNames);
     while (Date.now() < deadline) {
-        const needAttachment = Array.isArray(attachmentNames) && attachmentNames.length > 0;
         if (needAttachment) {
             const ready = await Runtime.evaluate({
                 expression: buildAttachmentReadyExpression(attachmentNames),
@@ -400,6 +453,9 @@ async function attemptSendButton(Runtime, _logger, attachmentNames) {
     }
     return false;
 }
+function sendButtonTimeoutMs(attachmentNames) {
+    return Array.isArray(attachmentNames) && attachmentNames.length > 0 ? 45_000 : 20_000;
+}
 async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselineTurns) {
     const deadline = Date.now() + timeoutMs;
     const encodedPrompt = JSON.stringify(prompt.trim());
@@ -542,5 +598,6 @@ async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger, baselin
 // biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
 export const __test__ = {
     attemptSendButton,
+    sendButtonTimeoutMs,
     verifyPromptCommitted,
 };

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

@@ -207,21 +207,36 @@ function buildThinkingTimeExpression(level) {
 
     const findModelButton = () => document.querySelector(MODEL_BUTTON_SELECTOR);
     const findTrailingButtons = () => Array.from(document.querySelectorAll(TRAILING_SELECTOR));
+    const findEffortRow = (node) => {
+      let current = node instanceof HTMLElement ? node.parentElement : null;
+      while (current && current !== document.body) {
+        if (current.getAttribute?.('data-model-picker-thinking-effort-row') === 'true') {
+          return current;
+        }
+        current = current.parentElement;
+      }
+      return null;
+    };
+    const rowIsSelected = (row) => {
+      if (!(row instanceof HTMLElement)) return false;
+      const modelItem = row.querySelector('[data-model-picker-thinking-effort-menu-item="true"], [role="menuitemradio"]');
+      if (optionIsSelected(modelItem)) return true;
+      return Boolean(
+        row.querySelector(
+          '[aria-checked="true"], [aria-selected="true"], [aria-current="true"], [data-selected="true"], [data-state="checked"], [data-state="selected"], [data-state="on"]',
+        ),
+      );
+    };
     const pickTrailingForCurrentModel = () => {
       const trailings = findTrailingButtons();
       if (trailings.length === 0) return null;
       if (trailings.length === 1) return trailings[0];
       // Prefer the trailing button whose model row is currently selected.
       for (const t of trailings) {
-        const row = t.closest('[role="menuitem"], [role="menuitemradio"], [data-radix-collection-item]');
-        if (row && (optionIsSelected(row) || row.querySelector('[aria-checked="true"]'))) return t;
-      }
-      // Fallback: first one with non-zero box.
-      for (const t of trailings) {
-        const r = t.getBoundingClientRect?.();
-        if (r && r.width > 0 && r.height > 0) return t;
+        const row = findEffortRow(t);
+        if (rowIsSelected(row)) return t;
       }
-      return trailings[0];
+      return null;
     };
 
     const modelBtn = findModelButton();

package/dist/src/browser/constants.js

@@ -1,5 +1,5 @@
 export const CHATGPT_URL = "https://chatgpt.com/";
-export const DEFAULT_MODEL_TARGET = "GPT-5.5 Pro";
+export const DEFAULT_MODEL_TARGET = "Pro";
 export const DEFAULT_MODEL_STRATEGY = "select";
 export const COOKIE_URLS = [
     "https://chatgpt.com",

package/dist/src/browser/index.js

@@ -26,6 +26,7 @@ import { resolveAttachRunningConnection } from "./attachRunning.js";
 import { connectToExistingChatGptTab } from "./liveTabs.js";
 import { captureBrowserDiagnostics } from "./domDebug.js";
 import { archiveChatGptConversation, resolveBrowserArchiveDecision, } from "./actions/archiveConversation.js";
+import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, isManualLoginProfileInitialized, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { describeBrowserControlPlan, formatBrowserControlPlan } from "./controlPlan.js";
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
 export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from "./utils.js";
@@ -290,6 +291,17 @@ async function closeRemoteConnectionAfterRun(options) {
 function shouldCloseOwnedRunTargetAfterRun(options) {
     return options.runStatus === "complete" && options.ownsTarget && !options.keepBrowser;
 }
+function buildSkippedModelSelectionEvidence(desiredModel, strategy) {
+    return {
+        requestedModel: desiredModel ?? null,
+        resolvedLabel: null,
+        strategy,
+        status: "skipped",
+        verified: false,
+        source: "config",
+        capturedAt: new Date().toISOString(),
+    };
+}
 export async function runBrowserMode(options) {
     const promptText = options.prompt?.trim();
     if (!promptText) {
@@ -383,14 +395,19 @@ export async function runBrowserMode(options) {
     const manualLogin = Boolean(config.manualLogin);
     const manualProfileDir = config.manualLoginProfileDir
         ? path.resolve(config.manualLoginProfileDir)
-        : path.join(os.homedir(), ".oracle", "browser-profile");
+        : defaultManualLoginProfileDir();
     const userDataDir = manualLogin
         ? manualProfileDir
         : await mkdtemp(path.join(await resolveUserDataBaseDir(), "oracle-browser-"));
+    const effectiveKeepBrowser = Boolean(config.keepBrowser);
     if (manualLogin) {
         // Learned: manual login reuses a persistent profile so cookies/SSO survive.
         await mkdir(userDataDir, { recursive: true });
         logger(`Manual login mode enabled; reusing persistent profile at ${userDataDir}`);
+        await assertManualLoginProfileReadyForRun({
+            userDataDir,
+            keepBrowser: effectiveKeepBrowser,
+        });
     }
     else {
         logger(`Created temporary Chrome profile at ${userDataDir}`);
@@ -403,7 +420,6 @@ export async function runBrowserMode(options) {
             sessionId: options.sessionId,
         });
     }
-    const effectiveKeepBrowser = Boolean(config.keepBrowser);
     let acquiredChrome;
     try {
         acquiredChrome = manualLogin
@@ -451,6 +467,7 @@ export async function runBrowserMode(options) {
     let answerMarkdown = "";
     let answerHtml = "";
     let runStatus = "attempted";
+    let modelSelectionEvidence;
     let connectionClosedUnexpectedly = false;
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
@@ -587,6 +604,8 @@ export async function runBrowserMode(options) {
                 appliedCookies,
                 manualLogin,
                 timeoutMs: config.timeoutMs,
+                profileDir: userDataDir,
+                keepBrowser: effectiveKeepBrowser,
             }));
             if (config.url !== baseUrl) {
                 await raceWithDisconnect(navigateToPromptReadyWithFallback(Page, Runtime, {
@@ -680,7 +699,7 @@ export async function runBrowserMode(options) {
         await captureRuntimeSnapshot();
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
         if (config.desiredModel && modelStrategy !== "ignore") {
-            await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
+            modelSelectionEvidence = await raceWithDisconnect(withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
@@ -699,6 +718,7 @@ export async function runBrowserMode(options) {
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
         else if (modelStrategy === "ignore") {
+            modelSelectionEvidence = buildSkippedModelSelectionEvidence(config.desiredModel, modelStrategy);
             logger("Model picker: skipped (strategy=ignore)");
         }
         const deepResearch = config.researchMode === "deep";
@@ -881,6 +901,7 @@ export async function runBrowserMode(options) {
                 answerHtml: researchResult.html,
                 artifacts: savedArtifacts,
                 archive,
+                modelSelection: modelSelectionEvidence,
                 tookMs: durationMs,
                 answerTokens: tokens,
                 answerChars: researchResult.text.length,
@@ -1266,6 +1287,7 @@ export async function runBrowserMode(options) {
             generatedImages: imageArtifacts.generatedImages,
             savedImages: imageArtifacts.savedImages,
             archive,
+            modelSelection: modelSelectionEvidence,
             tookMs: durationMs,
             answerTokens,
             answerChars,
@@ -1491,12 +1513,13 @@ async function findEphemeralPort() {
         });
     });
 }
-async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, }) {
+async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, profileDir, keepBrowser, }) {
     if (!manualLogin) {
         await ensureLoggedIn(runtime, logger, { appliedCookies });
         return;
     }
-    const deadline = Date.now() + Math.min(timeoutMs ?? 1_200_000, 20 * 60_000);
+    const waitMs = resolveManualLoginWaitMs(timeoutMs, Boolean(keepBrowser));
+    const deadline = Date.now() + waitMs;
     let lastNotice = 0;
     while (Date.now() < deadline) {
         try {
@@ -1518,7 +1541,10 @@ async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, time
             await delay(1000);
         }
     }
-    throw new Error("Manual login mode timed out waiting for ChatGPT session; please sign in and retry.");
+    const setupCommand = formatManualLoginSetupCommand(profileDir ?? defaultManualLoginProfileDir());
+    throw new Error("Manual login mode timed out waiting for ChatGPT session. " +
+        `Browser mode is using Oracle's private Chrome profile at ${profileDir ?? "(default profile)"}, not your normal Chrome profile. ` +
+        `Run first-time setup, sign in there, then retry: ${setupCommand}`);
 }
 async function maybeRecoverLongAssistantResponse({ runtime, baselineTurns, answerText, answerMarkdown, logger, allowMarkdownUpdate, }) {
     // Learned: long streaming responses can still be rendering after initial capture.
@@ -1712,6 +1738,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     let answerHtml = "";
     let connectionClosedUnexpectedly = false;
     let runStatus = "attempted";
+    let modelSelectionEvidence;
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
     let connection = null;
@@ -1801,7 +1828,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
         const modelStrategy = config.modelStrategy ?? DEFAULT_MODEL_STRATEGY;
         if (config.desiredModel && modelStrategy !== "ignore") {
-            await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
+            modelSelectionEvidence = await withRetries(() => ensureModelSelection(Runtime, config.desiredModel, logger, modelStrategy), {
                 retries: 2,
                 delayMs: 300,
                 onRetry: (attempt, error) => {
@@ -1814,6 +1841,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
         }
         else if (modelStrategy === "ignore") {
+            modelSelectionEvidence = buildSkippedModelSelectionEvidence(config.desiredModel, modelStrategy);
             logger("Model picker: skipped (strategy=ignore)");
         }
         const deepResearch = config.researchMode === "deep";
@@ -1948,6 +1976,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 answerHtml: researchResult.html,
                 artifacts: savedArtifacts,
                 archive,
+                modelSelection: modelSelectionEvidence,
                 tookMs: durationMs,
                 answerTokens: tokens,
                 answerChars: researchResult.text.length,
@@ -2311,6 +2340,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
             artifacts: savedArtifacts,
             archive,
+            modelSelection: modelSelectionEvidence,
             controllerPid: process.pid,
         };
     }
@@ -2372,10 +2402,14 @@ export { estimateTokenCount } from "./utils.js";
 export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from "./config.js";
 // biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
 export const __test__ = {
+    assertManualLoginProfileReadyForRun,
     closeRemoteConnectionAfterRun,
     detachKeptChromeProcess,
+    formatManualLoginSetupCommand,
+    isManualLoginProfileInitialized,
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
+    resolveManualLoginWaitMs,
     shouldCloseOwnedRunTargetAfterRun,
 };
 export { syncCookies } from "./cookies.js";

package/dist/src/browser/manualLoginProfile.js

@@ -0,0 +1,54 @@
+import { readdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { BrowserAutomationError } from "../oracle/errors.js";
+export function resolveManualLoginWaitMs(timeoutMs, keepBrowser) {
+    const configured = Math.min(timeoutMs ?? 1_200_000, 20 * 60_000);
+    if (keepBrowser) {
+        return configured;
+    }
+    return Math.min(configured, 30_000);
+}
+export async function assertManualLoginProfileReadyForRun({ userDataDir, keepBrowser, }) {
+    if (keepBrowser) {
+        return;
+    }
+    if (await isManualLoginProfileInitialized(userDataDir)) {
+        return;
+    }
+    const setupCommand = formatManualLoginSetupCommand(userDataDir);
+    throw new BrowserAutomationError("ChatGPT browser manual-login profile is not initialized. " +
+        `Browser mode is using Oracle's private Chrome profile at ${userDataDir}, separate from your normal Chrome profile. ` +
+        `Run first-time setup, sign in there, then retry: ${setupCommand}. ` +
+        "If you want to reuse an already signed-in Chrome instead, use --browser-attach-running.", {
+        stage: "browser-login-setup",
+        details: {
+            profileDir: userDataDir,
+            setupCommand,
+            sessionStatus: "needs_login",
+        },
+        reuseProfileHint: setupCommand,
+    });
+}
+export async function isManualLoginProfileInitialized(profileDir) {
+    const entries = await readdir(profileDir, { withFileTypes: true }).catch(() => []);
+    return entries.some((entry) => {
+        if (!entry.name)
+            return false;
+        if (entry.name === "Default" || entry.name === "Local State")
+            return true;
+        if (entry.name.startsWith("Profile "))
+            return true;
+        return false;
+    });
+}
+export function formatManualLoginSetupCommand(profileDir) {
+    return [
+        "oracle --engine browser --browser-manual-login --browser-keep-browser",
+        `--browser-manual-login-profile-dir ${JSON.stringify(profileDir)}`,
+        '-p "HI"',
+    ].join(" ");
+}
+export function defaultManualLoginProfileDir() {
+    return path.join(os.homedir(), ".oracle", "browser-profile");
+}