@steipete/oracle 0.16.0 → 0.17.0

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/browserDefaults.js

@@ -11,6 +11,7 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     };
     const attachRunningRequested = options.browserAttachRunning === true ||
         (isUnset("browserAttachRunning") && browser.attachRunning === true);
+    const currentModelRequestedByCli = options.browserModelStrategy === "current" && getSource("browserModelStrategy") === "cli";
     const configuredChatgptUrl = browser.chatgptUrl ?? browser.url;
     const cliChatgptSet = options.chatgptUrl !== undefined || options.browserUrl !== undefined;
     if (isUnset("chatgptUrl") && !cliChatgptSet && configuredChatgptUrl !== undefined) {
@@ -89,7 +90,9 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     if (isUnset("browserModelStrategy") && browser.modelStrategy !== undefined) {
         options.browserModelStrategy = browser.modelStrategy;
     }
-    if (isUnset("browserThinkingTime") && browser.thinkingTime !== undefined) {
+    if (!currentModelRequestedByCli &&
+        isUnset("browserThinkingTime") &&
+        browser.thinkingTime !== undefined) {
         options.browserThinkingTime = normalizeThinkingTimeLevel(browser.thinkingTime) ?? undefined;
     }
     if (isUnset("browserResearch") && browser.researchMode !== undefined) {

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";
     }

package/dist/src/cli/sessionDisplay.js

@@ -12,6 +12,7 @@ import { estimateTokenCount } from "../browser/utils.js";
 import { formatSessionTableHeader, formatSessionTableRow, resolveSessionCost, } from "./sessionTable.js";
 import { abbreviateResponseId, buildResponseOwnerIndex, resolveSessionLineage, } from "./sessionLineage.js";
 import { formatSessionExecutionLabel } from "./sessionLifecycle.js";
+import { formatBrowserModelSelectionEvidence, formatSessionBrowserModelWithRequestedKey, resolveSessionBrowserModelDisplayName, } from "../browser/modelDisplay.js";
 const isTty = () => Boolean(process.stdout.isTTY);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 export const MAX_RENDER_BYTES = 200_000;
@@ -185,6 +186,7 @@ export async function attachSession(sessionId, options) {
     const isVerbose = Boolean(process.env.ORACLE_VERBOSE_RENDER);
     const runtime = metadata.browser?.runtime;
     const controllerAlive = isProcessAlive(runtime?.controllerPid);
+    const workerAlive = isProcessAlive(metadata.lifecycle?.workerPid);
     const hasChromeDisconnect = metadata.response?.incompleteReason === "chrome-disconnected";
     const hasIncompleteCapture = metadata.response?.incompleteReason === "incomplete-capture";
     const statusAllowsReattach = metadata.status === "running" ||
@@ -204,6 +206,7 @@ export async function attachSession(sessionId, options) {
     const canReattach = (statusAllowsReattach || completedDeepResearchPlaceholder) &&
         metadata.mode === "browser" &&
         hasFallbackSessionInfo &&
+        !workerAlive &&
         (hasRecoverableConversation ||
             runtime?.promptSubmitted ||
             hasLiveChromeFallback ||
@@ -311,11 +314,17 @@ export async function attachSession(sessionId, options) {
                 const usage = run.usage
                     ? ` tok=${formatTokenCount(run.usage.outputTokens ?? 0)}/${formatTokenCount(run.usage.totalTokens ?? 0)}`
                     : "";
-                console.log(`- ${chalk.cyan(run.model)} — ${run.status}${usage}`);
+                const modelLabel = (metadata.mode ?? metadata.options?.mode) === "browser"
+                    ? formatSessionBrowserModelWithRequestedKey(metadata, run.model)
+                    : run.model;
+                console.log(`- ${chalk.cyan(modelLabel)} — ${run.status}${usage}`);
             }
         }
         else if (metadata.model) {
-            console.log(`Model: ${metadata.model}`);
+            const modelLabel = (metadata.mode ?? metadata.options?.mode) === "browser"
+                ? formatSessionBrowserModelWithRequestedKey(metadata)
+                : metadata.model;
+            console.log(`Model: ${modelLabel}`);
         }
         const browserEvidence = formatBrowserEvidence(metadata);
         if (browserEvidence) {
@@ -391,6 +400,9 @@ export async function attachSession(sessionId, options) {
         if (summary) {
             console.log(`\n${chalk.green.bold(summary)}`);
         }
+        if (options?.propagateFailure && metadata.status === "error") {
+            process.exitCode = 1;
+        }
         return;
     }
     if (wantsRender) {
@@ -493,6 +505,48 @@ export async function attachSession(sessionId, options) {
                     }
                 }
             }
+            if (options?.propagateFailure && latest.status === "error") {
+                process.exitCode = 1;
+            }
+            break;
+        }
+        const controllerPid = latest.lifecycle?.workerPid ?? latest.browser?.runtime?.controllerPid;
+        if (latest.lifecycle?.detached && controllerPid && !isProcessAlive(controllerPid)) {
+            const settled = await sessionStore.readSession(sessionId);
+            if (!settled) {
+                break;
+            }
+            if (settled.status === "completed" || settled.status === "partial") {
+                continue;
+            }
+            await printNew();
+            flushRemainder();
+            const message = settled.status === "error"
+                ? (settled.errorMessage ?? "Detached worker failed.")
+                : "Detached worker exited before the session reached a terminal state.";
+            const failure = {
+                category: "internal",
+                message,
+            };
+            if (settled.model) {
+                await sessionStore.updateModelRun(settled.id, settled.model, {
+                    status: "error",
+                    completedAt: new Date().toISOString(),
+                    response: { status: "incomplete", incompleteReason: "incomplete-capture" },
+                    error: failure,
+                });
+            }
+            await sessionStore.updateSession(settled.id, {
+                status: "error",
+                completedAt: new Date().toISOString(),
+                errorMessage: message,
+                response: { status: "incomplete", incompleteReason: "incomplete-capture" },
+                error: failure,
+            });
+            console.log(chalk.yellow(`${message} Reattach via: ${settled.lifecycle?.reattachCommand}`));
+            if (options?.propagateFailure) {
+                process.exitCode = 1;
+            }
             break;
         }
         await wait(1000);
@@ -555,11 +609,7 @@ export function formatBrowserEvidence(metadata) {
     const lines = [];
     const evidence = browser.modelSelection;
     if (evidence) {
-        const requested = evidence.requestedModel ?? "(none)";
-        const resolved = evidence.resolvedLabel ?? "(unavailable)";
-        const strategy = evidence.strategy ?? "(default)";
-        const verified = evidence.verified ? "yes" : "no";
-        lines.push(`model requested=${requested}; resolved=${resolved}; status=${evidence.status}; strategy=${strategy}; verified=${verified}`);
+        lines.push(`model ${formatBrowserModelSelectionEvidence(evidence, metadata.model)}`);
     }
     for (const warning of browser.warnings ?? []) {
         lines.push(`warning ${warning.code}: ${warning.message}`);
@@ -821,7 +871,9 @@ export function formatCompletionSummary(metadata, options = {}) {
     if (!metadata.usage || metadata.elapsedMs == null) {
         return null;
     }
-    const modeLabel = metadata.mode === "browser" ? `${metadata.model ?? "n/a"}[browser]` : (metadata.model ?? "n/a");
+    const modeLabel = (metadata.mode ?? metadata.options?.mode) === "browser"
+        ? `${resolveSessionBrowserModelDisplayName(metadata)}[browser]`
+        : (metadata.model ?? "n/a");
     const usage = metadata.usage;
     const cost = resolveSessionCost(metadata);
     const tokensDisplay = [

package/dist/src/cli/sessionLifecycle.js

@@ -1,9 +1,10 @@
-export function buildSessionLifecycle({ engine, detached, reattachCommand, }) {
+export function buildSessionLifecycle({ engine, detached, workerPid, reattachCommand, }) {
     return {
         engine,
         execution: detached ? "background" : "foreground",
         attached: !detached,
         detached,
+        workerPid,
         reattachCommand,
     };
 }