@steipete/oracle 0.11.1 → 0.12.0

package/dist/src/cli/runOptions.js

@@ -5,41 +5,59 @@ import { resolveGeminiModelId } from "../oracle/gemini.js";
 import { PromptValidationError } from "../oracle/errors.js";
 import { normalizeChatGptModelForBrowser } from "./browserConfig.js";
 import { resolveConfiguredMaxFileSizeBytes } from "./fileSize.js";
+import { isAzureOpenAICandidateModel } from "../oracle/providerRouting.js";
 export function resolveRunOptionsFromConfig({ prompt, files = [], model, models, engine, userConfig, env = process.env, }) {
-    const resolvedEngine = resolveEngineWithConfig({ engine, configEngine: userConfig?.engine, env });
+    const resolvedEngine = resolveEngineWithConfig({
+        engine,
+        configEngine: userConfig?.engine,
+        env,
+    });
     const browserRequested = engine === "browser";
     const browserConfigured = userConfig?.engine === "browser";
+    const envBrowserConfigured = (env.ORACLE_ENGINE ?? "").trim().toLowerCase() === "browser";
     const requestedModelList = Array.isArray(models) ? models : [];
     const normalizedRequestedModels = requestedModelList
         .map((entry) => normalizeModelOption(entry))
         .filter(Boolean);
     const cliModelArg = normalizeModelOption(model ?? userConfig?.model) || DEFAULT_MODEL;
-    const inferredModel = resolvedEngine === "browser" && normalizedRequestedModels.length === 0
-        ? inferModelFromLabel(cliModelArg)
-        : resolveApiModel(cliModelArg);
-    // Browser engine maps Pro/legacy aliases to the latest ChatGPT picker targets.
-    const resolvedModel = resolvedEngine === "browser" ? normalizeChatGptModelForBrowser(inferredModel) : inferredModel;
-    const isCodex = resolvedModel.startsWith("gpt-5.1-codex");
-    const isClaude = resolvedModel.startsWith("claude");
-    const isGrok = resolvedModel.startsWith("grok");
-    const isGeminiApiOnly = resolvedModel === "gemini-3.1-pro";
+    const apiModel = resolveApiModel(cliModelArg);
+    const browserModel = normalizeChatGptModelForBrowser(inferModelFromLabel(cliModelArg));
+    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))))
-        : [resolvedModel];
+        : [apiModel];
+    const browserCompatibilityModels = normalizedRequestedModels.length > 0 ? allModels : [browserModel];
     const includesGeminiApiOnly = allModels.some((m) => m === "gemini-3.1-pro");
     if ((browserRequested || browserConfigured) && 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 = (browserRequested || browserConfigured) && allModels.some((m) => !isBrowserCompatible(m));
+    const hasNonBrowserCompatibleTarget = (browserRequested || browserConfigured) &&
+        browserCompatibilityModels.some((m) => !isBrowserCompatible(m));
     if (hasNonBrowserCompatibleTarget) {
         throw new PromptValidationError("Browser engine only supports GPT and Gemini models. Re-run with --engine api for Grok, Claude, or other models.", { engine: "browser", models: allModels });
     }
-    const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok || isGeminiApiOnly);
-    const fixedEngine = isCodex || isClaude || isGrok || isGeminiApiOnly || normalizedRequestedModels.length > 0
+    const azure = resolveAzureOptions(userConfig, env);
+    const azureAutoApi = Boolean(azure?.endpoint) &&
+        !browserRequested &&
+        !browserConfigured &&
+        !envBrowserConfigured &&
+        allModels.some(isAzureOpenAICandidateModel);
+    const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok || isGeminiApiOnly || azureAutoApi);
+    const fixedEngine = isCodex ||
+        isClaude ||
+        isGrok ||
+        isGeminiApiOnly ||
+        azureAutoApi ||
+        normalizedRequestedModels.length > 0
         ? "api"
         : resolvedEngine;
+    // Browser runs use ChatGPT picker labels/aliases; API runs must keep API model ids intact.
+    const resolvedModel = fixedEngine === "browser" ? browserModel : apiModel;
     const promptWithSuffix = userConfig?.promptSuffix && userConfig.promptSuffix.trim().length > 0
         ? `${prompt.trim()}\n${userConfig.promptSuffix}`
         : prompt;
@@ -66,11 +84,12 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
         filesReport: userConfig?.filesReport,
         background: userConfig?.background,
         baseUrl,
+        azure,
         effectiveModelId,
     };
     return { runOptions, resolvedEngine: fixedEngine, engineCoercedToApi };
 }
-function resolveEngineWithConfig({ engine, configEngine, env, }) {
+function resolveEngineWithConfig({ engine, configEngine, apiProviderRequested, env, }) {
     if (engine)
         return engine;
     const envOverride = (env.ORACLE_ENGINE ?? "").trim().toLowerCase();
@@ -79,7 +98,18 @@ function resolveEngineWithConfig({ engine, configEngine, env, }) {
     }
     if (configEngine)
         return configEngine;
-    return resolveEngine({ engine: undefined, env });
+    return resolveEngine({ engine: undefined, apiProviderRequested, env });
+}
+function resolveAzureOptions(userConfig, env) {
+    const endpoint = env.AZURE_OPENAI_ENDPOINT ?? userConfig?.azure?.endpoint;
+    if (!endpoint?.trim()) {
+        return undefined;
+    }
+    return {
+        endpoint,
+        deployment: env.AZURE_OPENAI_DEPLOYMENT ?? userConfig?.azure?.deployment,
+        apiVersion: env.AZURE_OPENAI_API_VERSION ?? userConfig?.azure?.apiVersion,
+    };
 }
 function resolveEffectiveModelId(model) {
     if (typeof model === "string" && model.startsWith("gemini")) {

package/dist/src/cli/sessionDisplay.js

@@ -10,6 +10,7 @@ import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportA
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatSessionTableHeader, formatSessionTableRow, resolveSessionCost, } from "./sessionTable.js";
 import { abbreviateResponseId, buildResponseOwnerIndex, resolveSessionLineage, } from "./sessionLineage.js";
+import { formatSessionExecutionLabel } from "./sessionLifecycle.js";
 const isTty = () => Boolean(process.stdout.isTTY);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 export const MAX_RENDER_BYTES = 200_000;
@@ -219,6 +220,8 @@ export async function attachSession(sessionId, options) {
                 browser: {
                     config: metadata.browser?.config,
                     runtime,
+                    modelSelection: metadata.browser?.modelSelection,
+                    warnings: metadata.browser?.warnings,
                 },
                 artifacts,
                 response: { status: "completed" },
@@ -266,6 +269,11 @@ export async function attachSession(sessionId, options) {
         }
         console.log(`Created: ${metadata.createdAt}`);
         console.log(`Status: ${metadata.status}`);
+        if (metadata.lifecycle) {
+            const attached = metadata.lifecycle.attached ? "attached" : "detached";
+            console.log(`Execution: ${formatSessionExecutionLabel(metadata)} (${attached})`);
+            console.log(`Reattach: ${metadata.lifecycle.reattachCommand}`);
+        }
         if (metadata.models && metadata.models.length > 0) {
             console.log("Models:");
             for (const run of metadata.models) {
@@ -278,6 +286,13 @@ export async function attachSession(sessionId, options) {
         else if (metadata.model) {
             console.log(`Model: ${metadata.model}`);
         }
+        const browserEvidence = formatBrowserEvidence(metadata);
+        if (browserEvidence) {
+            console.log("Browser evidence:");
+            for (const line of browserEvidence) {
+                console.log(dim(`- ${line}`));
+            }
+        }
         if (metadata.artifacts && metadata.artifacts.length > 0) {
             console.log("Artifacts:");
             for (const artifact of metadata.artifacts) {
@@ -299,7 +314,7 @@ export async function attachSession(sessionId, options) {
             console.log(dim(`User error: ${userErrorSummary}`));
         }
     }
-    const shouldTrimIntro = initialStatus === "completed" || initialStatus === "error";
+    const shouldTrimIntro = initialStatus === "completed" || initialStatus === "partial" || initialStatus === "error";
     if (options?.renderPrompt !== false) {
         const prompt = await readStoredPrompt(sessionId);
         if (prompt) {
@@ -422,7 +437,7 @@ export async function attachSession(sessionId, options) {
         if (!latest) {
             break;
         }
-        if (latest.status === "completed" || latest.status === "error") {
+        if (latest.status === "completed" || latest.status === "partial" || latest.status === "error") {
             await printNew();
             flushRemainder();
             if (!options?.suppressMetadata) {
@@ -430,10 +445,11 @@ export async function attachSession(sessionId, options) {
                     console.log("\nResult:");
                     console.log(`Session failed: ${latest.errorMessage}`);
                 }
-                if (latest.status === "completed" && latest.usage) {
+                if ((latest.status === "completed" || latest.status === "partial") && latest.usage) {
                     const summary = formatCompletionSummary(latest, { includeSlug: true });
                     if (summary) {
-                        console.log(`\n${chalk.green.bold(summary)}`);
+                        const color = latest.status === "partial" ? chalk.yellow.bold : chalk.green.bold;
+                        console.log(`\n${color(summary)}`);
                     }
                     else {
                         const usage = latest.usage;
@@ -495,6 +511,25 @@ export function formatUserErrorMetadata(metadata) {
     }
     return parts.length > 0 ? parts.join(" | ") : null;
 }
+export function formatBrowserEvidence(metadata) {
+    const browser = metadata.browser;
+    if (!browser?.modelSelection && (!browser?.warnings || browser.warnings.length === 0)) {
+        return null;
+    }
+    const lines = [];
+    const evidence = browser.modelSelection;
+    if (evidence) {
+        const requested = evidence.requestedModel ?? "(none)";
+        const resolved = evidence.resolvedLabel ?? "(unavailable)";
+        const strategy = evidence.strategy ?? "(default)";
+        const verified = evidence.verified ? "yes" : "no";
+        lines.push(`model requested=${requested}; resolved=${resolved}; status=${evidence.status}; strategy=${strategy}; verified=${verified}`);
+    }
+    for (const warning of browser.warnings ?? []) {
+        lines.push(`warning ${warning.code}: ${warning.message}`);
+    }
+    return lines.length > 0 ? lines : null;
+}
 export function buildReattachLine(metadata) {
     if (!metadata.id) {
         return null;

package/dist/src/cli/sessionLifecycle.js

@@ -0,0 +1,38 @@
+export function buildSessionLifecycle({ engine, detached, reattachCommand, }) {
+    return {
+        engine,
+        execution: detached ? "background" : "foreground",
+        attached: !detached,
+        detached,
+        reattachCommand,
+    };
+}
+export function formatSessionLifecycleBlock(meta) {
+    const lifecycle = meta.lifecycle;
+    if (!lifecycle) {
+        return [];
+    }
+    const modelCount = meta.models?.length ?? (meta.model ? 1 : 0);
+    const detachValue = lifecycle.detached
+        ? lifecycle.execution === "background"
+            ? "yes, polling"
+            : "yes"
+        : "no";
+    const lines = [
+        `Session: ${meta.id}`,
+        `Mode: ${lifecycle.engine} ${lifecycle.execution}`,
+        `Models: ${modelCount > 1 ? `${modelCount} parallel` : String(modelCount || 1)}`,
+        `Detach: ${detachValue}`,
+        `Reattach: ${lifecycle.reattachCommand}`,
+    ];
+    return lines;
+}
+export function formatSessionExecutionLabel(meta) {
+    const lifecycle = meta.lifecycle;
+    if (!lifecycle) {
+        return meta.mode ?? meta.options?.mode ?? "api";
+    }
+    const engine = lifecycle.engine === "browser" ? "br" : lifecycle.engine;
+    const execution = lifecycle.execution === "background" ? "bg" : "fg";
+    return `${engine}/${execution}`;
+}

package/dist/src/cli/sessionRunner.js

@@ -1,7 +1,7 @@
 import kleur from "kleur";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, } from "../oracle.js";
+import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, classifyProviderFailure, } from "../oracle.js";
 import { ensureSessionArtifacts, runBrowserSessionExecution, } from "../browser/sessionRunner.js";
 import { renderMarkdownAnsi } from "./markdownRenderer.js";
 import { formatResponseMetadata, formatTransportMetadata } from "./sessionDisplay.js";
@@ -82,6 +82,8 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     config: browserConfig,
                     runtime: result.runtime,
                     archive: result.archive,
+                    modelSelection: result.modelSelection,
+                    warnings: result.warnings,
                 },
                 artifacts: mergeArtifacts(sessionMeta.artifacts, result.artifacts),
                 response: undefined,
@@ -245,8 +247,13 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             });
             log(statusColor(line1));
             const hasFailure = summary.rejected.length > 0;
+            const allowPartial = runOptions.partialMode === "ok" && summary.fulfilled.length > 0;
+            if (hasFailure) {
+                const resultLabel = summary.fulfilled.length > 0 ? "partial success" : "failed";
+                log(statusColor(`Multi-model result: ${resultLabel}, ${summary.fulfilled.length}/${multiModels.length} succeeded`));
+            }
             await sessionStore.updateSession(sessionMeta.id, {
-                status: hasFailure ? "error" : "completed",
+                status: hasFailure ? (allowPartial ? "partial" : "error") : "completed",
                 completedAt: new Date().toISOString(),
                 usage: aggregateUsage,
                 elapsedMs: summary.elapsedMs,
@@ -273,15 +280,52 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                         savedOutputs.push({ model: entry.model, path: savedPath });
                     }
                 }
+                const sessionWithRuns = (await readSessionForManifest(sessionMeta.id)) ?? {
+                    ...sessionMeta,
+                    models: sessionMeta.models,
+                };
+                const runLogs = await collectMultiModelRunLogs(sessionMeta.id, sessionWithRuns.models, summary);
+                const manifestPath = await writeMultiModelOutputManifest({
+                    baseOutputPath: runOptions.writeOutputPath,
+                    sessionId: sessionMeta.id,
+                    status: hasFailure ? (allowPartial ? "partial" : "error") : "completed",
+                    summary,
+                    savedOutputs,
+                    modelRuns: sessionWithRuns.models,
+                    runLogs,
+                    runOptions,
+                    log,
+                });
                 if (savedOutputs.length > 0) {
                     log(dim("Saved outputs:"));
                     for (const item of savedOutputs) {
                         log(dim(`- ${item.model} -> ${item.path}`));
                     }
                 }
+                if (manifestPath) {
+                    log(dim(`Output manifest: ${manifestPath}`));
+                }
+                if (runLogs.length > 0) {
+                    log(dim(""));
+                    log(dim("Run logs:"));
+                    for (const item of runLogs) {
+                        log(dim(`- ${item.model} -> ${item.path}`));
+                    }
+                }
             }
             if (hasFailure) {
-                throw summary.rejected[0].reason;
+                log(dim("Failures:"));
+                for (const item of summary.rejected) {
+                    const providerContext = providerFailureContextForModel(item.model, runOptions);
+                    log(dim(`- ${item.model}: ${formatMultiModelFailure(item.reason, providerContext)}`));
+                    for (const line of formatMultiModelFailureDetails(item.reason, providerContext)) {
+                        log(dim(line));
+                    }
+                }
+            }
+            if (hasFailure && !allowPartial) {
+                const firstFailure = summary.rejected[0];
+                throw sanitizeMultiModelFailureForThrow(firstFailure.reason, providerFailureContextForModel(firstFailure.model, runOptions));
             }
             return;
         }
@@ -483,6 +527,187 @@ function mergeArtifacts(existing, additions) {
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function providerFailureContextForModel(model, runOptions) {
+    return {
+        model,
+        providerMode: runOptions.provider,
+        azure: runOptions.azure,
+        baseUrl: runOptions.baseUrl,
+        apiKey: runOptions.apiKey,
+    };
+}
+function formatMultiModelFailure(error, context) {
+    const userError = asOracleUserError(error);
+    if (userError) {
+        return `${userError.category}, ${userError.message}`;
+    }
+    const providerFailure = classifyProviderFailure(error, context);
+    if (providerFailure) {
+        return providerFailure.label;
+    }
+    if (error instanceof OracleTransportError) {
+        return `${error.reason}, ${error.message}`;
+    }
+    if (error instanceof OracleResponseError) {
+        return error.message;
+    }
+    return formatError(error);
+}
+function formatMultiModelFailureDetails(error, context) {
+    const providerFailure = classifyProviderFailure(error, context);
+    if (!providerFailure) {
+        return [];
+    }
+    const lines = [];
+    if (providerFailure.keyEnv) {
+        lines.push(`  key: ${providerFailure.keyEnv}`);
+    }
+    lines.push(`  provider said: ${providerFailure.providerMessage}`);
+    lines.push(`  fix: ${providerFailure.fix}`);
+    return lines;
+}
+function sanitizeMultiModelFailureForThrow(error, context) {
+    const providerFailure = classifyProviderFailure(error, context);
+    if (!providerFailure) {
+        return error;
+    }
+    const modelPrefix = typeof context === "object" && context?.model ? `${context.model}: ` : "";
+    const message = `${modelPrefix}${providerFailure.label}: ${providerFailure.providerMessage}`;
+    if (!(error instanceof Error)) {
+        return new Error(message);
+    }
+    error.message = message;
+    if (error.stack) {
+        const [firstLine, ...rest] = error.stack.split("\n");
+        const prefix = firstLine.includes(":") ? firstLine.split(":", 1)[0] : error.name;
+        error.stack = [prefix ? `${prefix}: ${message}` : message, ...rest].join("\n");
+    }
+    return error;
+}
+export function deriveOutputManifestPath(basePath) {
+    const ext = path.extname(basePath);
+    const stem = path.basename(basePath, ext);
+    const dir = path.dirname(basePath);
+    return path.join(dir, `${stem}.oracle.json`);
+}
+async function collectMultiModelRunLogs(sessionId, modelRuns, summary) {
+    const sessionDir = await resolveSessionDir(sessionId);
+    const logsByModel = new Map();
+    for (const run of modelRuns ?? []) {
+        if (run.log?.path) {
+            logsByModel.set(run.model, resolveSessionPath(sessionDir, run.log.path));
+        }
+    }
+    for (const entry of summary.fulfilled) {
+        if (!logsByModel.has(entry.model)) {
+            logsByModel.set(entry.model, entry.logPath);
+        }
+    }
+    return [...logsByModel.entries()].map(([model, logPath]) => ({ model, path: logPath }));
+}
+async function writeMultiModelOutputManifest({ baseOutputPath, sessionId, status, summary, savedOutputs, modelRuns, runLogs, runOptions, log, }) {
+    const manifestPath = deriveOutputManifestPath(baseOutputPath);
+    const normalizedTarget = path.resolve(manifestPath);
+    const normalizedSessionsDir = path.resolve(sessionStore.sessionsDir());
+    if (normalizedTarget === normalizedSessionsDir ||
+        normalizedTarget.startsWith(`${normalizedSessionsDir}${path.sep}`)) {
+        log(dim(`output manifest skipped: refusing to write inside session storage (${normalizedSessionsDir}).`));
+        return undefined;
+    }
+    const manifest = buildMultiModelOutputManifest({
+        baseOutputPath,
+        sessionId,
+        status,
+        summary,
+        savedOutputs,
+        modelRuns,
+        runLogs,
+        runOptions,
+    });
+    try {
+        await fs.mkdir(path.dirname(normalizedTarget), { recursive: true });
+        await fs.writeFile(normalizedTarget, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+        return normalizedTarget;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        log(dim(`output manifest failed (${reason}); session completed anyway.`));
+        return undefined;
+    }
+}
+function buildMultiModelOutputManifest({ baseOutputPath, sessionId, status, summary, savedOutputs, modelRuns, runLogs, runOptions, }) {
+    const outputByModel = new Map(savedOutputs.map((entry) => [entry.model, entry.path]));
+    const logsByModel = new Map(runLogs.map((entry) => [entry.model, entry.path]));
+    const runsByModel = new Map((modelRuns ?? []).map((run) => [run.model, run]));
+    const fulfilledByModel = new Map(summary.fulfilled.map((entry) => [entry.model, entry]));
+    const rejectedByModel = new Map(summary.rejected.map((entry) => [entry.model, entry.reason]));
+    const orderedModels = [
+        ...summary.fulfilled.map((entry) => entry.model),
+        ...summary.rejected.map((entry) => entry.model),
+    ];
+    return {
+        version: 1,
+        sessionId,
+        status,
+        outputBasePath: path.resolve(baseOutputPath),
+        createdAt: new Date().toISOString(),
+        models: orderedModels.map((model) => {
+            const run = runsByModel.get(model);
+            const fulfilled = fulfilledByModel.get(model);
+            const reason = rejectedByModel.get(model);
+            const userError = reason ? asOracleUserError(reason) : undefined;
+            const providerFailure = reason
+                ? classifyProviderFailure(reason, providerFailureContextForModel(model, runOptions))
+                : undefined;
+            return {
+                model,
+                status: fulfilled ? "completed" : reason ? "error" : (run?.status ?? "error"),
+                outputPath: outputByModel.get(model),
+                logPath: logsByModel.get(model),
+                errorCategory: run?.error?.category ?? userError?.category ?? providerFailure?.category,
+                errorMessage: run?.error?.message ??
+                    userError?.message ??
+                    providerFailure?.label ??
+                    (reason ? formatError(reason) : undefined),
+                elapsedMs: calculateModelElapsedMs(run),
+                usage: run?.usage ?? fulfilled?.usage,
+            };
+        }),
+    };
+}
+function calculateModelElapsedMs(run) {
+    if (!run?.startedAt || !run.completedAt) {
+        return undefined;
+    }
+    const startedMs = Date.parse(run.startedAt);
+    const completedMs = Date.parse(run.completedAt);
+    if (!Number.isFinite(startedMs) || !Number.isFinite(completedMs) || completedMs < startedMs) {
+        return undefined;
+    }
+    return completedMs - startedMs;
+}
+async function readSessionForManifest(sessionId) {
+    try {
+        return (await sessionStore.readSession(sessionId)) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveSessionDir(sessionId) {
+    try {
+        return (await sessionStore.getPaths(sessionId)).dir;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveSessionPath(sessionDir, targetPath) {
+    if (path.isAbsolute(targetPath) || !sessionDir) {
+        return targetPath;
+    }
+    return path.join(sessionDir, targetPath);
+}
 async function writeAssistantOutput(targetPath, content, log) {
     if (!targetPath)
         return;

package/dist/src/cli/sessionTable.js

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import kleur from "kleur";
 import { MODEL_CONFIGS } from "../oracle.js";
 import { estimateUsdCost } from "tokentally";
+import { formatSessionExecutionLabel } from "./sessionLifecycle.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;
@@ -19,7 +20,7 @@ export function formatSessionTableRow(meta, options) {
     const status = colorStatus(meta.status ?? "unknown", rich);
     const modelLabel = (meta.model ?? "n/a").padEnd(MODEL_PAD);
     const model = rich ? chalk.white(modelLabel) : modelLabel;
-    const modeLabel = (meta.mode ?? meta.options?.mode ?? "api").padEnd(MODE_PAD);
+    const modeLabel = formatSessionExecutionLabel(meta).padEnd(MODE_PAD);
     const mode = rich ? chalk.gray(modeLabel) : modeLabel;
     const timestampLabel = formatTimestampAligned(meta.createdAt).padEnd(TIMESTAMP_PAD);
     const timestamp = rich ? chalk.gray(timestampLabel) : timestampLabel;

package/dist/src/duration.js

@@ -0,0 +1,47 @@
+export function parseDuration(input, fallback) {
+    if (!input) {
+        return fallback;
+    }
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return fallback;
+    }
+    const lowercase = trimmed.toLowerCase();
+    if (/^[0-9]+$/.test(lowercase)) {
+        return Number(lowercase);
+    }
+    const normalized = lowercase.replace(/\s+/g, "");
+    const singleMatch = /^([0-9]+)(ms|s|m|h)$/i.exec(normalized);
+    if (singleMatch && singleMatch[0].length === normalized.length) {
+        const value = Number(singleMatch[1]);
+        return convertUnit(value, singleMatch[2]);
+    }
+    const multiDuration = /([0-9]+)(ms|h|m|s)/g;
+    let total = 0;
+    let lastIndex = 0;
+    let match = multiDuration.exec(normalized);
+    while (match !== null) {
+        total += convertUnit(Number(match[1]), match[2]);
+        lastIndex = multiDuration.lastIndex;
+        match = multiDuration.exec(normalized);
+    }
+    if (total > 0 && lastIndex === normalized.length) {
+        return total;
+    }
+    return fallback;
+}
+function convertUnit(value, unitRaw) {
+    const unit = unitRaw?.toLowerCase();
+    switch (unit) {
+        case "ms":
+            return value;
+        case "s":
+            return value * 1000;
+        case "m":
+            return value * 60_000;
+        case "h":
+            return value * 3_600_000;
+        default:
+            return value;
+    }
+}

package/dist/src/mcp/tools/consult.js

@@ -60,6 +60,10 @@ const consultInputShape = {
         .boolean()
         .optional()
         .describe("Browser-only: bundle many files into a single upload (helps with upload limits)."),
+    browserBundleFormat: z
+        .enum(["text", "zip"])
+        .optional()
+        .describe('Browser-only: bundle upload format when browserBundleFiles is true or auto-bundling is needed. Defaults to "text"; "zip" preserves individual file names in one uploaded archive.'),
     browserThinkingTime: z
         .enum(["light", "standard", "extended", "heavy"])
         .optional()
@@ -140,6 +144,7 @@ const consultDryRunResolvedShape = z.object({
         researchMode: z.string().nullable().optional(),
         attachments: z.string().optional(),
         bundleFiles: z.boolean().optional(),
+        bundleFormat: z.enum(["text", "zip"]).optional(),
         keepBrowser: z.boolean().optional(),
         manualLogin: z.boolean().optional(),
         profileDir: z.string().nullable().optional(),
@@ -196,7 +201,9 @@ export function buildConsultBrowserConfig({ userConfig, env, runModel, inputMode
         ? mapModelToBrowserLabel(runModel)
         : resolveBrowserModelLabel(preferredLabel, runModel);
     const configuredUrl = configuredBrowser.chatgptUrl ?? configuredBrowser.url ?? CHATGPT_URL;
-    const manualLogin = hasProfileDir ? true : (configuredBrowser.manualLogin ?? false);
+    const manualLogin = hasProfileDir
+        ? true
+        : (configuredBrowser.manualLogin ?? process.platform === "win32");
     return {
         ...configuredBrowser,
         url: configuredUrl,
@@ -224,6 +231,12 @@ export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browser
     }
     if (resolvedEngine === "browser") {
         guidance.push("Browser engine uses the signed-in ChatGPT profile; run dryRun:true before live use.");
+        if (browserConfig?.manualLogin) {
+            const profile = browserConfig.manualLoginProfileDir ?? "~/.oracle/browser-profile";
+            guidance.push(`Manual-login browser mode uses Oracle's private Chrome profile at ${profile}, separate from your normal Chrome profile.`);
+            guidance.push(`First-time setup: run oracle --engine browser --browser-manual-login --browser-keep-browser --browser-manual-login-profile-dir ${JSON.stringify(profile)} -p "HI", sign into ChatGPT in that window, then retry the consult.`);
+            guidance.push("If this profile is not signed in, non-setup MCP/browser runs fail fast instead of waiting for the full browser timeout.");
+        }
     }
     const desiredModel = browserConfig?.desiredModel ?? null;
     const thinkingTime = browserConfig?.thinkingTime ?? null;
@@ -251,6 +264,7 @@ export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browser
                 researchMode: browserConfig?.researchMode ?? null,
                 attachments: runOptions.browserAttachments,
                 bundleFiles: runOptions.browserBundleFiles,
+                bundleFormat: runOptions.browserBundleFormat,
                 keepBrowser: browserConfig?.keepBrowser,
                 manualLogin: browserConfig?.manualLogin,
                 profileDir: browserConfig?.manualLoginProfileDir ?? null,
@@ -277,6 +291,7 @@ export function formatConsultDryRunResolved(details) {
         lines.push(`  browser research mode: ${details.browser.researchMode ?? "off"}`);
         lines.push(`  browser attachments: ${details.browser.attachments ?? "auto"}`);
         lines.push(`  browser bundle files: ${details.browser.bundleFiles ? "yes" : "no"}`);
+        lines.push(`  browser bundle format: ${details.browser.bundleFormat ?? "text"}`);
         lines.push(`  browser keep browser: ${details.browser.keepBrowser ? "yes" : "no"}`);
         lines.push(`  browser manual login: ${details.browser.manualLogin ? "yes" : "no"}`);
         if (details.browser.profileDir) {
@@ -295,7 +310,7 @@ export function formatConsultDryRunResolved(details) {
 export function registerConsultTool(server) {
     server.registerTool("consult", {
         title: "Run an oracle session",
-        description: 'Run an Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then API when OPENAI_API_KEY is set, otherwise browser. Browser GPT-5.5 Pro consults can take many minutes; use `dryRun:true` first when configuring an agent and inspect `sessions`/`oracle status` before retrying. For browser-based image/file uploads, set `browserAttachments:"always"`. Browser consults can include `browserFollowUps` for a multi-turn ChatGPT review in one conversation. Sessions are stored under `ORACLE_HOME_DIR` (shared with the CLI).',
+        description: 'Run an Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then API when OPENAI_API_KEY is set, otherwise browser. Browser GPT-5.5 Pro consults can take many minutes; use `dryRun:true` first when configuring an agent and inspect `sessions`/`oracle status` before retrying. Browser manual-login uses a private Oracle Chrome profile separate from the user\'s normal Chrome; dry-run output includes first-time setup guidance when that path is active. For browser-based image/file uploads, set `browserAttachments:"always"`. Browser consults can include `browserFollowUps` for a multi-turn ChatGPT review in one conversation. Sessions are stored under `ORACLE_HOME_DIR` (shared with the CLI).',
         // Cast to any to satisfy SDK typings across differing Zod versions.
         inputSchema: consultInputShape,
         outputSchema: consultOutputShape,
@@ -311,7 +326,7 @@ export function registerConsultTool(server) {
                 content: textContent(error instanceof Error ? error.message : String(error)),
             };
         }
-        const { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserFollowUps, browserKeepBrowser, dryRun, slug, } = parsedInput;
+        const { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserBundleFormat, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserFollowUps, browserKeepBrowser, dryRun, slug, } = parsedInput;
         const { config: userConfig } = await loadUserConfig();
         const { runOptions, resolvedEngine } = mapConsultToRunOptions({
             prompt,
@@ -322,6 +337,7 @@ export function registerConsultTool(server) {
             search,
             browserAttachments,
             browserBundleFiles,
+            browserBundleFormat,
             browserFollowUps,
             userConfig,
             env: process.env,