@steipete/oracle 0.16.0 → 0.17.0

package/dist/src/cli/sessionRunner.js

@@ -78,6 +78,15 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 cwd,
                 log,
             }, runnerDeps);
+            await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            await sendSessionNotification({
+                sessionId: sessionMeta.id,
+                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+                mode,
+                model: sessionMeta.model,
+                usage: result.usage,
+                characters: result.answerText?.length,
+            }, notificationSettings, log, result.answerText?.slice(0, 140));
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
@@ -103,15 +112,6 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 transport: undefined,
                 error: undefined,
             });
-            await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
-            await sendSessionNotification({
-                sessionId: sessionMeta.id,
-                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
-                mode,
-                model: sessionMeta.model,
-                usage: result.usage,
-                characters: result.answerText?.length,
-            }, notificationSettings, log, result.answerText?.slice(0, 140));
             return;
         }
         const multiModels = Array.isArray(runOptions.models) ? runOptions.models.filter(Boolean) : [];
@@ -362,16 +362,6 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         if (result.mode !== "live") {
             throw new Error("Unexpected preview result while running a session.");
         }
-        await sessionStore.updateSession(sessionMeta.id, {
-            status: "completed",
-            completedAt: new Date().toISOString(),
-            usage: result.usage,
-            elapsedMs: result.elapsedMs,
-            errorMessage: undefined,
-            response: extractResponseMetadata(result.response),
-            transport: undefined,
-            error: undefined,
-        });
         if (modelForStatus && singleModelOverride == null) {
             await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                 status: "completed",
@@ -389,6 +379,16 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             usage: result.usage,
             characters: answerText.length,
         }, notificationSettings, log, answerText.slice(0, 140));
+        await sessionStore.updateSession(sessionMeta.id, {
+            status: "completed",
+            completedAt: new Date().toISOString(),
+            usage: result.usage,
+            elapsedMs: result.elapsedMs,
+            errorMessage: undefined,
+            response: extractResponseMetadata(result.response),
+            transport: undefined,
+            error: undefined,
+        });
     }
     catch (error) {
         const message = formatError(error);
@@ -469,22 +469,101 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 response: { status: "running", incompleteReason: "chrome-disconnected" },
             });
             logBrowserReattachGuidance(recoverableRuntime);
+            // Only auto-reattach when liveness classified the target as still alive.
+            // Closed-Chrome disconnects stay running + guidance but must not enter a
+            // futile resume loop (fail closed on availability).
+            const recoverableDisconnect = userError.details
+                ?.recoverableDisconnect === true;
+            if (!recoverableDisconnect) {
+                log(dim("Skipping auto-reattach: disconnect classified as non-recoverable."));
+                return;
+            }
+            // Connection-lost should attempt the same recovery path as assistant-timeout.
+            // When auto-reattach interval is unset, still try a single resume so a live
+            // Chrome/target can be harvested instead of leaving the session permanently running.
+            const configuredIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
+            const connectionLostIntervalMs = configuredIntervalMs > 0
+                ? configuredIntervalMs
+                : Math.max(1_000, Math.min(browserConfig?.timeoutMs ?? 30_000, 30_000));
+            const success = await autoReattachUntilComplete({
+                sessionMeta,
+                runtime: recoverableRuntime ?? undefined,
+                browserConfig: {
+                    ...browserConfig,
+                    autoReattachIntervalMs: connectionLostIntervalMs,
+                    autoReattachDelayMs: browserConfig?.autoReattachDelayMs ?? 0,
+                    autoReattachTimeoutMs: browserConfig?.autoReattachTimeoutMs ?? browserConfig?.timeoutMs ?? 120_000,
+                },
+                browserMetadata: currentBrowser,
+                runOptions,
+                modelForStatus,
+                notificationSettings,
+                log,
+                maxAttempts: configuredIntervalMs > 0 ? undefined : 1,
+            });
+            if (success) {
+                return;
+            }
             return;
         }
         if (assistantTimeout && mode === "browser" && browserCanReattach) {
             const runtime = userError.details
                 ?.runtime;
             log(dim("Assistant response timed out; marking capture incomplete for reattach."));
+            const timeoutResponse = {
+                status: "incomplete",
+                incompleteReason: "incomplete-capture",
+            };
+            const timeoutError = {
+                category: userError.category,
+                message: userError.message,
+                details: userError.details,
+            };
+            const autoReattachIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
+            const autoRuntime = runtime ?? currentBrowser?.runtime;
+            const willAutoReattach = autoReattachIntervalMs > 0 && Boolean(autoRuntime);
+            if (willAutoReattach) {
+                if (modelForStatus) {
+                    await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                        status: "running",
+                        completedAt: undefined,
+                        response: timeoutResponse,
+                        error: timeoutError,
+                    });
+                }
+                await sessionStore.updateSession(sessionMeta.id, {
+                    status: "running",
+                    completedAt: undefined,
+                    errorMessage: message,
+                    mode,
+                    browser: {
+                        ...currentBrowser,
+                        config: browserConfig,
+                        runtime: autoRuntime,
+                    },
+                    response: timeoutResponse,
+                    error: timeoutError,
+                });
+                const success = await autoReattachUntilComplete({
+                    sessionMeta,
+                    runtime: autoRuntime,
+                    browserConfig,
+                    browserMetadata: currentBrowser,
+                    runOptions,
+                    modelForStatus,
+                    notificationSettings,
+                    log,
+                });
+                if (success) {
+                    return;
+                }
+            }
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "error",
                     completedAt: new Date().toISOString(),
-                    response: { status: "incomplete", incompleteReason: "incomplete-capture" },
-                    error: {
-                        category: userError.category,
-                        message: userError.message,
-                        details: userError.details,
-                    },
+                    response: timeoutResponse,
+                    error: timeoutError,
                 });
             }
             await sessionStore.updateSession(sessionMeta.id, {
@@ -497,30 +576,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     config: browserConfig,
                     runtime: runtime ?? currentBrowser?.runtime,
                 },
-                response: { status: "incomplete", incompleteReason: "incomplete-capture" },
-                error: {
-                    category: userError.category,
-                    message: userError.message,
-                    details: userError.details,
-                },
+                response: timeoutResponse,
+                error: timeoutError,
             });
-            const autoReattachIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
-            if (autoReattachIntervalMs > 0) {
-                const autoRuntime = runtime ?? currentBrowser?.runtime;
-                const success = await autoReattachUntilComplete({
-                    sessionMeta,
-                    runtime: autoRuntime ?? undefined,
-                    browserConfig,
-                    browserMetadata: currentBrowser,
-                    runOptions,
-                    modelForStatus,
-                    notificationSettings,
-                    log,
-                });
-                if (success) {
-                    return;
-                }
-            }
             logBrowserReattachGuidance(runtime ?? currentBrowser?.runtime);
             return;
         }
@@ -833,7 +891,7 @@ async function writeAssistantOutput(targetPath, content, log) {
         log(dim(`write-output failed (${reason}); session completed anyway.`));
     }
 }
-async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, }) {
+async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, maxAttempts, }) {
     if (!runtime || !browserConfig) {
         log(dim("Auto-reattach disabled: missing runtime or browser config."));
         return false;
@@ -848,11 +906,19 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
         120_000;
     const maxTotalMs = 2 * 60 * 60 * 1000; // 2h hard cap; avoid infinite polling by default.
     const maxDeadline = Date.now() + maxTotalMs;
+    const attemptLimit = typeof maxAttempts === "number" && maxAttempts > 0
+        ? Math.floor(maxAttempts)
+        : Number.POSITIVE_INFINITY;
     if (delayMs > 0) {
         log(dim(`Auto-reattach starting in ${formatElapsed(delayMs)}...`));
         await wait(delayMs);
     }
-    log(dim(`Auto-reattach will stop after ${formatElapsed(maxTotalMs)} if no answer is captured.`));
+    if (Number.isFinite(attemptLimit)) {
+        log(dim(`Auto-reattach will try up to ${attemptLimit} attempt(s).`));
+    }
+    else {
+        log(dim(`Auto-reattach will stop after ${formatElapsed(maxTotalMs)} if no answer is captured.`));
+    }
     const logger = ((message) => {
         if (message) {
             log(dim(message));
@@ -868,6 +934,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
         }
         attempt += 1;
         log(dim(`Auto-reattach attempt ${attempt}...`));
+        let captureSucceeded = false;
         try {
             const reattachConfig = {
                 ...browserConfig,
@@ -876,6 +943,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
             const result = await resumeBrowserSession(runtime, reattachConfig, logger, {
                 promptPreview: sessionMeta.promptPreview,
             });
+            captureSucceeded = true;
             const answerText = result.answerMarkdown || result.answerText || "";
             const outputTokens = estimateTokenCount(answerText);
             const artifacts = await ensureSessionArtifacts({
@@ -904,6 +972,18 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                     },
                 });
             }
+            await writeAssistantOutput(runOptions.writeOutputPath, answerText, log);
+            await sendSessionNotification({
+                sessionId: sessionMeta.id,
+                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+                mode: sessionMeta.mode ?? "browser",
+                model: sessionMeta.model ?? runOptions.model,
+                usage: {
+                    inputTokens: 0,
+                    outputTokens,
+                },
+                characters: answerText.length,
+            }, notificationSettings, log, answerText.slice(0, 140));
             await sessionStore.updateSession(sessionMeta.id, {
                 status: "completed",
                 completedAt: new Date().toISOString(),
@@ -924,25 +1004,42 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 error: undefined,
                 transport: undefined,
             });
-            await writeAssistantOutput(runOptions.writeOutputPath, answerText, log);
-            await sendSessionNotification({
-                sessionId: sessionMeta.id,
-                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
-                mode: sessionMeta.mode ?? "browser",
-                model: sessionMeta.model ?? runOptions.model,
-                usage: {
-                    inputTokens: 0,
-                    outputTokens,
-                },
-                characters: answerText.length,
-            }, notificationSettings, log, answerText.slice(0, 140));
             log(kleur.green("Auto-reattach succeeded; session marked completed."));
             return true;
         }
         catch (error) {
+            if (captureSucceeded) {
+                const message = formatError(error);
+                if (modelForStatus) {
+                    await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                        status: "error",
+                        completedAt: new Date().toISOString(),
+                    });
+                }
+                await sessionStore.updateSession(sessionMeta.id, {
+                    status: "error",
+                    completedAt: new Date().toISOString(),
+                    errorMessage: message,
+                    browser: {
+                        ...browserMetadata,
+                        config: browserConfig,
+                        runtime,
+                    },
+                    response: { status: "error", incompleteReason: "incomplete-capture" },
+                    error: {
+                        category: "internal",
+                        message,
+                    },
+                });
+                throw error;
+            }
             const message = error instanceof Error ? error.message : String(error);
             log(dim(`Auto-reattach attempt ${attempt} failed: ${message}`));
         }
+        if (attempt >= attemptLimit) {
+            log(dim(`Auto-reattach stopped after ${attempt} attempt(s) without capturing an answer.`));
+            return false;
+        }
         const remainingAfterAttemptMs = maxDeadline - Date.now();
         if (remainingAfterAttemptMs <= 0) {
             log(dim(`Auto-reattach stopped after ${formatElapsed(maxTotalMs)} without capturing an answer.`));

package/dist/src/cli/sessionTable.js

@@ -3,6 +3,7 @@ import kleur from "kleur";
 import { MODEL_CONFIGS } from "../oracle.js";
 import { estimateUsdCost } from "tokentally";
 import { formatSessionExecutionLabel } from "./sessionLifecycle.js";
+import { resolveSessionBrowserModelDisplayName } from "../browser/modelDisplay.js";
 const isRich = (rich) => rich ?? Boolean(process.stdout.isTTY && chalk.level > 0);
 const dim = (text, rich) => (rich ? kleur.dim(text) : text);
 export const STATUS_PAD = 9;
@@ -18,7 +19,10 @@ export function formatSessionTableHeader(rich) {
 export function formatSessionTableRow(meta, options) {
     const rich = isRich(options?.rich);
     const status = colorStatus(meta.status ?? "unknown", rich);
-    const modelLabel = (meta.model ?? "n/a").padEnd(MODEL_PAD);
+    const displayModel = (meta.mode ?? meta.options?.mode) === "browser"
+        ? resolveSessionBrowserModelDisplayName(meta)
+        : (meta.model ?? "n/a");
+    const modelLabel = displayModel.padEnd(MODEL_PAD);
     const model = rich ? chalk.white(modelLabel) : modelLabel;
     const modeLabel = formatSessionExecutionLabel(meta).padEnd(MODE_PAD);
     const mode = rich ? chalk.gray(modeLabel) : modeLabel;

package/dist/src/cli/tui/index.js

@@ -15,6 +15,7 @@ import { resolveNotificationSettings } from "../notifier.js";
 import { loadUserConfig } from "../../config.js";
 import { resolveConfiguredMaxFileSizeBytes } from "../fileSize.js";
 import { formatTokenCount } from "../../oracle/runUtils.js";
+import { formatSessionBrowserModelWithRequestedKey, resolveSessionBrowserModelDisplayName, } from "../../browser/modelDisplay.js";
 const isTty = () => Boolean(process.stdout.isTTY && chalk.level > 0);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 const RECENT_WINDOW_HOURS = 24;
@@ -157,7 +158,7 @@ async function showSessionDetail(sessionId) {
         console.clear();
         printSessionHeader(meta);
         if (meta.models && meta.models.length > 0) {
-            printModelSummaries(meta.models);
+            printModelSummaries(meta);
         }
         const prompt = await readStoredPrompt(sessionId);
         if (prompt) {
@@ -250,7 +251,10 @@ function printSessionHeader(meta) {
     console.log(`${chalk.white("Status:")} ${meta.status}`);
     console.log(`${chalk.white("Created:")} ${meta.createdAt}`);
     if (meta.model) {
-        console.log(`${chalk.white("Model:")} ${meta.model}`);
+        const modelLabel = (meta.mode ?? meta.options?.mode) === "browser"
+            ? resolveSessionBrowserModelDisplayName(meta)
+            : meta.model;
+        console.log(`${chalk.white("Model:")} ${modelLabel}`);
     }
     const mode = meta.mode ?? meta.options?.mode;
     if (mode) {
@@ -260,7 +264,8 @@ function printSessionHeader(meta) {
         console.log(chalk.red(`Error: ${meta.errorMessage}`));
     }
 }
-function printModelSummaries(models) {
+function printModelSummaries(meta) {
+    const models = meta.models ?? [];
     if (models.length === 0) {
         return;
     }
@@ -269,7 +274,10 @@ function printModelSummaries(models) {
         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 = (meta.mode ?? meta.options?.mode) === "browser"
+            ? formatSessionBrowserModelWithRequestedKey(meta, run.model)
+            : run.model;
+        console.log(` - ${chalk.cyan(modelLabel)} — ${run.status}${usage}`);
     }
     console.log("");
 }

package/dist/src/duration.js

@@ -21,6 +21,9 @@ export function parseDuration(input, fallback) {
     let lastIndex = 0;
     let match = multiDuration.exec(normalized);
     while (match !== null) {
+        if (match.index !== lastIndex) {
+            return fallback;
+        }
         total += convertUnit(Number(match[1]), match[2]);
         lastIndex = multiDuration.lastIndex;
         match = multiDuration.exec(normalized);

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

@@ -12,11 +12,29 @@ const GEMINI_UPLOAD_MIME_TYPES = {
     ".gif": "image/gif",
     ".jpeg": "image/jpeg",
     ".jpg": "image/jpeg",
+    ".mov": "video/quicktime",
+    ".mp4": "video/mp4",
     ".pdf": "application/pdf",
     ".png": "image/png",
     ".svg": "image/svg+xml",
+    ".webm": "video/webm",
     ".webp": "image/webp",
 };
+/**
+ * Resolve the MIME type Gemini should be told an upload carries.
+ *
+ * Gemini silently discards uploads it cannot type: the run still reports the file as
+ * attached, but the model never receives it and answers as though nothing was sent.
+ * Anything falling back to `application/octet-stream` is therefore invisible to the model.
+ *
+ * Only formats confirmed to work against the Gemini web upload endpoint are listed. The
+ * endpoint also gates on the file extension, not just the declared type — an `.m4v` byte
+ * for byte identical to a working `.mp4`, and declared `video/mp4`, is still dropped — so
+ * entries here cannot be extrapolated from what the Gemini API documents.
+ */
+export function resolveGeminiUploadMimeType(filePath) {
+    return (GEMINI_UPLOAD_MIME_TYPES[path.extname(filePath).toLowerCase()] ?? "application/octet-stream");
+}
 function getNestedValue(value, pathParts, fallback) {
     let current = value;
     for (const part of pathParts) {
@@ -125,7 +143,7 @@ async function uploadGeminiFile(filePath, signal) {
     const absPath = path.resolve(process.cwd(), filePath);
     const data = await readFile(absPath);
     const fileName = path.basename(absPath);
-    const mimeType = GEMINI_UPLOAD_MIME_TYPES[path.extname(absPath).toLowerCase()] ?? "application/octet-stream";
+    const mimeType = resolveGeminiUploadMimeType(absPath);
     const form = new FormData();
     form.append("file", new Blob([data], { type: mimeType }), fileName);
     const res = await fetch(GEMINI_UPLOAD_URL, {

package/dist/src/oracle/modelResolver.js

@@ -192,7 +192,14 @@ async function resolveBaseModelConfig(model, options = {}) {
 export function isProModel(model) {
     return isKnownModel(model) && PRO_MODELS.has(model);
 }
-const VALID_REASONING_EFFORTS = ["low", "medium", "high", "xhigh"];
+const VALID_REASONING_EFFORTS = [
+    "none",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/src/oracle/request.js

@@ -11,8 +11,15 @@ export function buildPrompt(basePrompt, files, cwd = process.cwd()) {
     const sectionText = formatFileSections(sections, { includeFileIndex: true });
     return `${basePrompt.trim()}\n\n${sectionText}`;
 }
-export function buildRequestBody({ modelConfig, systemPrompt, userPrompt, searchEnabled, maxOutputTokens, background, storeResponse, previousResponseId, }) {
+export function buildRequestBody({ modelConfig, reasoningEffort, reasoningMode, systemPrompt, userPrompt, searchEnabled, maxOutputTokens, background, storeResponse, previousResponseId, }) {
     const searchToolType = modelConfig.searchToolType ?? "web_search_preview";
+    const reasoning = modelConfig.reasoning || reasoningEffort || reasoningMode
+        ? {
+            ...(modelConfig.reasoning ?? {}),
+            ...(reasoningEffort ? { effort: reasoningEffort } : {}),
+            ...(reasoningMode ? { mode: reasoningMode } : {}),
+        }
+        : undefined;
     return {
         model: modelConfig.apiModel ?? modelConfig.model,
         previous_response_id: previousResponseId ? previousResponseId : undefined,
@@ -29,7 +36,7 @@ export function buildRequestBody({ modelConfig, systemPrompt, userPrompt, search
             },
         ],
         tools: searchEnabled ? [{ type: searchToolType }] : undefined,
-        reasoning: modelConfig.reasoning || undefined,
+        reasoning,
         max_output_tokens: maxOutputTokens,
         background: background ? true : undefined,
         store: storeResponse ? true : undefined,

package/dist/src/oracle/run.js

@@ -33,6 +33,9 @@ const dim = (text) => (isStdoutTty ? kleur.dim(text) : text);
 // Default timeout for non-pro API runs (fast models) — give them up to 120s.
 const DEFAULT_TIMEOUT_NON_PRO_MS = 120_000;
 const DEFAULT_TIMEOUT_PRO_MS = 60 * 60 * 1000;
+const GPT_5_6_API_MODELS = new Set(["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]);
+const REASONING_EFFORTS = new Set(["none", "low", "medium", "high", "xhigh", "max"]);
+const REASONING_MODES = new Set(["standard", "pro"]);
 const defaultWait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
@@ -69,6 +72,33 @@ function runtimeKeySource({ route, providerMode, optionsApiKey, }) {
         return "XAI_API_KEY";
     return optionsApiKey ? "apiKey option" : route.keySource;
 }
+function validateReasoningOptions(options, route) {
+    const { reasoningEffort, reasoningMode } = options;
+    if (!reasoningEffort && !reasoningMode)
+        return;
+    if (reasoningEffort && !REASONING_EFFORTS.has(reasoningEffort)) {
+        throw new PromptValidationError(`Invalid reasoning effort "${reasoningEffort}". Expected none, low, medium, high, xhigh, or max.`, { model: options.model, reasoningEffort });
+    }
+    if (reasoningMode && !REASONING_MODES.has(reasoningMode)) {
+        throw new PromptValidationError(`Invalid reasoning mode "${reasoningMode}". Expected standard or pro.`, { model: options.model, reasoningMode });
+    }
+    if (!GPT_5_6_API_MODELS.has(options.model)) {
+        const option = reasoningMode
+            ? `Reasoning mode "${reasoningMode}"`
+            : `Reasoning effort "${reasoningEffort}"`;
+        const guidance = reasoningMode
+            ? `Use --model gpt-5.6-sol --reasoning-mode ${reasoningMode}.`
+            : `Use --model gpt-5.6-sol --reasoning-effort ${reasoningEffort}.`;
+        throw new PromptValidationError(`${option} is available only for GPT-5.6 API models. ${guidance}`, { model: options.model, reasoningEffort, reasoningMode });
+    }
+    if (reasoningMode &&
+        !route.isAzureOpenAI &&
+        (route.openRouterFallback ||
+            isOpenRouterBaseUrl(route.baseUrl) ||
+            isCustomBaseUrl(route.baseUrl))) {
+        throw new PromptValidationError("--reasoning-mode requires the OpenAI or Azure OpenAI Responses API; OpenRouter and custom --base-url routes use the Chat Completions adapter.", { model: options.model, reasoningMode });
+    }
+}
 export async function runOracle(options, deps = {}) {
     const { apiKey: optionsApiKey = options.apiKey, cwd = process.cwd(), fs: fsModule = createFsAdapter(fs), log = console.log, write: sinkWrite = (_text) => true, allowStdout = true, stdoutWrite: stdoutWriteDep, now = () => performance.now(), clientFactory = createDefaultClientFactory(), client, wait = defaultWait, } = deps;
     const stdoutWrite = allowStdout
@@ -100,6 +130,7 @@ export async function runOracle(options, deps = {}) {
     const { isAzureOpenAI, azureDeploymentName } = route;
     const baseUrl = route.baseUrl;
     const openRouterFallback = route.openRouterFallback;
+    validateReasoningOptions(options, route);
     const logVerbose = (message) => {
         if (options.verbose) {
             log(dim(`[verbose] ${message}`));
@@ -125,7 +156,7 @@ export async function runOracle(options, deps = {}) {
     const minPromptLength = Number.parseInt(process.env.ORACLE_MIN_PROMPT_CHARS ?? "10", 10);
     const promptLength = options.prompt?.trim().length ?? 0;
     // Enforce the short-prompt guardrail on pro-tier models because they're costly; cheaper models can run short prompts without blocking.
-    const isProTierModel = isProModel(options.model);
+    const isProTierModel = isProModel(options.model) || options.reasoningMode === "pro";
     if (isProTierModel && !Number.isNaN(minPromptLength) && promptLength < minPromptLength) {
         throw new PromptValidationError(`Prompt is too short (<${minPromptLength} chars). This was likely accidental; please provide more detail.`, { minPromptLength, promptLength });
     }
@@ -205,6 +236,8 @@ export async function runOracle(options, deps = {}) {
     }
     const requestBody = buildRequestBody({
         modelConfig,
+        reasoningEffort: options.reasoningEffort,
+        reasoningMode: options.reasoningMode,
         systemPrompt,
         userPrompt: promptWithFiles,
         searchEnabled,
@@ -249,6 +282,12 @@ export async function runOracle(options, deps = {}) {
         if (options.background && !supportsBackground) {
             log(dim("Background runs are not supported for this model; streaming in foreground instead."));
         }
+        if (options.reasoningMode) {
+            log(dim(`Reasoning mode: ${options.reasoningMode}`));
+        }
+        if (options.reasoningEffort) {
+            log(dim(`Reasoning effort: ${options.reasoningEffort}`));
+        }
         if (!options.suppressTips) {
             if (pendingNoFilesTip) {
                 log(dim(pendingNoFilesTip));
@@ -547,8 +586,9 @@ export async function runOracle(options, deps = {}) {
             },
         })?.totalUsd
         : undefined;
-    const effortLabel = modelConfig.reasoning?.effort;
-    const modelLabel = effortLabel ? `${modelConfig.model}[${effortLabel}]` : modelConfig.model;
+    const effortLabel = options.reasoningEffort ?? modelConfig.reasoning?.effort;
+    const reasoningLabel = [options.reasoningMode, effortLabel].filter(Boolean).join("/");
+    const modelLabel = reasoningLabel ? `${modelConfig.model}[${reasoningLabel}]` : modelConfig.model;
     const sessionIdContainsModel = typeof options.sessionId === "string" &&
         options.sessionId.toLowerCase().includes(modelConfig.model.toLowerCase());
     const tokensDisplay = [inputTokens, outputTokens, reasoningTokens, totalTokens]

package/dist/src/remote/server.js

@@ -189,6 +189,9 @@ export async function createRemoteServer(options = {}, deps = {}) {
                 }
             });
             automationLogger.verbose = Boolean(payload.options.verbose);
+            // Preserve an explicit request to leave the completed conversation tab
+            // open before the service forces `keepBrowser` for process lifetime.
+            const clientRequestedKeepBrowser = payload.browserConfig?.keepBrowser === true;
             // Remote runs always rely on the host's own Chrome profile; ignore any inline cookie transfer.
             if (payload.browserConfig) {
                 payload.browserConfig.inlineCookies = null;
@@ -212,6 +215,11 @@ export async function createRemoteServer(options = {}, deps = {}) {
                 attachments,
                 fallbackSubmission,
                 config: payload.browserConfig,
+                // `keepBrowser` above preserves the authenticated shared Chrome
+                // process. This separate service policy closes only a successfully
+                // captured tab owned by this run, preventing one renderer leak per
+                // request while incomplete/reattachable tabs remain untouched.
+                closeOwnedTabOnComplete: Boolean(options.manualLoginDefault && !clientRequestedKeepBrowser),
                 log: automationLogger,
                 heartbeatIntervalMs: payload.options.heartbeatIntervalMs,
                 verbose: payload.options.verbose,