@steipete/oracle 0.11.1 → 0.12.1

package/dist/src/oracle/run.js

@@ -4,7 +4,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 import { performance } from "node:perf_hooks";
-import { DEFAULT_SYSTEM_PROMPT, MODEL_CONFIGS, TOKENIZER_OPTIONS } from "./config.js";
+import { DEFAULT_SYSTEM_PROMPT, TOKENIZER_OPTIONS } from "./config.js";
 import { readFiles } from "./files.js";
 import { buildPrompt, buildRequestBody } from "./request.js";
 import { estimateRequestTokens } from "./tokenEstimate.js";
@@ -12,8 +12,9 @@ import { formatElapsed } from "./format.js";
 import { formatFinishLine } from "./finishLine.js";
 import { getFileTokenStats, printFileTokenStats } from "./tokenStats.js";
 import { OracleResponseError, OracleTransportError, PromptValidationError, describeTransportError, toTransportError, } from "./errors.js";
-import { createDefaultClientFactory, isCustomBaseUrl } from "./client.js";
-import { formatBaseUrlForLog, maskApiKey } from "./logging.js";
+import { isCustomBaseUrl } from "./baseUrl.js";
+import { createDefaultClientFactory } from "./client.js";
+import { maskApiKey } from "./logging.js";
 import { startHeartbeat } from "../heartbeat.js";
 import { startOscProgress } from "./oscProgress.js";
 import { createFsAdapter } from "./fsAdapter.js";
@@ -24,7 +25,9 @@ import { createMarkdownStreamer } from "markdansi";
 import { executeBackgroundResponse } from "./background.js";
 import { formatTokenEstimate, formatTokenValue, resolvePreviewMode } from "./runUtils.js";
 import { estimateUsdCost } from "tokentally";
-import { defaultOpenRouterBaseUrl, isKnownModel, isOpenRouterBaseUrl, isProModel, resolveModelConfig, normalizeOpenRouterBaseUrl, } from "./modelResolver.js";
+import { isOpenRouterBaseUrl, isProModel, resolveModelConfig } from "./modelResolver.js";
+import { validateProviderRouting } from "./providerRouting.js";
+import { formatRouteTargetForLog, resolveProviderRoute, } from "./providerRoutePlan.js";
 const isStdoutTty = process.stdout.isTTY && chalk.level > 0;
 const dim = (text) => (isStdoutTty ? kleur.dim(text) : text);
 // Default timeout for non-pro API runs (fast models) — give them up to 120s.
@@ -33,100 +36,84 @@ const DEFAULT_TIMEOUT_PRO_MS = 60 * 60 * 1000;
 const defaultWait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
+function formatProviderRouteLogLine(route, keySource) {
+    if (route.isAzureOpenAI) {
+        return `Provider: Azure OpenAI | endpoint: ${formatRouteTargetForLog(route.azureEndpoint)} | deployment: ${route.azureDeploymentName || "none"} | key: ${keySource}`;
+    }
+    return `Provider: ${route.providerLabel} | base: ${route.base} | key: ${keySource}`;
+}
+function runtimeKeySource({ route, providerMode, optionsApiKey, }) {
+    if (optionsApiKey &&
+        (route.isAzureOpenAI ||
+            providerMode === "openai" ||
+            route.provider === "openai" ||
+            route.providerLabel === "OpenAI-compatible")) {
+        return "apiKey option";
+    }
+    if (route.isAzureOpenAI) {
+        return "AZURE_OPENAI_API_KEY|OPENAI_API_KEY";
+    }
+    if (providerMode === "openai") {
+        return "OPENAI_API_KEY";
+    }
+    if (isOpenRouterBaseUrl(route.baseUrl) || route.openRouterFallback || route.model.includes("/")) {
+        return "OPENROUTER_API_KEY";
+    }
+    if (route.model.startsWith("gpt"))
+        return "OPENAI_API_KEY";
+    if (route.model.startsWith("gemini"))
+        return "GEMINI_API_KEY";
+    if (route.model.startsWith("claude"))
+        return "ANTHROPIC_API_KEY";
+    if (route.model.startsWith("grok"))
+        return "XAI_API_KEY";
+    return optionsApiKey ? "apiKey option" : route.keySource;
+}
 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
         ? (stdoutWriteDep ?? process.stdout.write.bind(process.stdout))
         : () => true;
     const isTty = allowStdout && isStdoutTty;
-    const resolvedXaiBaseUrl = process.env.XAI_BASE_URL?.trim() || "https://api.x.ai/v1";
-    const openRouterApiKey = process.env.OPENROUTER_API_KEY?.trim();
-    const defaultOpenRouterBase = defaultOpenRouterBaseUrl();
-    const knownModelConfig = isKnownModel(options.model) ? MODEL_CONFIGS[options.model] : undefined;
-    const provider = knownModelConfig?.provider ?? "other";
-    const hasOpenAIKey = Boolean(optionsApiKey) ||
-        Boolean(process.env.OPENAI_API_KEY) ||
-        Boolean(process.env.AZURE_OPENAI_API_KEY && options.azure?.endpoint);
-    const hasAnthropicKey = Boolean(optionsApiKey) || Boolean(process.env.ANTHROPIC_API_KEY);
-    const hasGeminiKey = Boolean(optionsApiKey) || Boolean(process.env.GEMINI_API_KEY);
-    const hasXaiKey = Boolean(optionsApiKey) || Boolean(process.env.XAI_API_KEY);
-    let baseUrl = options.baseUrl?.trim();
-    if (!baseUrl) {
-        if (options.model.startsWith("grok")) {
-            baseUrl = resolvedXaiBaseUrl;
-        }
-        else if (provider === "anthropic") {
-            baseUrl = process.env.ANTHROPIC_BASE_URL?.trim();
-        }
-        else {
-            baseUrl = process.env.OPENAI_BASE_URL?.trim();
-        }
-    }
-    const providerKeyMissing = (provider === "openai" && !hasOpenAIKey) ||
-        (provider === "anthropic" && !hasAnthropicKey) ||
-        (provider === "google" && !hasGeminiKey) ||
-        (provider === "xai" && !hasXaiKey) ||
-        provider === "other";
-    const openRouterFallback = providerKeyMissing && Boolean(openRouterApiKey);
-    if (!baseUrl || openRouterFallback) {
-        if (openRouterFallback) {
-            baseUrl = defaultOpenRouterBase;
-        }
-    }
-    if (baseUrl && isOpenRouterBaseUrl(baseUrl)) {
-        baseUrl = normalizeOpenRouterBaseUrl(baseUrl);
-    }
-    const logVerbose = (message) => {
-        if (options.verbose) {
-            log(dim(`[verbose] ${message}`));
-        }
-    };
     const previewMode = resolvePreviewMode(options.previewMode ?? options.preview);
     const isPreview = Boolean(previewMode);
-    const isAzureOpenAI = Boolean(options.azure?.endpoint);
-    const getApiKeyForModel = (model) => {
-        if (isOpenRouterBaseUrl(baseUrl) || openRouterFallback) {
-            return { key: optionsApiKey ?? openRouterApiKey, source: "OPENROUTER_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("gpt")) {
-            if (optionsApiKey)
-                return { key: optionsApiKey, source: "apiKey option" };
-            if (isAzureOpenAI) {
-                const key = process.env.AZURE_OPENAI_API_KEY ?? process.env.OPENAI_API_KEY;
-                return { key, source: "AZURE_OPENAI_API_KEY|OPENAI_API_KEY" };
+    const providerMode = options.provider ?? "auto";
+    validateProviderRouting({
+        model: options.model,
+        providerMode,
+        azure: options.azure,
+    }, {
+        onAzureDeploymentMissing: (state) => {
+            if (!isPreview && !options.suppressHeader) {
+                log(dim(`Provider: Azure OpenAI | endpoint: ${formatRouteTargetForLog(state.azureEndpoint)} | deployment: none | key: ${optionsApiKey ? "apiKey option" : "AZURE_OPENAI_API_KEY|OPENAI_API_KEY"}`));
             }
-            return { key: process.env.OPENAI_API_KEY, source: "OPENAI_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("gemini")) {
-            return { key: optionsApiKey ?? process.env.GEMINI_API_KEY, source: "GEMINI_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("claude")) {
-            return { key: optionsApiKey ?? process.env.ANTHROPIC_API_KEY, source: "ANTHROPIC_API_KEY" };
-        }
-        if (typeof model === "string" && model.startsWith("grok")) {
-            return { key: optionsApiKey ?? process.env.XAI_API_KEY, source: "XAI_API_KEY" };
+        },
+    });
+    const route = resolveProviderRoute({
+        model: options.model,
+        providerMode,
+        azure: options.azure,
+        baseUrl: options.baseUrl,
+        apiKey: optionsApiKey,
+        env: process.env,
+    });
+    const { isAzureOpenAI, azureDeploymentName } = route;
+    const baseUrl = route.baseUrl;
+    const openRouterFallback = route.openRouterFallback;
+    const logVerbose = (message) => {
+        if (options.verbose) {
+            log(dim(`[verbose] ${message}`));
         }
-        return {
-            key: optionsApiKey ?? openRouterApiKey,
-            source: optionsApiKey ? "apiKey option" : "OPENROUTER_API_KEY",
-        };
     };
-    const apiKeyResult = getApiKeyForModel(options.model);
-    const apiKey = apiKeyResult.key;
+    const apiKey = route.apiKey;
     if (!apiKey) {
-        const envVar = isOpenRouterBaseUrl(baseUrl) || openRouterFallback
-            ? "OPENROUTER_API_KEY"
-            : options.model.startsWith("gpt")
-                ? isAzureOpenAI
-                    ? "AZURE_OPENAI_API_KEY (or OPENAI_API_KEY)"
-                    : "OPENAI_API_KEY"
-                : options.model.startsWith("gemini")
-                    ? "GEMINI_API_KEY"
-                    : options.model.startsWith("claude")
-                        ? "ANTHROPIC_API_KEY"
-                        : options.model.startsWith("grok")
-                            ? "XAI_API_KEY"
-                            : "OPENROUTER_API_KEY";
+        const envVar = isAzureOpenAI
+            ? "AZURE_OPENAI_API_KEY (or OPENAI_API_KEY)"
+            : providerMode === "openai"
+                ? "OPENAI_API_KEY"
+                : isOpenRouterBaseUrl(baseUrl) || openRouterFallback
+                    ? "OPENROUTER_API_KEY"
+                    : route.keySource;
         const browserModeHint = options.model.startsWith("gpt")
             ? ' If you have a ChatGPT Pro subscription, retry with --engine browser (or MCP engine:"browser" / preset:"chatgpt-pro-heavy"); browser mode uses your signed-in ChatGPT session instead of an API key.'
             : "";
@@ -134,7 +121,7 @@ export async function runOracle(options, deps = {}) {
             env: envVar,
         });
     }
-    const envVar = apiKeyResult.source;
+    const envVar = runtimeKeySource({ route, providerMode, optionsApiKey });
     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.
@@ -142,7 +129,7 @@ export async function runOracle(options, deps = {}) {
     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 });
     }
-    const resolverOpenRouterApiKey = openRouterFallback || isOpenRouterBaseUrl(baseUrl) ? (openRouterApiKey ?? apiKey) : undefined;
+    const resolverOpenRouterApiKey = openRouterFallback || isOpenRouterBaseUrl(baseUrl) ? apiKey : undefined;
     const modelConfig = await resolveModelConfig(options.model, {
         baseUrl,
         openRouterApiKey: resolverOpenRouterApiKey,
@@ -199,14 +186,17 @@ export async function runOracle(options, deps = {}) {
             : DEFAULT_TIMEOUT_NON_PRO_MS / 1000
         : options.timeoutSeconds;
     const timeoutMs = timeoutSeconds * 1000;
-    const azureDeploymentName = isAzureOpenAI ? options.azure?.deployment?.trim() : undefined;
+    const httpTimeoutMs = typeof options.httpTimeoutMs === "number" &&
+        Number.isFinite(options.httpTimeoutMs) &&
+        options.httpTimeoutMs > 0
+        ? options.httpTimeoutMs
+        : timeoutMs;
     // Track the concrete model id we dispatch to (especially for Gemini preview aliases)
-    const effectiveModelId = options.effectiveModelId ??
-        (azureDeploymentName
-            ? azureDeploymentName
-            : options.model.startsWith("gemini")
-                ? resolveGeminiModelId(options.model)
-                : (modelConfig.apiModel ?? modelConfig.model));
+    const effectiveModelId = azureDeploymentName ??
+        options.effectiveModelId ??
+        (options.model.startsWith("gemini")
+            ? resolveGeminiModelId(options.model)
+            : (modelConfig.apiModel ?? modelConfig.model));
     if (!isPreview && options.previousResponseId) {
         log(dim(`Continuing from response ${options.previousResponseId}`));
     }
@@ -238,6 +228,7 @@ export async function runOracle(options, deps = {}) {
     if (!isPreview) {
         if (!options.suppressHeader) {
             log(headerLine);
+            log(dim(formatProviderRouteLogLine(route, envVar)));
         }
         const maskedKey = maskApiKey(apiKey);
         if (maskedKey && options.verbose) {
@@ -249,9 +240,6 @@ export async function runOracle(options, deps = {}) {
             effectiveModelId === "gpt-5.5-pro") {
             log(dim(`Note: \`${modelConfig.model}\` is a stable CLI alias; OpenAI API uses \`gpt-5.5-pro\`.`));
         }
-        if (baseUrl) {
-            log(dim(`Base URL: ${formatBaseUrlForLog(baseUrl)}`));
-        }
         if (effectiveModelId !== modelConfig.model) {
             log(dim(`Resolved model: ${modelConfig.model} → ${effectiveModelId}`));
         }
@@ -269,6 +257,11 @@ export async function runOracle(options, deps = {}) {
         if (isLongRunningModel) {
             log(dim("This model can take up to 60 minutes (usually replies much faster)."));
         }
+        if (options.verbose || isLongRunningModel || httpTimeoutMs < timeoutMs) {
+            const timeoutLine = `Timeouts | overall: ${formatElapsed(timeoutMs)} | transport: ${formatElapsed(httpTimeoutMs)}`;
+            const timeoutNote = httpTimeoutMs < timeoutMs ? " | note: transport can fail before overall timeout" : "";
+            log(dim(`${timeoutLine}${timeoutNote}`));
+        }
         if (options.verbose || isLongRunningModel) {
             log(dim("Press Ctrl+C to cancel."));
         }
@@ -300,25 +293,29 @@ export async function runOracle(options, deps = {}) {
             inputTokenBudget,
         };
     }
-    const proxyCompatibleBaseUrl = baseUrl && (isOpenRouterBaseUrl(baseUrl) || isCustomBaseUrl(baseUrl)) ? baseUrl : undefined;
-    const apiEndpoint = modelConfig.model.startsWith("gemini")
-        ? proxyCompatibleBaseUrl
-        : proxyCompatibleBaseUrl
+    const proxyCompatibleBaseUrl = !isAzureOpenAI && baseUrl && (isOpenRouterBaseUrl(baseUrl) || isCustomBaseUrl(baseUrl))
+        ? baseUrl
+        : undefined;
+    const apiEndpoint = isAzureOpenAI
+        ? undefined
+        : modelConfig.model.startsWith("gemini")
             ? proxyCompatibleBaseUrl
-            : modelConfig.model.startsWith("claude")
-                ? (process.env.ANTHROPIC_BASE_URL ?? baseUrl)
-                : baseUrl;
+            : proxyCompatibleBaseUrl
+                ? proxyCompatibleBaseUrl
+                : modelConfig.model.startsWith("claude")
+                    ? baseUrl
+                    : baseUrl;
     const clientInstance = client ??
         clientFactory(apiKey, {
             baseUrl: apiEndpoint,
-            azure: options.azure,
+            azure: isAzureOpenAI ? options.azure : undefined,
             model: options.model,
             resolvedModelId: modelConfig.model.startsWith("claude")
                 ? resolveClaudeModelId(effectiveModelId)
                 : modelConfig.model.startsWith("gemini")
                     ? resolveGeminiModelId(effectiveModelId)
                     : effectiveModelId,
-            httpTimeoutMs: options.httpTimeoutMs,
+            httpTimeoutMs,
         });
     logVerbose("Dispatching request to API...");
     if (options.verbose) {

package/dist/src/oracle.js

@@ -10,3 +10,4 @@ export { OracleResponseError, OracleTransportError, OracleUserError, FileValidat
 export { createDefaultClientFactory } from "./oracle/client.js";
 export { runOracle, extractTextOutput } from "./oracle/run.js";
 export { resolveGeminiModelId } from "./oracle/gemini.js";
+export { classifyProviderFailure } from "./oracle/providerFailures.js";

package/dist/src/remote/client.js

@@ -8,10 +8,18 @@ export function createRemoteBrowserExecutor({ host, token }) {
         const payload = {
             prompt: options.prompt,
             attachments: await serializeAttachments(options.attachments ?? []),
+            fallbackSubmission: options.fallbackSubmission
+                ? {
+                    prompt: options.fallbackSubmission.prompt,
+                    attachments: await serializeAttachments(options.fallbackSubmission.attachments ?? []),
+                }
+                : undefined,
             browserConfig: options.config ?? {},
             options: {
                 heartbeatIntervalMs: options.heartbeatIntervalMs,
                 verbose: options.verbose,
+                sessionId: options.sessionId,
+                followUpPrompts: options.followUpPrompts,
             },
         };
         const body = Buffer.from(JSON.stringify(payload));

package/dist/src/remote/server.js

@@ -119,6 +119,7 @@ export async function createRemoteServer(options = {}, deps = {}) {
             res.write(`${JSON.stringify(event)}\n`);
         };
         const attachments = [];
+        let fallbackSubmission;
         try {
             const attachmentsPayload = Array.isArray(payload.attachments) ? payload.attachments : [];
             for (const [index, attachment] of attachmentsPayload.entries()) {
@@ -131,6 +132,28 @@ export async function createRemoteServer(options = {}, deps = {}) {
                     sizeBytes: attachment.sizeBytes,
                 });
             }
+            if (payload.fallbackSubmission) {
+                const fallbackAttachmentDir = path.join(runDir, "fallback-attachments");
+                await mkdir(fallbackAttachmentDir, { recursive: true });
+                const fallbackAttachments = [];
+                const fallbackPayload = Array.isArray(payload.fallbackSubmission.attachments)
+                    ? payload.fallbackSubmission.attachments
+                    : [];
+                for (const [index, attachment] of fallbackPayload.entries()) {
+                    const safeName = sanitizeName(attachment.fileName ?? `fallback-attachment-${index + 1}`);
+                    const filePath = path.join(fallbackAttachmentDir, safeName);
+                    await writeFile(filePath, Buffer.from(attachment.contentBase64, "base64"));
+                    fallbackAttachments.push({
+                        path: filePath,
+                        displayPath: attachment.displayPath,
+                        sizeBytes: attachment.sizeBytes,
+                    });
+                }
+                fallbackSubmission = {
+                    prompt: payload.fallbackSubmission.prompt,
+                    attachments: fallbackAttachments,
+                };
+            }
             // Reuse the existing browser logger surface so clients see the same log stream.
             const automationLogger = ((message) => {
                 if (typeof message === "string") {
@@ -159,10 +182,13 @@ export async function createRemoteServer(options = {}, deps = {}) {
             const result = await runBrowser({
                 prompt: payload.prompt,
                 attachments,
+                fallbackSubmission,
                 config: payload.browserConfig,
                 log: automationLogger,
                 heartbeatIntervalMs: payload.options.heartbeatIntervalMs,
                 verbose: payload.options.verbose,
+                sessionId: payload.options.sessionId,
+                followUpPrompts: payload.options.followUpPrompts,
             });
             sendEvent({ type: "result", result: sanitizeResult(result) });
             logger(`[serve] Run ${runId} completed in ${Date.now() - runStartedAt}ms`);

package/dist/src/sessionManager.js

@@ -1,8 +1,9 @@
 import path from "node:path";
 import fs from "node:fs/promises";
-import { createWriteStream } from "node:fs";
+import { createWriteStream, mkdirSync } from "node:fs";
 import net from "node:net";
-import { DEFAULT_MODEL, formatElapsed } from "./oracle.js";
+import { DEFAULT_MODEL } from "./oracle/config.js";
+import { formatElapsed } from "./oracle/format.js";
 import { safeModelSlug } from "./oracle/modelResolver.js";
 import { getOracleHomeDir } from "./oracleHome.js";
 export function getSessionsDir() {
@@ -85,14 +86,26 @@ async function fileExists(targetPath) {
         return false;
     }
 }
-async function ensureUniqueSessionId(baseSlug) {
+function isFileExistsError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+async function reserveUniqueSessionDir(baseSlug) {
     let candidate = baseSlug;
     let suffix = 2;
-    while (await fileExists(sessionDir(candidate))) {
+    for (;;) {
+        const dir = sessionDir(candidate);
+        try {
+            await fs.mkdir(dir, { recursive: false });
+            return candidate;
+        }
+        catch (error) {
+            if (!isFileExistsError(error)) {
+                throw error;
+            }
+        }
         candidate = `${baseSlug}-${suffix}`;
         suffix += 1;
     }
-    return candidate;
 }
 async function listModelRunFiles(sessionId) {
     const dir = modelsDir(sessionId);
@@ -152,9 +165,7 @@ export async function readModelRunMetadata(sessionId, model) {
 export async function initializeSession(options, cwd, notifications, baseSlugOverride) {
     await ensureSessionStorage();
     const baseSlug = baseSlugOverride || createSessionId(options.prompt || DEFAULT_SLUG, options.slug);
-    const sessionId = await ensureUniqueSessionId(baseSlug);
-    const dir = sessionDir(sessionId);
-    await ensureDir(dir);
+    const sessionId = await reserveUniqueSessionDir(baseSlug);
     const mode = options.mode ?? "api";
     const browserConfig = options.browserConfig;
     const modelList = Array.isArray(options.models) && options.models.length > 0
@@ -199,8 +210,10 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
             browserAttachments: options.browserAttachments,
             browserInlineFiles: options.browserInlineFiles,
             browserBundleFiles: options.browserBundleFiles,
+            browserBundleFormat: options.browserBundleFormat,
             background: options.background,
             search: options.search,
+            provider: options.provider,
             baseUrl: options.baseUrl,
             azure: options.azure,
             timeoutSeconds: options.timeoutSeconds,
@@ -208,6 +221,7 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
             zombieTimeoutMs: options.zombieTimeoutMs,
             zombieUseLastActivity: options.zombieUseLastActivity,
             writeOutputPath: options.writeOutputPath,
+            partialMode: options.partialMode,
             waitPreference: options.waitPreference,
             youtube: options.youtube,
             generateImage: options.generateImage,
@@ -235,25 +249,25 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
     return metadata;
 }
 export async function readSessionMetadata(sessionId) {
-    const modern = await readModernSessionMetadata(sessionId);
+    const modern = await readModernSessionMetadata(sessionId, { reconcile: true, persist: false });
     if (modern) {
         return modern;
     }
-    const legacy = await readLegacySessionMetadata(sessionId);
+    const legacy = await readLegacySessionMetadata(sessionId, { reconcile: true, persist: false });
     if (legacy) {
         return legacy;
     }
     return null;
 }
 export async function updateSessionMetadata(sessionId, updates) {
-    const existing = (await readModernSessionMetadata(sessionId)) ??
-        (await readLegacySessionMetadata(sessionId)) ??
+    const existing = (await readModernSessionMetadata(sessionId, { reconcile: false, persist: false })) ??
+        (await readLegacySessionMetadata(sessionId, { reconcile: false, persist: false })) ??
         { id: sessionId };
     const next = { ...existing, ...updates };
     await fs.writeFile(metaPath(sessionId), JSON.stringify(next, null, 2), "utf8");
     return next;
 }
-async function readModernSessionMetadata(sessionId) {
+async function readModernSessionMetadata(sessionId, options) {
     try {
         const raw = await fs.readFile(metaPath(sessionId), "utf8");
         const parsed = JSON.parse(raw);
@@ -261,25 +275,31 @@ async function readModernSessionMetadata(sessionId) {
             return null;
         }
         const enriched = await attachModelRuns(parsed, sessionId);
-        const runtimeChecked = await markDeadBrowser(enriched, { persist: false });
-        return await markZombie(runtimeChecked, { persist: false });
+        return options.reconcile ? reconcileSessionMetadata(enriched, options) : enriched;
     }
     catch {
         return null;
     }
 }
-async function readLegacySessionMetadata(sessionId) {
+async function readLegacySessionMetadata(sessionId, options) {
     try {
         const raw = await fs.readFile(legacySessionPath(sessionId), "utf8");
         const parsed = JSON.parse(raw);
         const enriched = await attachModelRuns(parsed, sessionId);
-        const runtimeChecked = await markDeadBrowser(enriched, { persist: false });
-        return await markZombie(runtimeChecked, { persist: false });
+        return options.reconcile ? reconcileSessionMetadata(enriched, options) : enriched;
     }
     catch {
         return null;
     }
 }
+async function readRawSessionMetadata(sessionId) {
+    return ((await readModernSessionMetadata(sessionId, { reconcile: false, persist: false })) ??
+        (await readLegacySessionMetadata(sessionId, { reconcile: false, persist: false })));
+}
+async function reconcileSessionMetadata(meta, { persist }) {
+    const runtimeChecked = await markDeadBrowser(meta, { persist });
+    return await markZombie(runtimeChecked, { persist });
+}
 function isSessionMetadataRecord(value) {
     return Boolean(value && typeof value.id === "string" && value.status);
 }
@@ -293,7 +313,7 @@ async function attachModelRuns(meta, sessionId) {
 export function createSessionLogWriter(sessionId, model) {
     const targetPath = model ? modelLogPath(sessionId, model) : logPath(sessionId);
     if (model) {
-        void ensureDir(modelsDir(sessionId));
+        mkdirSync(modelsDir(sessionId), { recursive: true });
     }
     const stream = createWriteStream(targetPath, { flags: "a" });
     const logLine = (line = "") => {
@@ -310,10 +330,10 @@ export async function listSessionsMetadata() {
     const entries = await fs.readdir(getSessionsDir()).catch(() => []);
     const metas = [];
     for (const entry of entries) {
-        let meta = await readSessionMetadata(entry);
+        let meta = await readRawSessionMetadata(entry);
         if (meta) {
-            meta = await markDeadBrowser(meta, { persist: true });
-            meta = await markZombie(meta, { persist: true }); // keep stored metadata consistent with zombie detection
+            // Keep stored metadata consistent with status reconciliation done by `oracle status`.
+            meta = await reconcileSessionMetadata(meta, { persist: true });
             metas.push(meta);
         }
     }
@@ -384,7 +404,7 @@ export async function readModelLog(sessionId, model) {
     }
 }
 export async function readSessionRequest(sessionId) {
-    const modern = await readModernSessionMetadata(sessionId);
+    const modern = await readModernSessionMetadata(sessionId, { reconcile: false, persist: false });
     if (modern?.options) {
         return modern.options;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.5 Pro, GPT-5.5, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
   "homepage": "https://github.com/steipete/oracle#readme",
@@ -30,6 +30,7 @@
   "main": "dist/bin/oracle-cli.js",
   "scripts": {
     "docs:list": "tsx scripts/docs-list.ts",
+    "docs:check": "node --no-deprecation --import tsx bin/oracle-cli.ts docs check",
     "docs:site": "node scripts/build-docs-site.mjs",
     "build": "tsgo -p tsconfig.build.json && pnpm run build:vendor",
     "build:vendor": "node -e \"const fs=require('fs'); const path=require('path'); const vendorRoot=path.join('dist','vendor'); fs.rmSync(vendorRoot,{recursive:true,force:true}); const vendors=[['oracle-notifier']]; vendors.forEach(([name])=>{const src=path.join('vendor',name); const dest=path.join(vendorRoot,name); fs.mkdirSync(dest,{recursive:true}); if(fs.existsSync(src)){fs.cpSync(src,dest,{recursive:true,force:true});}});\"",
@@ -45,8 +46,9 @@
     "test": "vitest run",
     "test:mcp": "pnpm run build && pnpm run test:mcp:unit && pnpm run test:mcp:mcporter",
     "test:mcp:unit": "vitest run tests/mcp*.test.ts tests/mcp/**/*.test.ts",
-    "test:mcp:mcporter": "pnpm dlx mcporter list oracle-local --schema --config config/mcporter.json && pnpm dlx mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
+    "test:mcp:mcporter": "CHROME_DEVTOOLS_URL=http://127.0.0.1:0 pnpm dlx mcporter list oracle-local --schema --config config/mcporter.json && CHROME_DEVTOOLS_URL=http://127.0.0.1:0 pnpm dlx mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
     "test:browser": "pnpm run build && tsx scripts/test-browser.ts && ./scripts/browser-smoke.sh",
+    "test:packed-cli": "node scripts/packed-cli-smoke.mjs",
     "test:live": "ORACLE_LIVE_TEST=1 vitest run tests/live --exclude tests/live/openai-live.test.ts",
     "test:live:fast": "ORACLE_LIVE_TEST=1 ORACLE_LIVE_TEST_FAST=1 vitest run tests/live/browser-fast-live.test.ts",
     "test:pro": "ORACLE_LIVE_TEST=1 vitest run tests/live/openai-live.test.ts",
@@ -59,7 +61,7 @@
     "@google/genai": "^2.0.1",
     "@google/generative-ai": "^0.24.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@steipete/sweet-cookie": "^0.2.0",
+    "@steipete/sweet-cookie": "^0.3.0",
     "chalk": "^5.6.2",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.34.0",
@@ -68,11 +70,11 @@
     "dotenv": "^17.4.2",
     "fast-glob": "^3.3.3",
     "gpt-tokenizer": "^3.4.0",
-    "inquirer": "13.4.2",
+    "inquirer": "13.4.3",
     "json5": "^2.2.3",
     "kleur": "^4.1.5",
     "markdansi": "0.2.1",
-    "openai": "^6.35.0",
+    "openai": "^6.38.0",
     "osc-progress": "^0.3.0",
     "qs": "^6.15.1",
     "shiki": "^4.0.2",
@@ -82,17 +84,17 @@
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@types/chrome-remote-interface": "^0.33.0",
+    "@types/chrome-remote-interface": "^0.34.0",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.6.0",
-    "@typescript/native-preview": "7.0.0-dev.20260508.1",
-    "@vitest/coverage-v8": "4.1.5",
-    "devtools-protocol": "0.0.1627472",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1",
+    "@vitest/coverage-v8": "4.1.6",
+    "devtools-protocol": "0.0.1629771",
     "es-toolkit": "^1.46.1",
     "esbuild": "^0.28.0",
-    "oxfmt": "0.48.0",
+    "oxfmt": "0.50.0",
     "oxlint": "^1.62.0",
-    "puppeteer-core": "^24.42.0",
+    "puppeteer-core": "^25.0.2",
     "tsx": "^4.21.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"
@@ -111,7 +113,8 @@
   "packageManager": "pnpm@10.33.2",
   "pnpm": {
     "overrides": {
-      "devtools-protocol": "0.0.1627472"
+      "devtools-protocol": "0.0.1629771",
+      "vite": "7.3.2"
     },
     "onlyBuiltDependencies": [
       "esbuild"