@steipete/oracle 0.11.1 → 0.12.1

package/dist/src/cli/perfTrace.js

@@ -0,0 +1,242 @@
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+const SECRET_VALUE_FLAGS = new Set([
+    "--api-key",
+    "--browser-follow-up",
+    "--browser-inline-cookies",
+    "--browser-inline-cookies-file",
+    "--message",
+    "--prompt",
+    "--remote-token",
+    "--token",
+    "-p",
+]);
+const VALUE_FLAGS = new Set([
+    "--aspect",
+    "--azure-api-version",
+    "--azure-deployment",
+    "--azure-endpoint",
+    "--base-url",
+    "--browser-archive",
+    "--browser-attachments",
+    "--browser-auto-reattach-delay",
+    "--browser-auto-reattach-interval",
+    "--browser-auto-reattach-timeout",
+    "--browser-bundle-format",
+    "--browser-cookie-names",
+    "--browser-cookie-path",
+    "--browser-cookie-wait",
+    "--browser-input-timeout",
+    "--browser-max-concurrent-tabs",
+    "--browser-model-strategy",
+    "--browser-port",
+    "--browser-profile-lock-timeout",
+    "--browser-recheck-delay",
+    "--browser-recheck-timeout",
+    "--browser-research",
+    "--browser-reuse-wait",
+    "--browser-tab",
+    "--browser-timeout",
+    "--browser-url",
+    "--chatgpt-url",
+    "--engine",
+    "--followup",
+    "--followup-model",
+    "--heartbeat",
+    "--http-timeout",
+    "--max-file-size-bytes",
+    "--model",
+    "--models",
+    "--output",
+    "--partial",
+    "--perf-trace-path",
+    "--provider",
+    "--remote-chrome",
+    "--remote-host",
+    "--slug",
+    "--timeout",
+    "--write-output",
+    "--youtube",
+    "--zombie-timeout",
+    "-e",
+    "-m",
+    "-s",
+]);
+export function isTraceValueFlag(flag) {
+    return SECRET_VALUE_FLAGS.has(flag) || VALUE_FLAGS.has(flag);
+}
+class DisabledPerfTrace {
+    mark() { }
+    wrapFirstOutput() { }
+    flush() { }
+}
+class FilePerfTrace {
+    outputPath;
+    options;
+    events = [];
+    wrapped = false;
+    firstOutput = false;
+    flushed = false;
+    constructor(outputPath, options) {
+        this.outputPath = outputPath;
+        this.options = options;
+    }
+    mark(name, data) {
+        this.events.push({
+            name,
+            ms: Number(performance.now().toFixed(3)),
+            data,
+        });
+    }
+    wrapFirstOutput() {
+        if (this.wrapped)
+            return;
+        this.wrapped = true;
+        const wrap = (stream) => {
+            const original = stream.write.bind(stream);
+            stream.write = ((...args) => {
+                if (!this.firstOutput) {
+                    this.firstOutput = true;
+                    this.mark("first-output", {
+                        stream: stream === process.stderr ? "stderr" : "stdout",
+                    });
+                }
+                return original(...args);
+            });
+        };
+        wrap(process.stdout);
+        wrap(process.stderr);
+    }
+    flush(exitCode) {
+        if (this.flushed)
+            return;
+        this.flushed = true;
+        this.mark("exit", { exitCode: exitCode ?? 0 });
+        const payload = {
+            version: this.options.version,
+            argv: sanitizeTraceArgv(this.options.argv),
+            cwd: this.options.cwd ?? process.cwd(),
+            pid: process.pid,
+            node: process.version,
+            timeOrigin: performance.timeOrigin,
+            totalMs: Number(performance.now().toFixed(3)),
+            events: this.events,
+        };
+        writeFileSync(this.outputPath, `${JSON.stringify(payload, null, 2)}\n`);
+    }
+}
+export function createPerfTrace(options) {
+    const envValue = process.env.ORACLE_PERF_TRACE;
+    const optionValue = options.value;
+    if (!optionValue && !envValue) {
+        return new DisabledPerfTrace();
+    }
+    const rawValue = typeof optionValue === "string" ? optionValue : envValue;
+    const outputPath = rawValue && rawValue !== "1" && rawValue !== "true"
+        ? path.resolve(options.cwd ?? process.cwd(), rawValue)
+        : path.join(options.cwd ?? process.cwd(), `.oracle-perf-${new Date().toISOString().replace(/[:.]/g, "-")}-${process.pid}.json`);
+    const trace = new FilePerfTrace(outputPath, options);
+    trace.wrapFirstOutput();
+    trace.mark("cli-module-ready");
+    return trace;
+}
+export function deriveDetachedPerfTraceEnv(value, sessionId) {
+    const trimmed = value?.trim();
+    if (!trimmed || trimmed === "1" || trimmed.toLowerCase() === "true")
+        return value;
+    const safeSessionId = sessionId.replace(/[^A-Za-z0-9._-]/g, "_");
+    const lastSlash = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+    const lastDot = trimmed.lastIndexOf(".");
+    if (lastDot > lastSlash) {
+        return `${trimmed.slice(0, lastDot)}.${safeSessionId}${trimmed.slice(lastDot)}`;
+    }
+    return `${trimmed}.${safeSessionId}.json`;
+}
+export function resolveDetachedPerfTraceEnv(cliValue, envValue, sessionId) {
+    if (typeof cliValue === "string") {
+        return deriveDetachedPerfTraceEnv(cliValue, sessionId);
+    }
+    if (cliValue === true) {
+        return "1";
+    }
+    return deriveDetachedPerfTraceEnv(envValue, sessionId);
+}
+export function buildDetachedPerfTraceEnv(env, cliValue, sessionId) {
+    const nextEnv = { ...env };
+    const traceValue = resolveDetachedPerfTraceEnv(cliValue, env.ORACLE_PERF_TRACE, sessionId);
+    if (traceValue) {
+        nextEnv.ORACLE_PERF_TRACE = traceValue;
+    }
+    else {
+        delete nextEnv.ORACLE_PERF_TRACE;
+    }
+    return nextEnv;
+}
+export function sanitizeTraceArgv(argv) {
+    const sanitized = [];
+    let redactNext = false;
+    let valueNext = false;
+    let afterDoubleDash = false;
+    for (const arg of argv) {
+        if (afterDoubleDash) {
+            sanitized.push("[redacted-positional]");
+            continue;
+        }
+        if (arg === "--") {
+            sanitized.push(arg);
+            afterDoubleDash = true;
+            continue;
+        }
+        if (redactNext) {
+            sanitized.push("[redacted]");
+            redactNext = false;
+            continue;
+        }
+        if (valueNext) {
+            sanitized.push(redactPotentialSecret(arg));
+            valueNext = false;
+            continue;
+        }
+        const equalsIndex = arg.indexOf("=");
+        const flag = equalsIndex >= 0 ? arg.slice(0, equalsIndex) : arg;
+        if (equalsIndex >= 0 && SECRET_VALUE_FLAGS.has(flag)) {
+            sanitized.push(`${flag}=[redacted]`);
+            continue;
+        }
+        if (arg.startsWith("-p") && arg.length > 2) {
+            sanitized.push("-p[redacted]");
+            continue;
+        }
+        if (equalsIndex >= 0) {
+            sanitized.push(`${flag}=${redactPotentialSecret(arg.slice(equalsIndex + 1))}`);
+            continue;
+        }
+        if (SECRET_VALUE_FLAGS.has(arg)) {
+            sanitized.push(arg);
+            redactNext = true;
+            continue;
+        }
+        if (VALUE_FLAGS.has(arg)) {
+            sanitized.push(arg);
+            valueNext = true;
+            continue;
+        }
+        if (!arg.startsWith("-")) {
+            sanitized.push("[redacted-positional]");
+            continue;
+        }
+        sanitized.push(arg);
+    }
+    return sanitized;
+}
+function redactPotentialSecret(value) {
+    return value
+        .replace(/\bBearer\s+[A-Za-z0-9._\-+/=]+/gi, "Bearer [redacted]")
+        .replace(/:\/\/([^:/?#\s]+):([^@/?#\s]+)@/g, "://$1:[redacted]@")
+        .replace(/([?&](?:access_)?token=)[^&#\s]+/gi, "$1[redacted]")
+        .replace(/([?&](?:api[-_]?key|auth|authorization|password|secret)=)[^&#\s]+/gi, "$1[redacted]")
+        .replace(/\bsk-(?:ant-|or-)?[A-Za-z0-9_-]{8,}\b/g, "sk-...[redacted]")
+        .replace(/\bxai-[A-Za-z0-9_-]{8,}\b/g, "xai-...[redacted]")
+        .replace(/\bAIza[0-9A-Za-z_-]{8,}\b/g, "AIza...[redacted]");
+}

package/dist/src/cli/promptRequirement.js

@@ -10,6 +10,8 @@ export function shouldRequirePrompt(rawArgs, options) {
         options.execSession ||
         options.status ||
         options.debugHelp ||
+        options.route ||
+        options.preflight ||
         firstArg === "status" ||
         firstArg === "session");
     const requiresPrompt = options.renderMarkdown || Boolean(options.preview) || Boolean(options.dryRun) || !bypassPrompt;

package/dist/src/cli/providerDoctor.js

@@ -0,0 +1,85 @@
+import chalk from "chalk";
+import { DEFAULT_MODEL } from "../oracle/config.js";
+import { resolveApiModel } from "./options.js";
+import { loadUserConfig } from "../config.js";
+import { buildProviderRoutePlan } from "../oracle/providerRoutePlan.js";
+export async function runProviderDoctor(options) {
+    if (!options.providers) {
+        console.log("Run `oracle doctor --providers` to inspect API provider readiness.");
+        return;
+    }
+    const { config: userConfig } = await loadUserConfig();
+    const providerMode = resolveProviderMode(options);
+    const azure = resolveAzureOptions(options, userConfig);
+    const models = resolveModels(options, userConfig);
+    const plans = models.map((model) => buildProviderRoutePlan({
+        model,
+        providerMode,
+        azure,
+        baseUrl: options.baseUrl ?? userConfig.apiBaseUrl,
+        env: process.env,
+    }));
+    if (options.json) {
+        console.log(JSON.stringify({ providers: plans }, null, 2));
+        process.exitCode = plans.some((plan) => !plan.ok) ? 1 : 0;
+        return;
+    }
+    printProviderPlans(plans);
+    process.exitCode = plans.some((plan) => !plan.ok) ? 1 : 0;
+}
+export function printProviderPlans(plans, { title = "Provider readiness" } = {}) {
+    console.log(chalk.bold(title));
+    console.log("");
+    for (const plan of plans) {
+        const status = plan.ok ? chalk.green("ok") : chalk.red("not ready");
+        console.log(`${plan.model}: ${status}`);
+        console.log(chalk.dim(`  provider: ${plan.providerLabel}`));
+        console.log(chalk.dim(`  base: ${plan.base || "(none)"}`));
+        console.log(chalk.dim(`  key: ${plan.keyPreview}`));
+        if (plan.isAzureOpenAI || plan.azureDeploymentName) {
+            console.log(chalk.dim(`  azure deployment: ${plan.azureDeploymentName ?? "none"}`));
+        }
+        if (plan.azureNote) {
+            console.log(chalk.dim(`  azure: ${plan.azureNote}`));
+        }
+        if (plan.error) {
+            console.log(chalk.dim(`  error: ${plan.error}`));
+        }
+        console.log("");
+    }
+}
+function resolveModels(options, userConfig) {
+    const entries = Array.isArray(options.models) && options.models.length > 0
+        ? options.models
+        : typeof options.models === "string" && options.models.trim().length > 0
+            ? options.models
+                .split(",")
+                .map((entry) => entry.trim())
+                .filter(Boolean)
+            : [options.model ?? userConfig.model ?? DEFAULT_MODEL];
+    return Array.from(new Set(entries.map((entry) => resolveApiModel(entry))));
+}
+function resolveProviderMode(options) {
+    const provider = options.provider ?? "auto";
+    if (provider === "azure" && options.azure === false) {
+        throw new Error("--provider azure cannot be combined with --no-azure.");
+    }
+    if (options.azure === false) {
+        return "openai";
+    }
+    return provider;
+}
+function resolveAzureOptions(options, userConfig) {
+    const endpoint = firstNonEmpty(options.azureEndpoint, process.env.AZURE_OPENAI_ENDPOINT, userConfig.azure?.endpoint);
+    if (!endpoint) {
+        return undefined;
+    }
+    return {
+        endpoint,
+        deployment: firstNonEmpty(options.azureDeployment, process.env.AZURE_OPENAI_DEPLOYMENT, userConfig.azure?.deployment),
+        apiVersion: firstNonEmpty(options.azureApiVersion, process.env.AZURE_OPENAI_API_VERSION, userConfig.azure?.apiVersion),
+    };
+}
+function firstNonEmpty(...values) {
+    return values.find((value) => value?.trim());
+}

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

@@ -6,10 +6,12 @@ import { formatFinishLine } from "../oracle/finishLine.js";
 import { sessionStore, wait } from "../sessionStore.js";
 import { formatTokenCount, formatTokenValue } from "../oracle/runUtils.js";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "../browser/artifacts.js";
 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;
@@ -173,9 +175,16 @@ export async function attachSession(sessionId, options) {
         hasFallbackSessionInfo &&
         isDeepResearchPlaceholderCapture(metadata, await sessionStore.readLog(sessionId).catch(() => ""));
     const completedDeepResearchPlaceholder = metadata.status === "completed" && deepResearchPlaceholderCapture;
+    const hasRecoverableConversation = hasRecoverableChatGptConversation(runtime);
+    const hasLiveChromeFallback = Boolean((metadata.status === "running" || hasIncompleteCapture || completedDeepResearchPlaceholder) &&
+        (runtime?.chromePort || runtime?.chromeBrowserWSEndpoint || runtime?.chromeProfileRoot));
     const canReattach = (statusAllowsReattach || completedDeepResearchPlaceholder) &&
         metadata.mode === "browser" &&
         hasFallbackSessionInfo &&
+        (hasRecoverableConversation ||
+            runtime?.promptSubmitted ||
+            hasLiveChromeFallback ||
+            completedDeepResearchPlaceholder) &&
         (hasChromeDisconnect ||
             hasIncompleteCapture ||
             completedDeepResearchPlaceholder ||
@@ -219,6 +228,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 +277,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 +294,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 +322,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 +445,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 +453,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 +519,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}`;
+}