@steipete/oracle 0.13.0 → 0.14.1

package/dist/src/cli/browserTabs.js

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import chalk from "chalk";
 import { sessionStore } from "../sessionStore.js";
 import { collectChatGptTabs, DEFAULT_REMOTE_CHROME_HOST, DEFAULT_REMOTE_CHROME_PORT, extractConversationIdFromUrl, formatBrowserTabState, harvestChatGptTab, sessionMatchesTab, } from "../browser/liveTabs.js";
+import { recoverConversationTab } from "../browser/recoverConversation.js";
 import { resolveOutputPath } from "./writeOutputPath.js";
 const LIVE_POLL_MS = 2000;
 const DEFAULT_STALL_THRESHOLD_MS = 60_000;
@@ -149,80 +150,154 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
     if (!meta) {
         throw new Error(`No session found with ID ${sessionId}.`);
     }
-    const endpoint = sessionBrowserEndpoint(meta) ?? {
+    const initialEndpoint = sessionBrowserEndpoint(meta) ?? {
         host: DEFAULT_REMOTE_CHROME_HOST,
         port: DEFAULT_REMOTE_CHROME_PORT,
     };
-    const harvested = await harvestChatGptTab({
-        host: endpoint.host,
-        port: endpoint.port,
-        ref: options.browserTabRef ?? resolveSessionTabRef(meta),
-        stallWindowMs: options.stallWindowMs,
-    });
-    await persistHarvest(sessionId, meta, harvested);
-    printHarvestSummary(sessionId, harvested);
-    const output = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "";
-    if (options.writeOutputPath) {
-        await maybeWriteHarvestOutput(options.writeOutputPath, meta.cwd ?? process.cwd(), output);
+    const ref = options.browserTabRef ?? resolveSessionTabRef(meta);
+    const recoverIfMissing = options.recoverIfMissing !== false;
+    let recoveredChrome = null;
+    try {
+        let harvested;
+        try {
+            harvested = await harvestChatGptTab({
+                host: initialEndpoint.host,
+                port: initialEndpoint.port,
+                ref,
+                stallWindowMs: options.stallWindowMs,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const isMissingTabError = message.includes("No ChatGPT tab matched") ||
+                message.includes("ECONNREFUSED") ||
+                message.includes("Could not connect");
+            if (!isMissingTabError || !recoverIfMissing) {
+                throw error;
+            }
+            console.log(chalk.yellow(`No live ChatGPT tab matched session "${sessionId}". Attempting recovery by reopening the saved conversation URL.`));
+            const recovered = await recoverConversationTab(meta, (line) => console.log(line));
+            recoveredChrome = recovered.chrome;
+            harvested = await harvestChatGptTab({
+                host: recovered.host,
+                port: recovered.port,
+                ref: recovered.url,
+                stallWindowMs: options.stallWindowMs,
+            });
+        }
+        await persistHarvest(sessionId, meta, harvested);
+        printHarvestSummary(sessionId, harvested);
+        const output = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "";
+        if (options.writeOutputPath) {
+            await maybeWriteHarvestOutput(options.writeOutputPath, meta.cwd ?? process.cwd(), output);
+        }
+        if (!options.quietOutput && output) {
+            process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
+        }
+        return harvested;
     }
-    if (!options.quietOutput && output) {
-        process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
+    finally {
+        if (recoveredChrome && options.closeAfterRecover) {
+            try {
+                recoveredChrome.kill();
+            }
+            catch {
+                // best-effort cleanup
+            }
+        }
     }
-    return harvested;
 }
 export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
     const meta = await sessionStore.readSession(sessionId);
     if (!meta) {
         throw new Error(`No session found with ID ${sessionId}.`);
     }
-    const endpoint = sessionBrowserEndpoint(meta) ?? {
+    let endpoint = sessionBrowserEndpoint(meta) ?? {
         host: DEFAULT_REMOTE_CHROME_HOST,
         port: DEFAULT_REMOTE_CHROME_PORT,
     };
-    const browserTabRef = options.browserTabRef ?? resolveSessionTabRef(meta);
+    let browserTabRef = options.browserTabRef ?? resolveSessionTabRef(meta);
+    const recoverIfMissing = options.recoverIfMissing !== false;
+    let recoveredChrome = null;
     const stallThresholdMs = options.stallThresholdMs ?? DEFAULT_STALL_THRESHOLD_MS;
     let lastHash = null;
     let unchangedSince = Date.now();
-    while (true) {
-        const harvested = await harvestChatGptTab({
-            host: endpoint.host,
-            port: endpoint.port,
-            ref: browserTabRef,
-        });
-        const fullText = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "";
-        const hash = createHash("sha1").update(fullText).digest("hex");
-        if (hash !== lastHash) {
-            lastHash = hash;
-            unchangedSince = Date.now();
-            const statusLine = `[${new Date().toISOString()}] state=${harvested.state} stop=${harvested.stopExists ? "yes" : "no"} ` +
-                `send=${harvested.sendExists ? "yes" : "no"} model=${harvested.currentModelLabel || "(unknown)"} ` +
-                `snippet=${snippet(harvested.lastAssistantSnippet || fullText, 160)}`;
-            console.log(statusLine);
-            await persistHarvest(sessionId, meta, harvested);
+    try {
+        // Probe once to see if the live tab is still alive; recover if not.
+        try {
+            await harvestChatGptTab({
+                host: endpoint.host,
+                port: endpoint.port,
+                ref: browserTabRef,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const isMissingTabError = message.includes("No ChatGPT tab matched") ||
+                message.includes("ECONNREFUSED") ||
+                message.includes("Could not connect");
+            if (!isMissingTabError || !recoverIfMissing) {
+                throw error;
+            }
+            console.log(chalk.yellow(`No live ChatGPT tab matched session "${sessionId}". Attempting recovery by reopening the saved conversation URL.`));
+            const recovered = await recoverConversationTab(meta, (line) => console.log(line));
+            recoveredChrome = recovered.chrome;
+            endpoint = { host: recovered.host, port: recovered.port };
+            browserTabRef = recovered.url;
         }
-        const derivedState = harvested.stopExists
-            ? Date.now() - unchangedSince >= stallThresholdMs
-                ? "stalled"
-                : "running"
-            : harvested.authenticated
-                ? "completed"
-                : "detached";
-        if (derivedState === "completed" || derivedState === "stalled" || derivedState === "detached") {
-            const finalHarvest = {
-                ...harvested,
-                state: derivedState,
-            };
-            await persistHarvest(sessionId, meta, finalHarvest);
-            printHarvestSummary(sessionId, finalHarvest);
-            const output = finalHarvest.lastAssistantMarkdown ?? finalHarvest.lastAssistantText ?? "";
-            if (options.writeOutputPath) {
-                await maybeWriteHarvestOutput(options.writeOutputPath, meta.cwd ?? process.cwd(), output);
+        while (true) {
+            const harvested = await harvestChatGptTab({
+                host: endpoint.host,
+                port: endpoint.port,
+                ref: browserTabRef,
+            });
+            const fullText = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "";
+            const hash = createHash("sha1").update(fullText).digest("hex");
+            if (hash !== lastHash) {
+                lastHash = hash;
+                unchangedSince = Date.now();
+                const statusLine = `[${new Date().toISOString()}] state=${harvested.state} stop=${harvested.stopExists ? "yes" : "no"} ` +
+                    `send=${harvested.sendExists ? "yes" : "no"} model=${harvested.currentModelLabel || "(unknown)"} ` +
+                    `snippet=${snippet(harvested.lastAssistantSnippet || fullText, 160)}`;
+                console.log(statusLine);
+                await persistHarvest(sessionId, meta, harvested);
+            }
+            const derivedState = harvested.stopExists
+                ? Date.now() - unchangedSince >= stallThresholdMs
+                    ? "stalled"
+                    : "running"
+                : harvested.authenticated
+                    ? "completed"
+                    : "detached";
+            if (derivedState === "completed" ||
+                derivedState === "stalled" ||
+                derivedState === "detached") {
+                const finalHarvest = {
+                    ...harvested,
+                    state: derivedState,
+                };
+                await persistHarvest(sessionId, meta, finalHarvest);
+                printHarvestSummary(sessionId, finalHarvest);
+                const output = finalHarvest.lastAssistantMarkdown ?? finalHarvest.lastAssistantText ?? "";
+                if (options.writeOutputPath) {
+                    await maybeWriteHarvestOutput(options.writeOutputPath, meta.cwd ?? process.cwd(), output);
+                }
+                if (output) {
+                    process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
+                }
+                return finalHarvest;
+            }
+            await new Promise((resolve) => setTimeout(resolve, LIVE_POLL_MS));
+        }
+    }
+    finally {
+        if (recoveredChrome && options.closeAfterRecover) {
+            try {
+                recoveredChrome.kill();
             }
-            if (output) {
-                process.stdout.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
+            catch {
+                // best-effort cleanup
             }
-            return finalHarvest;
         }
-        await new Promise((resolve) => setTimeout(resolve, LIVE_POLL_MS));
     }
 }

package/dist/src/cli/followup.js

@@ -0,0 +1,72 @@
+import { CHATGPT_URL } from "../browser/constants.js";
+import { buildConversationUrl } from "../browser/reattachHelpers.js";
+import { resolveRecoveryUrl } from "../browser/recoverConversation.js";
+import { isRecoverableChatGptConversationUrl } from "../browser/reattachability.js";
+import { DEFAULT_MODEL } from "../oracle/config.js";
+/**
+ * Resolve the ChatGPT conversation URL to reopen for a browser follow-up.
+ *
+ * Reuses the same recoverable-URL gate as conversation recovery
+ * (`resolveRecoveryUrl`): prefer the post-harvest URL, fall back to the
+ * runtime tab URL, and reject home / project-shell / external URLs via
+ * `isRecoverableChatGptConversationUrl`. Only when neither candidate is a
+ * recoverable `chatgpt.com/c/<id>` URL do we rebuild from a stored
+ * `conversationId` against the session's ChatGPT base — and that rebuilt URL is
+ * gated too. This prevents a stale or attacker-controlled URL in session
+ * metadata from navigating the signed-in browser profile somewhere unintended.
+ */
+export function resolveBrowserResumeConversationUrl(metadata, fallbackBaseUrl = CHATGPT_URL) {
+    const gatedUrl = resolveRecoveryUrl(metadata);
+    if (gatedUrl) {
+        return gatedUrl;
+    }
+    const conversationId = metadata.browser?.runtime?.conversationId?.trim();
+    if (!conversationId) {
+        return null;
+    }
+    const baseUrl = metadata.browser?.config?.url ?? fallbackBaseUrl;
+    const built = buildConversationUrl({ conversationId }, baseUrl);
+    if (built && isRecoverableChatGptConversationUrl(built)) {
+        return built;
+    }
+    return null;
+}
+export async function resolveBrowserFollowupReference(value, store) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.startsWith("resp_")) {
+        return null;
+    }
+    const metadata = await store.readSession(trimmed);
+    if (!metadata) {
+        return null;
+    }
+    const mode = metadata.mode ?? metadata.options?.mode;
+    const hasBrowserMetadata = Boolean(metadata.browser?.runtime || metadata.browser?.config || metadata.options?.browserConfig);
+    if (mode !== "browser" && !hasBrowserMetadata) {
+        return null;
+    }
+    const resumeConversationUrl = resolveBrowserResumeConversationUrl(metadata);
+    if (!resumeConversationUrl) {
+        throw new Error(`Session ${trimmed} is a browser session but does not contain a ChatGPT conversation URL. Run "oracle status --hours 72 --limit 20" to list recent sessions.`);
+    }
+    const parentBrowserConfig = metadata.options?.browserConfig ?? metadata.browser?.config;
+    if (!parentBrowserConfig) {
+        throw new Error(`Session ${trimmed} is missing its stored browser configuration.`);
+    }
+    const storedModel = metadata.options?.model ?? metadata.model;
+    const model = typeof storedModel === "string" && storedModel.startsWith("gpt-")
+        ? storedModel
+        : DEFAULT_MODEL;
+    return {
+        sessionId: metadata.id,
+        resumeConversationUrl,
+        model,
+        browserConfig: {
+            ...parentBrowserConfig,
+            browserTabRef: null,
+            resumeConversationUrl,
+            researchMode: "off",
+            archiveConversations: "never",
+        },
+    };
+}

package/dist/src/cli/help.js

@@ -49,7 +49,7 @@ function renderHelpFooter(program, colors) {
         `${colors.bullet("•")} Spell out the project + platform + version requirements (repo name, target OS/toolchain versions, API dependencies) so Oracle doesn’t guess defaults.`,
         `${colors.bullet("•")} When comparing multiple repos/files, spell out each repo + path + role (e.g., “Project A SettingsView → apps/project-a/Sources/SettingsView.swift; Project B SettingsView → ../project-b/mac/...”) so the model knows exactly which file is which.`,
         `${colors.bullet("•")} Best results: 6–30 sentences plus key source files; very short prompts often yield generic answers.`,
-        `${colors.bullet("•")} Oracle is one-shot by default. API runs can continue with ${colors.accent("--followup <sessionId|responseId>")}; browser runs can ask sequential ChatGPT turns with repeated ${colors.accent("--browser-follow-up")}.`,
+        `${colors.bullet("•")} Oracle is one-shot by default. Continue saved API or ChatGPT browser sessions with ${colors.accent("--followup <sessionId|responseId>")}; use repeated ${colors.accent("--browser-follow-up")} for planned same-run ChatGPT turns.`,
         `${colors.bullet("•")} Run ${colors.accent("--files-report")} to inspect token spend before hitting the API.`,
         `${colors.bullet("•")} Non-preview runs spawn detached sessions (especially gpt-5.5-pro API). If the CLI times out, do not re-run — reattach with ${colors.accent("oracle session <slug>")} to resume/inspect the existing run.`,
         `${colors.bullet("•")} Set a memorable 3–5 word slug via ${colors.accent('--slug "<words>"')} to keep session IDs tidy.`,

package/dist/src/cli/options.js

@@ -3,6 +3,7 @@ import { parseDuration } from "../duration.js";
 import path from "node:path";
 import fg from "fast-glob";
 import { DEFAULT_MODEL, MODEL_CONFIGS } from "../oracle/config.js";
+import { normalizeThinkingTimeLevel } from "../oracle/thinkingTime.js";
 export function collectPaths(value, previous = []) {
     if (!value) {
         return previous;
@@ -127,6 +128,13 @@ export function parseSearchOption(value) {
     }
     throw new InvalidArgumentError('Search mode must be "on" or "off".');
 }
+export function parseThinkingTimeOption(value) {
+    const normalized = normalizeThinkingTimeLevel(value);
+    if (normalized) {
+        return normalized;
+    }
+    throw new InvalidArgumentError('Thinking time must be one of "light", "standard", "extended", "heavy", or a ChatGPT UI alias like "instant", "medium", "high", or "extra-high".');
+}
 export function normalizeModelOption(value) {
     return (value ?? "").trim();
 }
@@ -228,6 +236,14 @@ export function resolveApiModel(modelValue) {
         throw new InvalidArgumentError("Gemini Deep Think is browser-only today. Use --engine browser --model gemini-3-deep-think.");
     }
     if (normalized.includes("gemini")) {
+        if (normalized.includes("3.5") && normalized.includes("flash")) {
+            return "gemini-3.5-flash";
+        }
+        if ((normalized.includes("3.1") || normalized.includes("3_1")) &&
+            normalized.includes("flash") &&
+            normalized.includes("lite")) {
+            return "gemini-3.1-flash-lite";
+        }
         if (normalized.includes("3.1") || normalized.includes("3_1")) {
             return "gemini-3.1-pro";
         }
@@ -266,6 +282,14 @@ export function inferModelFromLabel(modelValue) {
         return "gemini-3-pro-deep-think";
     }
     if (normalized.includes("gemini")) {
+        if (normalized.includes("3.5") && normalized.includes("flash")) {
+            return "gemini-3.5-flash";
+        }
+        if ((normalized.includes("3.1") || normalized.includes("3_1")) &&
+            normalized.includes("flash") &&
+            normalized.includes("lite")) {
+            return "gemini-3.1-flash-lite";
+        }
         if (normalized.includes("3.1") || normalized.includes("3_1")) {
             return "gemini-3.1-pro";
         }

package/dist/src/cli/reattachGuidance.js

@@ -0,0 +1,8 @@
+export function formatBrowserReattachGuidance(sessionId) {
+    return [
+        "This run did not return cleanly, but it may still be alive. Reattach:",
+        `  oracle session ${sessionId} --render    # final markdown when complete`,
+        `  oracle session ${sessionId} --live      # tail until done`,
+        `  oracle session ${sessionId} --harvest   # snapshot the current answer now`,
+    ].join("\n");
+}

package/dist/src/cli/runOptions.js

@@ -28,16 +28,11 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     const isCodex = apiModel.startsWith("gpt-5.1-codex");
     const isClaude = apiModel.startsWith("claude");
     const isGrok = apiModel.startsWith("grok");
-    const isGeminiApiOnly = apiModel === "gemini-3.1-pro";
     const engineWasBrowser = resolvedEngine === "browser";
     const allModels = normalizedRequestedModels.length > 0
         ? Array.from(new Set(normalizedRequestedModels.map((entry) => resolveApiModel(entry))))
         : [apiModel];
     const browserCompatibilityModels = normalizedRequestedModels.length > 0 ? allModels : [browserModel];
-    const includesGeminiApiOnly = allModels.some((m) => m === "gemini-3.1-pro");
-    if (browserEngineRequested && includesGeminiApiOnly) {
-        throw new PromptValidationError("gemini-3.1-pro is API-only today. Use --engine api or switch to gemini-3-pro for Gemini web.", { engine: "browser", models: allModels });
-    }
     const isBrowserCompatible = (m) => m.startsWith("gpt-") || m.startsWith("gemini");
     const hasNonBrowserCompatibleTarget = browserEngineRequested && browserCompatibilityModels.some((m) => !isBrowserCompatible(m));
     if (hasNonBrowserCompatibleTarget) {
@@ -47,13 +42,8 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     const azureAutoApi = Boolean(azure?.endpoint) &&
         !browserEngineRequested &&
         allModels.some(isAzureOpenAICandidateModel);
-    const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok || isGeminiApiOnly || azureAutoApi);
-    const fixedEngine = isCodex ||
-        isClaude ||
-        isGrok ||
-        isGeminiApiOnly ||
-        azureAutoApi ||
-        normalizedRequestedModels.length > 0
+    const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok || azureAutoApi);
+    const fixedEngine = isCodex || isClaude || isGrok || azureAutoApi || normalizedRequestedModels.length > 0
         ? "api"
         : resolvedEngine;
     // Browser runs use ChatGPT picker labels/aliases; API runs must keep API model ids intact.

package/dist/src/cli/sessionCommand.js

@@ -109,16 +109,20 @@ export async function handleSessionCommand(sessionId, command, deps = defaultDep
             process.exitCode = 1;
             return;
         }
+        // Commander sets `recover: false` when --no-recover is passed; default is `true`.
+        const recoverIfMissing = sessionOptions.recover !== false;
         if (harvestRequested) {
             await deps.harvestSessionBrowserOutput(sessionId, {
                 writeOutputPath,
                 browserTabRef,
+                recoverIfMissing,
             });
             return;
         }
         await deps.liveTailSessionBrowserOutput(sessionId, {
             writeOutputPath,
             browserTabRef,
+            recoverIfMissing,
         });
         return;
     }

package/dist/src/cli/sessionDisplay.js

@@ -628,6 +628,14 @@ function matchesModel(entry, filter) {
         (entry.model ? [entry.model.toLowerCase()] : []);
     return models.includes(normalized);
 }
+function formatLineageParentLabel(lineage) {
+    if (!lineage?.parentSessionId) {
+        return undefined;
+    }
+    return lineage.parentResponseId
+        ? `${lineage.parentSessionId} (${abbreviateResponseId(lineage.parentResponseId)})`
+        : lineage.parentSessionId;
+}
 function buildStatusTreeRows(entries, responseOwners) {
     const entryById = new Map(entries.map((entry) => [entry.id, entry]));
     const orderIndex = new Map(entries.map((entry, index) => [entry.id, index]));
@@ -668,7 +676,7 @@ function buildStatusTreeRows(entries, responseOwners) {
         visited.add(entry.id);
         const lineage = lineageById.get(entry.id);
         const hiddenParent = lineage?.parentSessionId && !entryById.has(lineage.parentSessionId)
-            ? `${lineage.parentSessionId} (${abbreviateResponseId(lineage.parentResponseId)})`
+            ? formatLineageParentLabel(lineage)
             : undefined;
         const children = childMap.get(entry.id) ?? [];
         rows.push({ entry, displaySlug: entry.id, detachedParentLabel: hiddenParent });
@@ -694,13 +702,19 @@ async function buildSessionChainLine(metadata) {
         return `root -> ${metadata.id}`;
     }
     if (lineageWithoutLookup.parentSessionId) {
-        return `${lineageWithoutLookup.parentSessionId} (${abbreviateResponseId(lineageWithoutLookup.parentResponseId)}) -> ${metadata.id}`;
+        return `${formatLineageParentLabel(lineageWithoutLookup)} -> ${metadata.id}`;
+    }
+    if (!lineageWithoutLookup.parentResponseId) {
+        return `root -> ${metadata.id}`;
     }
     const sessions = await sessionStore.listSessions().catch(() => []);
     const responseOwners = buildResponseOwnerIndex(sessions);
     const lineage = resolveSessionLineage(metadata, responseOwners) ?? lineageWithoutLookup;
     if (lineage.parentSessionId) {
-        return `${lineage.parentSessionId} (${abbreviateResponseId(lineage.parentResponseId)}) -> ${metadata.id}`;
+        return `${formatLineageParentLabel(lineage)} -> ${metadata.id}`;
+    }
+    if (!lineage.parentResponseId) {
+        return `root -> ${metadata.id}`;
     }
     return `${abbreviateResponseId(lineage.parentResponseId)} -> ${metadata.id}`;
 }

package/dist/src/cli/sessionLineage.js

@@ -39,17 +39,20 @@ export function buildResponseOwnerIndex(sessions) {
 }
 export function resolveSessionLineage(meta, responseOwners) {
     const previous = meta.options?.previousResponseId?.trim();
-    if (!previous) {
+    let parentSessionId = meta.options?.followupSessionId?.trim();
+    if (!previous && !parentSessionId) {
         return null;
     }
-    let parentSessionId = meta.options?.followupSessionId?.trim();
-    if (!parentSessionId && responseOwners) {
+    if (!parentSessionId && previous && responseOwners) {
         parentSessionId = responseOwners.get(previous);
     }
     if (parentSessionId === meta.id) {
         parentSessionId = undefined;
     }
-    return { parentResponseId: previous, parentSessionId };
+    return {
+        parentResponseId: previous || undefined,
+        parentSessionId,
+    };
 }
 export function abbreviateResponseId(responseId, max = 18) {
     if (responseId.length <= max) {

package/dist/src/cli/sessionRunner.js

@@ -24,6 +24,7 @@ import { resumeBrowserSession } from "../browser/reattach.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatElapsed } from "../oracle/format.js";
+import { formatBrowserReattachGuidance } from "./reattachGuidance.js";
 const isTty = process.stdout.isTTY;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
 export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, browserDeps, muteStdout = false, }) {
@@ -388,6 +389,16 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             userError.details?.stage === "assistant-timeout";
         const cloudflareChallenge = userError?.category === "browser-automation" &&
             userError.details?.stage === "cloudflare-challenge";
+        let reattachGuidanceLogged = false;
+        const logBrowserReattachGuidance = (runtime) => {
+            if (reattachGuidanceLogged || mode !== "browser")
+                return;
+            if (!hasRecoverableChatGptConversation(runtime) && runtime?.promptSubmitted !== true) {
+                return;
+            }
+            reattachGuidanceLogged = true;
+            log(formatBrowserReattachGuidance(sessionMeta.id));
+        };
         if (connectionLost && mode === "browser") {
             const runtime = userError.details
                 ?.runtime;
@@ -442,6 +453,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 },
                 response: { status: "running", incompleteReason: "chrome-disconnected" },
             });
+            logBrowserReattachGuidance(recoverableRuntime);
             return;
         }
         if (assistantTimeout && mode === "browser") {
@@ -492,7 +504,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     return;
                 }
             }
-            log(dim(`Reattach later with: oracle session ${sessionMeta.id}`));
+            logBrowserReattachGuidance(runtime ?? sessionMeta.browser?.runtime);
             return;
         }
         if (cloudflareChallenge && mode === "browser") {
@@ -518,6 +530,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         const browserRuntime = mode === "browser"
             ? userError?.details?.runtime
             : undefined;
+        if (!cloudflareChallenge) {
+            logBrowserReattachGuidance(browserRuntime ?? sessionMeta.browser?.runtime);
+        }
         await sessionStore.updateSession(sessionMeta.id, {
             status: "error",
             completedAt: new Date().toISOString(),

package/dist/src/gemini-web/client.js

@@ -1,13 +1,8 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { buildGeminiWebModelHeader, FALLBACK_GEMINI_WEB_MODEL, } from "./models.js";
 const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
 const MODEL_HEADER_NAME = "x-goog-ext-525001261-jspb";
-const MODEL_HEADERS = {
-    "gemini-3-pro": '[1,null,null,null,"9d8ca3786ebdfbea",null,null,0,[4]]',
-    "gemini-3-pro-deep-think": '[1,null,null,null,"e6fa609c3fa255c0",null,null,0,[4],null,null,3]',
-    "gemini-2.5-pro": '[1,null,null,null,"4af6c7f5da75d65d",null,null,0,[4]]',
-    "gemini-2.5-flash": '[1,null,null,null,"9ec249fc9ad08861",null,null,0,[4]]',
-};
 const GEMINI_APP_URL = "https://gemini.google.com/app";
 const GEMINI_STREAM_GENERATE_URL = "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate";
 const GEMINI_UPLOAD_URL = "https://content-push.googleapis.com/upload";
@@ -276,7 +271,7 @@ export async function runGeminiWebOnce(input) {
             "x-same-domain": "1",
             "user-agent": USER_AGENT,
             cookie: cookieHeader,
-            [MODEL_HEADER_NAME]: MODEL_HEADERS[input.model],
+            [MODEL_HEADER_NAME]: buildGeminiWebModelHeader(input.model),
         },
         body: params.toString(),
     });
@@ -324,9 +319,9 @@ export async function runGeminiWebOnce(input) {
 }
 export async function runGeminiWebWithFallback(input) {
     const attempt = await runGeminiWebOnce(input);
-    if (isGeminiModelUnavailable(attempt.errorCode) && input.model !== "gemini-2.5-flash") {
-        const fallback = await runGeminiWebOnce({ ...input, model: "gemini-2.5-flash" });
-        return { ...fallback, effectiveModel: "gemini-2.5-flash" };
+    if (isGeminiModelUnavailable(attempt.errorCode) && input.model !== FALLBACK_GEMINI_WEB_MODEL) {
+        const fallback = await runGeminiWebOnce({ ...input, model: FALLBACK_GEMINI_WEB_MODEL });
+        return { ...fallback, effectiveModel: FALLBACK_GEMINI_WEB_MODEL };
     }
     return { ...attempt, effectiveModel: input.model };
 }

package/dist/src/gemini-web/executor.js

@@ -4,6 +4,7 @@ import { runProviderDomFlow } from "../browser/providerDomFlow.js";
 import { delay } from "../browser/utils.js";
 import { runGeminiWebWithFallback, saveFirstGeminiImageFromOutput } from "./client.js";
 import { geminiDeepThinkDomProvider } from "../browser/providers/index.js";
+import { resolveGeminiWebModel } from "./models.js";
 import { openGeminiBrowserSession } from "./browserSessionManager.js";
 import { selectGeminiExecutionMode } from "./executionMode.js";
 const GEMINI_COOKIE_NAMES = [
@@ -38,30 +39,6 @@ function resolveInvocationPath(value) {
         return undefined;
     return path.isAbsolute(trimmed) ? trimmed : path.resolve(process.cwd(), trimmed);
 }
-function resolveGeminiWebModel(desiredModel, log) {
-    const desired = typeof desiredModel === "string" ? desiredModel.trim() : "";
-    if (!desired)
-        return "gemini-3-pro";
-    const normalized = desired.toLowerCase().replace(/[_\s]+/g, "-");
-    switch (normalized) {
-        case "gemini-3-pro":
-        case "gemini-3.0-pro":
-            return "gemini-3-pro";
-        case "gemini-3-deep-think":
-        case "gemini-3-pro-deep-think":
-        case "gemini-3-pro-deepthink":
-            return "gemini-3-pro-deep-think";
-        case "gemini-2.5-pro":
-            return "gemini-2.5-pro";
-        case "gemini-2.5-flash":
-            return "gemini-2.5-flash";
-        default:
-            if (normalized.startsWith("gemini-") || normalized.includes("gemini")) {
-                log?.(`[gemini-web] Unsupported Gemini web model "${desired}". Falling back to gemini-3-pro.`);
-            }
-            return "gemini-3-pro";
-    }
-}
 function resolveCookieDomain(cookie) {
     const rawDomain = cookie.domain?.trim();
     if (rawDomain) {