@steipete/oracle 0.16.1 → 0.17.0

package/dist/src/browser/chromeLifecycle.js

@@ -1,17 +1,14 @@
 import { rm } from "node:fs/promises";
-import { readFileSync } from "node:fs";
-import os from "node:os";
 import net from "node:net";
 import CDP from "chrome-remote-interface";
 import { launch, Launcher } from "chrome-launcher";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
+import { isWsl, resolveWslChromeLaunchRoute } from "./wslHost.js";
 export async function launchChrome(config, userDataDir, logger) {
-    const connectHost = resolveRemoteDebugHost();
-    const debugBindAddress = connectHost && connectHost !== "127.0.0.1" ? "0.0.0.0" : connectHost;
+    const { connectHost, debugBindAddress, usePatchedLauncher } = resolveWslChromeLaunchRoute();
     const debugPort = config.debugPort ?? parseDebugPortEnv();
     const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress, config.hideWindow ?? false);
-    const usePatchedLauncher = Boolean(connectHost && connectHost !== "127.0.0.1");
     // copy-profile reuses a copied signed-in profile whose cookies are
     // Keychain-encrypted, so it must launch with the real Keychain (not mocked):
     // strip the keychain-mocking flags from both chrome-launcher's defaults and
@@ -595,38 +592,6 @@ function parseDebugPortEnv() {
     }
     return value;
 }
-function resolveRemoteDebugHost() {
-    const override = process.env.ORACLE_BROWSER_REMOTE_DEBUG_HOST?.trim() || process.env.WSL_HOST_IP?.trim();
-    if (override) {
-        return override;
-    }
-    if (!isWsl()) {
-        return null;
-    }
-    try {
-        const resolv = readFileSync("/etc/resolv.conf", "utf8");
-        for (const line of resolv.split("\n")) {
-            const match = line.match(/^nameserver\s+([0-9.]+)/);
-            if (match?.[1]) {
-                return match[1];
-            }
-        }
-    }
-    catch {
-        // ignore; fall back to localhost
-    }
-    return null;
-}
-function isWsl() {
-    if (process.platform !== "linux") {
-        return false;
-    }
-    if (process.env.WSL_DISTRO_NAME) {
-        return true;
-    }
-    const release = os.release();
-    return release.toLowerCase().includes("microsoft");
-}
 async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host, requestedPort, ignoreDefaultFlags, }) {
     const launcher = new Launcher({
         chromePath: chromePath ?? undefined,

package/dist/src/browser/index.js

@@ -71,6 +71,9 @@ function classifyPreservedBrowserError(error, headless) {
 function shouldPreserveBrowserOnError(error, headless) {
     return classifyPreservedBrowserError(error, headless) !== null;
 }
+function normalizeAuthenticatedModelSelectionError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
 function shouldKeepLocalBrowserOpen(options) {
     if (options.usingCopiedProfile)
         return false;
@@ -1054,11 +1057,9 @@ export async function runBrowserMode(options) {
                     }
                 },
             })).catch((error) => {
-                const base = error instanceof Error ? error.message : String(error);
-                const hint = appliedCookies === 0
-                    ? " No cookies were applied; log in to ChatGPT in Chrome or provide inline cookies (--browser-inline-cookies[(-file)] or ORACLE_BROWSER_COOKIES_JSON)."
-                    : "";
-                throw new Error(`${base}${hint}`);
+                // Login has already been verified above. Preserve the picker failure instead of
+                // misdiagnosing an unavailable model as missing cookies.
+                throw normalizeAuthenticatedModelSelectionError(error);
             });
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
@@ -1342,7 +1343,11 @@ export async function runBrowserMode(options) {
             if (conversationUrl && isConversationUrl(conversationUrl)) {
                 logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
                 await raceWithDisconnect(Page.navigate({ url: conversationUrl }));
-                await raceWithDisconnect(delay(1000));
+                await raceWithDisconnect(waitForResumedConversationHydration(Runtime, recheckTimeoutMs || 30_000, logger, {
+                    requirePriorTurns: true,
+                    requirePromptReady: false,
+                    expectedConversationUrl: conversationUrl,
+                }));
             }
             // Validate session before attempting recheck - sessions can expire during the delay
             const sessionValid = await validateChatGPTSession(Runtime, logger);
@@ -2607,7 +2612,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 lastUrl = conversationUrl;
                 logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
                 await Page.navigate({ url: conversationUrl });
-                await delay(1000);
+                await waitForResumedConversationHydration(Runtime, recheckTimeoutMs || 30_000, logger, {
+                    requirePriorTurns: true,
+                    requirePromptReady: false,
+                    expectedConversationUrl: conversationUrl,
+                });
             }
             // Validate session before attempting recheck - sessions can expire during the delay
             const sessionValid = await validateChatGPTSession(Runtime, logger);
@@ -3051,10 +3060,12 @@ export const __test__ = {
     isManualLoginProfileInitialized,
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
+    normalizeAuthenticatedModelSelectionError,
     resolveManualLoginWaitMs,
     shouldCleanupBlankTabsAfterLastLease,
     shouldCloseOwnedRunTargetAfterRun,
     shouldKeepLocalBrowserOpen,
+    waitForAssistantResponseWithReload,
 };
 export { syncCookies } from "./cookies.js";
 export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from "./pageActions.js";
@@ -3086,7 +3097,11 @@ async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logg
         }
         logger("Assistant response stalled; reloading conversation and retrying once");
         await Page.navigate({ url: conversationUrl });
-        await delay(1000);
+        await waitForResumedConversationHydration(Runtime, timeoutMs, logger, {
+            requirePriorTurns: true,
+            requirePromptReady: false,
+            expectedConversationUrl: conversationUrl,
+        });
         return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId);
     }
 }

package/dist/src/browser/modelDisplay.js

@@ -0,0 +1,67 @@
+function cleanLabel(value) {
+    const label = value?.trim();
+    return label ? label : null;
+}
+function sameLabel(left, right) {
+    return left.localeCompare(right, undefined, { sensitivity: "accent" }) === 0;
+}
+/**
+ * Describe what a browser run will try to select without presenting the target as observed fact.
+ */
+export function formatBrowserModelTarget({ model, desiredModel, modelStrategy, }) {
+    const requested = cleanLabel(model) ?? "n/a";
+    if (modelStrategy === "current" || modelStrategy === "ignore") {
+        return `picker=${modelStrategy}; requested=${requested}`;
+    }
+    const target = cleanLabel(desiredModel);
+    if (!target) {
+        return requested;
+    }
+    return `target=${target}; requested=${requested}`;
+}
+/**
+ * Prefer picker evidence only when Oracle verified it. Otherwise retain the requested CLI key.
+ * In particular, a bare `Pro` picker label must not be expanded to a server-side model version.
+ */
+export function resolveBrowserModelDisplayName({ model, evidence, }) {
+    const verifiedLabel = evidence?.verified ? cleanLabel(evidence.resolvedLabel) : null;
+    return verifiedLabel ?? cleanLabel(model) ?? "n/a";
+}
+export function formatBrowserModelWithRequestedKey(input) {
+    const displayName = resolveBrowserModelDisplayName(input);
+    const requested = cleanLabel(input.model);
+    if (!requested || sameLabel(displayName, requested)) {
+        return displayName;
+    }
+    return `${displayName} (requested ${requested})`;
+}
+export function resolveSessionBrowserModelDisplayName(metadata, model = metadata.model) {
+    const sessionModel = cleanLabel(metadata.model);
+    const requestedModel = cleanLabel(model);
+    const evidenceApplies = requestedModel === null
+        ? sessionModel === null
+        : sessionModel !== null && sameLabel(requestedModel, sessionModel);
+    return resolveBrowserModelDisplayName({
+        model,
+        evidence: evidenceApplies ? metadata.browser?.modelSelection : undefined,
+    });
+}
+export function formatSessionBrowserModelWithRequestedKey(metadata, model = metadata.model) {
+    const sessionModel = cleanLabel(metadata.model);
+    const requestedModel = cleanLabel(model);
+    const evidenceApplies = requestedModel === null
+        ? sessionModel === null
+        : sessionModel !== null && sameLabel(requestedModel, sessionModel);
+    return formatBrowserModelWithRequestedKey({
+        model,
+        evidence: evidenceApplies ? metadata.browser?.modelSelection : undefined,
+    });
+}
+export function formatBrowserModelSelectionEvidence(evidence, model) {
+    const requestedKey = cleanLabel(model) ?? "(none)";
+    const target = cleanLabel(evidence.requestedModel) ?? "(none)";
+    const resolvedLabel = cleanLabel(evidence.resolvedLabel) ?? "(unavailable)";
+    const strategy = evidence.strategy ?? "(default)";
+    const verified = evidence.verified ? "yes" : "no";
+    return `requestedKey=${requestedKey}; target=${target}; resolvedLabel=${resolvedLabel}; status=${evidence.status}; strategy=${strategy}; verified=${verified}; source=${evidence.source}; capturedAt=${evidence.capturedAt}`;
+}

package/dist/src/browser/reattach.js

@@ -2,7 +2,7 @@ import CDP from "chrome-remote-interface";
 import os from "node:os";
 import path from "node:path";
 import { mkdtemp, mkdir, rm } from "node:fs/promises";
-import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, } from "./pageActions.js";
+import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, } from "./pageActions.js";
 import { launchChrome, connectToChrome, positionChromeWindowOffscreen, connectToRemoteChromeTarget, listRemoteChromeTargets, } from "./chromeLifecycle.js";
 import { resolveBrowserConfig } from "./config.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
@@ -98,6 +98,13 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         const pingTimeoutMs = Math.min(5_000, Math.max(1_500, Math.floor(timeoutMs * 0.05)));
         await withTimeout(Runtime.evaluate({ expression: "1+1", returnByValue: true }), pingTimeoutMs, "Reattach target did not respond");
         await ensureConversationOpen();
+        const waitForHydration = deps.waitForConversationHydration ?? waitForResumedConversationHydration;
+        const expectedConversationUrl = buildConversationUrl(runtime, resolveBrowserConfig(config ?? {}).url);
+        await waitForHydration(Runtime, timeoutMs, logger, {
+            requirePriorTurns: true,
+            requirePromptReady: false,
+            expectedConversationUrl: expectedConversationUrl ?? undefined,
+        });
         const minTurnIndex = (await readPromptPreviewTurnIndex(Runtime, deps.promptPreview)) ??
             (deps.promptPreview ? null : await readConversationTurnIndex(Runtime, logger));
         if (config?.researchMode === "deep") {
@@ -226,6 +233,12 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
         }
         await waitForLocationChange(Runtime, 15_000);
     }
+    const waitForHydration = deps.waitForConversationHydration ?? waitForResumedConversationHydration;
+    await waitForHydration(Runtime, resolved.inputTimeoutMs, logger, {
+        requirePriorTurns: true,
+        requirePromptReady: false,
+        expectedConversationUrl: conversationUrl ?? undefined,
+    });
     const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
     const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
     const timeoutMs = resolved.timeoutMs ?? 120_000;

package/dist/src/browser/recoverConversation.js

@@ -67,7 +67,8 @@ export function isRecoveredConversationHarvestReady(harvested) {
         (typeof harvested.lastAssistantTurnIndex === "number" &&
             typeof harvested.lastUserTurnIndex === "number" &&
             harvested.lastAssistantTurnIndex > harvested.lastUserTurnIndex);
-    return (harvested.stopExists === true ||
+    const hasHydratedUserTurn = typeof harvested.lastUserTurnIndex === "number" && harvested.lastUserTurnIndex >= 0;
+    return ((harvested.stopExists === true && hasHydratedUserTurn) ||
         ((harvested.assistantCount ?? 0) > 0 &&
             assistantFollowsLatestUser &&
             latestAssistant.trim().length > 0 &&

package/dist/src/browser/sessionRunner.js

@@ -5,6 +5,7 @@ import { runBrowserMode } from "../browserMode.js";
 import { assembleBrowserPrompt } from "./prompt.js";
 import { BrowserAutomationError } from "../oracle/errors.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
+import { formatBrowserModelSelectionEvidence, formatBrowserModelTarget, resolveBrowserModelDisplayName, } from "./modelDisplay.js";
 const LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD = 25_000;
 const LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD = 120_000;
 function buildUnavailableModelSelectionEvidence(browserConfig) {
@@ -21,13 +22,6 @@ function buildUnavailableModelSelectionEvidence(browserConfig) {
         capturedAt: new Date().toISOString(),
     };
 }
-function formatModelSelectionEvidence(evidence) {
-    const requested = evidence.requestedModel ?? "(none)";
-    const resolved = evidence.resolvedLabel ?? "(unavailable)";
-    const strategy = evidence.strategy ?? "(default)";
-    const verified = evidence.verified ? "yes" : "no";
-    return `[browser] Model selection evidence: requested=${requested}; resolved=${resolved}; status=${evidence.status}; strategy=${strategy}; verified=${verified}.`;
-}
 function isRequestedProBrowserRun(runOptions, browserConfig, evidence) {
     const candidates = [
         runOptions.model,
@@ -87,7 +81,12 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (promptArtifacts.bundled) {
         log(chalk.dim(`Packed ${promptArtifacts.bundled.originalCount} files into 1 bundle (contents counted in token estimate).`));
     }
-    const headerLine = `Launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens.`;
+    const launchModel = formatBrowserModelTarget({
+        model: runOptions.model,
+        desiredModel: browserConfig.desiredModel,
+        modelStrategy: browserConfig.modelStrategy,
+    });
+    const headerLine = `Launching browser mode (${launchModel}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens.`;
     const automationLogger = ((message) => {
         if (typeof message !== "string")
             return;
@@ -150,7 +149,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     }
     const modelSelection = browserResult.modelSelection ?? buildUnavailableModelSelectionEvidence(browserConfig);
     if (modelSelection) {
-        log(formatModelSelectionEvidence(modelSelection));
+        log(`[browser] Model selection evidence: ${formatBrowserModelSelectionEvidence(modelSelection, runOptions.model)}`);
     }
     const warnings = buildBrowserRunWarnings({
         runOptions,
@@ -199,7 +198,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     })();
     const { line1, line2 } = formatFinishLine({
         elapsedMs: browserResult.tookMs,
-        model: `${runOptions.model}[browser]`,
+        model: `${resolveBrowserModelDisplayName({ model: runOptions.model, evidence: modelSelection })}[browser]`,
         tokensPart,
         detailParts: [
             runOptions.file && runOptions.file.length > 0 ? `files=${runOptions.file.length}` : null,

package/dist/src/browser/wslHost.js

@@ -0,0 +1,50 @@
+import { readFileSync } from "node:fs";
+import os from "node:os";
+export function isWsl() {
+    if (process.platform !== "linux")
+        return false;
+    if (process.env.WSL_DISTRO_NAME)
+        return true;
+    return os.release().toLowerCase().includes("microsoft");
+}
+export function parseWslResolverHost(resolvConf) {
+    for (const line of resolvConf.split("\n")) {
+        const match = line.match(/^nameserver\s+([0-9.]+)/);
+        if (match?.[1]) {
+            return match[1].startsWith("127.") ? "127.0.0.1" : match[1];
+        }
+    }
+    return null;
+}
+export function resolveWslHost() {
+    if (!isWsl())
+        return null;
+    try {
+        return parseWslResolverHost(readFileSync("/etc/resolv.conf", "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveWslChromeHost(options = {}) {
+    const remoteDebugHost = options.remoteDebugHost === undefined
+        ? process.env.ORACLE_BROWSER_REMOTE_DEBUG_HOST
+        : options.remoteDebugHost;
+    const wslHostIp = options.wslHostIp === undefined ? process.env.WSL_HOST_IP : options.wslHostIp;
+    const override = remoteDebugHost?.trim() || wslHostIp?.trim();
+    if (override)
+        return override;
+    if (options.resolvConf !== undefined) {
+        return options.resolvConf === null ? null : parseWslResolverHost(options.resolvConf);
+    }
+    return resolveWslHost();
+}
+export function resolveWslChromeLaunchRoute(options = {}) {
+    const connectHost = resolveWslChromeHost(options);
+    const usePatchedLauncher = Boolean(connectHost && connectHost !== "127.0.0.1");
+    return {
+        connectHost,
+        debugBindAddress: usePatchedLauncher ? "0.0.0.0" : connectHost,
+        usePatchedLauncher,
+    };
+}

package/dist/src/cli/browserConfig.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import chalk from "chalk";
 import { normalizeThinkingTimeLevel } from "../oracle/thinkingTime.js";
 import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "../browser/constants.js";
 import { normalizeChatgptUrl } from "../browser/utils.js";
@@ -86,6 +87,7 @@ export async function buildBrowserConfig(options) {
     const isChatGptModel = baseModel.startsWith("gpt-") && !baseModel.includes("codex");
     const shouldUseOverride = !isChatGptModel && normalizedOverride.length > 0 && normalizedOverride !== baseModel;
     const modelStrategy = normalizeBrowserModelStrategy(options.browserModelStrategy) ?? DEFAULT_MODEL_STRATEGY;
+    assertBrowserModelAvailable(options.model, modelStrategy);
     const cookieNames = parseCookieNames(options.browserCookieNames ?? process.env.ORACLE_BROWSER_COOKIE_NAMES);
     let inline = await resolveInlineCookies({
         inlineArg: options.browserInlineCookies,
@@ -123,38 +125,38 @@ export async function buildBrowserConfig(options) {
         url,
         debugPort: selectBrowserPort(options),
         timeoutMs: options.browserTimeout
-            ? parseDuration(options.browserTimeout, DEFAULT_BROWSER_TIMEOUT_MS)
+            ? parseBrowserDuration(options.browserTimeout, "--browser-timeout", DEFAULT_BROWSER_TIMEOUT_MS)
             : undefined,
         inputTimeoutMs: options.browserInputTimeout
-            ? parseDuration(options.browserInputTimeout, DEFAULT_BROWSER_INPUT_TIMEOUT_MS)
+            ? parseBrowserDuration(options.browserInputTimeout, "--browser-input-timeout", DEFAULT_BROWSER_INPUT_TIMEOUT_MS)
             : undefined,
         attachmentTimeoutMs: options.browserAttachmentTimeout
-            ? parseDuration(options.browserAttachmentTimeout, DEFAULT_BROWSER_ATTACHMENT_TIMEOUT_MS)
+            ? parseBrowserDuration(options.browserAttachmentTimeout, "--browser-attachment-timeout", DEFAULT_BROWSER_ATTACHMENT_TIMEOUT_MS)
             : undefined,
         assistantRecheckDelayMs: options.browserRecheckDelay
-            ? parseDuration(options.browserRecheckDelay, 0)
+            ? parseBrowserDuration(options.browserRecheckDelay, "--browser-recheck-delay", 0)
             : undefined,
         assistantRecheckTimeoutMs: options.browserRecheckTimeout
-            ? parseDuration(options.browserRecheckTimeout, DEFAULT_BROWSER_RECHECK_TIMEOUT_MS)
+            ? parseBrowserDuration(options.browserRecheckTimeout, "--browser-recheck-timeout", DEFAULT_BROWSER_RECHECK_TIMEOUT_MS)
             : undefined,
         reuseChromeWaitMs: options.browserReuseWait
-            ? parseDuration(options.browserReuseWait, 0)
+            ? parseBrowserDuration(options.browserReuseWait, "--browser-reuse-wait", 0)
             : undefined,
         profileLockTimeoutMs: options.browserProfileLockTimeout
-            ? parseDuration(options.browserProfileLockTimeout, 0)
+            ? parseBrowserDuration(options.browserProfileLockTimeout, "--browser-profile-lock-timeout", 0)
             : undefined,
         maxConcurrentTabs: parseMaxConcurrentTabs(options.browserMaxConcurrentTabs),
         autoReattachDelayMs: options.browserAutoReattachDelay
-            ? parseDuration(options.browserAutoReattachDelay, 0)
+            ? parseBrowserDuration(options.browserAutoReattachDelay, "--browser-auto-reattach-delay", 0)
             : undefined,
         autoReattachIntervalMs: options.browserAutoReattachInterval
-            ? parseDuration(options.browserAutoReattachInterval, 0)
+            ? parseBrowserDuration(options.browserAutoReattachInterval, "--browser-auto-reattach-interval", 0)
             : undefined,
         autoReattachTimeoutMs: options.browserAutoReattachTimeout
-            ? parseDuration(options.browserAutoReattachTimeout, DEFAULT_BROWSER_AUTO_REATTACH_TIMEOUT_MS)
+            ? parseBrowserDuration(options.browserAutoReattachTimeout, "--browser-auto-reattach-timeout", DEFAULT_BROWSER_AUTO_REATTACH_TIMEOUT_MS)
             : undefined,
         cookieSyncWaitMs: options.browserCookieWait
-            ? parseDuration(options.browserCookieWait, 0)
+            ? parseBrowserDuration(options.browserCookieWait, "--browser-cookie-wait", 0)
             : undefined,
         cookieSync: options.browserNoCookieSync ? false : undefined,
         cookieNames,
@@ -178,6 +180,17 @@ export async function buildBrowserConfig(options) {
         archiveConversations: options.browserArchive,
     };
 }
+function assertBrowserModelAvailable(model, modelStrategy) {
+    if (modelStrategy !== "select")
+        return;
+    const normalized = normalizeChatGptModelForBrowser(model);
+    if (normalized !== "gpt-5.2" &&
+        normalized !== "gpt-5.2-instant" &&
+        normalized !== "gpt-5.2-thinking") {
+        return;
+    }
+    throw new Error(`Browser model "${model}" is retired because ChatGPT no longer offers GPT-5.2 base, Instant, or Thinking. Choose a current GPT-5.5/GPT-5.6 browser model, use --browser-model-strategy current to keep ChatGPT's active model, or use --engine api to retain the GPT-5.2 API alias.`);
+}
 function validateAttachRunningOptions(options, { attachRunning, hasInlineCookies, }) {
     if (!attachRunning) {
         return;
@@ -218,6 +231,13 @@ function parseMaxConcurrentTabs(raw) {
     }
     return Math.trunc(value);
 }
+function parseBrowserDuration(raw, optionName, fallbackMs) {
+    const parsed = parseDuration(raw, Number.NaN);
+    if (Number.isFinite(parsed))
+        return parsed;
+    console.log(chalk.yellow(`Warning: invalid ${optionName} duration "${raw}"; using fallback ${fallbackMs}ms.`));
+    return fallbackMs;
+}
 export function mapModelToBrowserLabel(model) {
     const normalized = normalizeChatGptModelForBrowser(model);
     // Iterate ordered array to find first match (most specific first)

package/dist/src/cli/detach.js

@@ -1,14 +1,31 @@
 import { isProModel } from "../oracle/modelResolver.js";
 export function shouldDetachSession({ 
 // Params kept for policy tweaks.
-engine, model, waitPreference, disableDetachEnv, }) {
+engine, model, reasoningMode, waitPreference, disableDetachEnv, }) {
     if (disableDetachEnv)
         return false;
-    // Explicit --wait means "stay attached", regardless of model defaults.
+    // Keep long local browser Pro work in a separate process even while the CLI
+    // stays attached to its session log. If the foreground stream is interrupted,
+    // the worker can still finish the browser run and persist the answer.
+    if (engine === "browser" && isProModel(model))
+        return true;
+    // For API runs, explicit --wait keeps execution in the foreground.
     if (waitPreference)
         return false;
-    // Only Pro-tier API runs should start detached by default; browser runs stay inline so failures surface.
-    if (isProModel(model) && engine === "api")
+    // Pro-tier API runs start detached by default.
+    if ((isProModel(model) || reasoningMode === "pro") && engine === "api")
         return true;
     return false;
 }
+export function stopDetachedWorker(workerPid, kill = process.kill) {
+    try {
+        kill(workerPid, "SIGTERM");
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ESRCH") {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/src/cli/dryRun.js

@@ -5,6 +5,7 @@ import { assembleBrowserPrompt } from "../browser/prompt.js";
 import { buildTokenEstimateSuffix, formatAttachmentLabel } from "../browser/promptSummary.js";
 import { buildCookiePlan } from "../browser/policies.js";
 import { describeBrowserControlPlan, formatBrowserControlPlan } from "../browser/controlPlan.js";
+import { formatBrowserModelTarget } from "../browser/modelDisplay.js";
 export async function runDryRunSummary({ engine, runOptions, cwd, version, log, browserConfig, }, deps = {}) {
     if (engine === "browser") {
         await runBrowserDryRun({ runOptions, cwd, version, log, browserConfig }, deps);
@@ -45,7 +46,12 @@ async function runBrowserDryRun({ runOptions, cwd, version, log, browserConfig,
     const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
     const artifacts = await assemblePromptImpl(runOptions, { cwd });
     const suffix = buildTokenEstimateSuffix(artifacts);
-    const headerLine = `[dry-run] Oracle (${version}) would launch browser mode (${runOptions.model}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
+    const displayModel = formatBrowserModelTarget({
+        model: runOptions.model,
+        desiredModel: browserConfig?.desiredModel,
+        modelStrategy: browserConfig?.modelStrategy,
+    });
+    const headerLine = `[dry-run] Oracle (${version}) would launch browser mode (${displayModel}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
     log(chalk.cyan(headerLine));
     logBrowserControlPlan(browserConfig, log, "dry-run");
     logBrowserFollowUpSummary(runOptions.browserFollowUps, log, "dry-run");
@@ -95,7 +101,12 @@ export async function runBrowserPreview({ runOptions, cwd, version, previewMode,
     const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
     const artifacts = await assemblePromptImpl(runOptions, { cwd });
     const suffix = buildTokenEstimateSuffix(artifacts);
-    const headerLine = `[preview] Oracle (${version}) browser mode (${runOptions.model}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
+    const displayModel = formatBrowserModelTarget({
+        model: runOptions.model,
+        desiredModel: browserConfig?.desiredModel,
+        modelStrategy: browserConfig?.modelStrategy,
+    });
+    const headerLine = `[preview] Oracle (${version}) browser mode (${displayModel}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
     log(chalk.cyan(headerLine));
     logBrowserControlPlan(browserConfig, log, "preview");
     logBrowserFollowUpSummary(runOptions.browserFollowUps, log, "preview");

package/dist/src/cli/engine.js

@@ -1,7 +1,7 @@
 import { isProModel } from "../oracle/modelResolver.js";
-export function defaultWaitPreference(model, engine) {
+export function defaultWaitPreference(model, engine, reasoningMode) {
     // Pro-class API runs can take a long time; prefer non-blocking unless explicitly overridden.
-    if (engine === "api" && isProModel(model)) {
+    if (engine === "api" && (isProModel(model) || reasoningMode === "pro")) {
         return false;
     }
     return true; // browser or non-pro models are fast enough to block by default

package/dist/src/cli/options.js

@@ -187,6 +187,10 @@ export function resolveApiModel(modelValue) {
     if (normalized.includes("/")) {
         return normalized;
     }
+    const gpt56Label = parseBrowserGpt56Label(normalized);
+    if (gpt56Label?.variant.split(" ").includes("pro")) {
+        throw new InvalidArgumentError("GPT-5.6 Pro is an API reasoning mode, not a model slug. Use --model gpt-5.6-sol --reasoning-mode pro.");
+    }
     if (normalized.includes("grok")) {
         return "grok-4.1";
     }