@steipete/oracle 0.11.1 → 0.12.0

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,7 +12,8 @@ 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 { isCustomBaseUrl } from "./baseUrl.js";
+import { createDefaultClientFactory } from "./client.js";
 import { formatBaseUrlForLog, maskApiKey } from "./logging.js";
 import { startHeartbeat } from "../heartbeat.js";
 import { startOscProgress } from "./oscProgress.js";
@@ -24,15 +25,61 @@ 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 { defaultOpenRouterBaseUrl, isOpenRouterBaseUrl, isProModel, resolveModelConfig, normalizeOpenRouterBaseUrl, } from "./modelResolver.js";
+import { validateProviderRouting } from "./providerRouting.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.
 const DEFAULT_TIMEOUT_NON_PRO_MS = 120_000;
 const DEFAULT_TIMEOUT_PRO_MS = 60 * 60 * 1000;
+const DEFAULT_PROVIDER_HOSTS = {
+    anthropic: "api.anthropic.com",
+    google: "generativelanguage.googleapis.com",
+    openai: "api.openai.com",
+    xai: "api.x.ai",
+};
 const defaultWait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
+function formatRouteTargetForLog(raw, fallbackHost = "") {
+    if (!raw)
+        return fallbackHost;
+    try {
+        const parsed = new URL(raw);
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        let path = "";
+        if (segments.length > 0) {
+            path = `/${segments[0]}`;
+            if (segments.length > 1) {
+                path += "/...";
+            }
+        }
+        return `${parsed.host}${path}`;
+    }
+    catch {
+        const formatted = formatBaseUrlForLog(raw).replace(/^https?:\/\//u, "");
+        return formatted || fallbackHost;
+    }
+}
+function formatProviderRouteLogLine({ provider, baseUrl, openRouterFallback, isAzureOpenAI, azureEndpoint, azureDeploymentName, envVar, }) {
+    if (isAzureOpenAI) {
+        return `Provider: Azure OpenAI | endpoint: ${formatRouteTargetForLog(azureEndpoint)} | deployment: ${azureDeploymentName || "none"} | key: ${envVar}`;
+    }
+    const isOpenRouter = isOpenRouterBaseUrl(baseUrl) || openRouterFallback;
+    const routeProvider = isOpenRouter
+        ? "OpenRouter"
+        : baseUrl && isCustomBaseUrl(baseUrl)
+            ? "OpenAI-compatible"
+            : provider === "anthropic"
+                ? "Anthropic"
+                : provider === "google"
+                    ? "Google Gemini"
+                    : provider === "xai"
+                        ? "xAI"
+                        : "OpenAI";
+    const fallbackHost = DEFAULT_PROVIDER_HOSTS[provider] ?? DEFAULT_PROVIDER_HOSTS.openai;
+    return `Provider: ${routeProvider} | base: ${formatRouteTargetForLog(baseUrl, fallbackHost)} | key: ${envVar}`;
+}
 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
@@ -42,32 +89,64 @@ export async function runOracle(options, deps = {}) {
     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 previewMode = resolvePreviewMode(options.previewMode ?? options.preview);
+    const isPreview = Boolean(previewMode);
+    const providerMode = options.provider ?? "auto";
+    const routing = 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"}`));
+            }
+        },
+    });
+    const { provider, isAzureOpenAI, azureEndpoint, azureDeploymentName } = routing;
     const hasOpenAIKey = Boolean(optionsApiKey) ||
         Boolean(process.env.OPENAI_API_KEY) ||
-        Boolean(process.env.AZURE_OPENAI_API_KEY && options.azure?.endpoint);
+        Boolean(providerMode !== "openai" && 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();
+    const providerQualifiedOpenRouterCandidate = !isAzureOpenAI && providerMode !== "openai" && options.model.includes("/");
+    if (baseUrl &&
+        providerQualifiedOpenRouterCandidate &&
+        !isOpenRouterBaseUrl(baseUrl) &&
+        !isCustomBaseUrl(baseUrl)) {
+        baseUrl = undefined;
+    }
     if (!baseUrl) {
+        let envBaseUrl;
         if (options.model.startsWith("grok")) {
-            baseUrl = resolvedXaiBaseUrl;
+            envBaseUrl = resolvedXaiBaseUrl;
         }
         else if (provider === "anthropic") {
-            baseUrl = process.env.ANTHROPIC_BASE_URL?.trim();
+            envBaseUrl = process.env.ANTHROPIC_BASE_URL?.trim();
         }
         else {
-            baseUrl = process.env.OPENAI_BASE_URL?.trim();
+            envBaseUrl = process.env.OPENAI_BASE_URL?.trim();
+        }
+        if (!providerQualifiedOpenRouterCandidate || (envBaseUrl && isCustomBaseUrl(envBaseUrl))) {
+            baseUrl = envBaseUrl;
         }
     }
-    const providerKeyMissing = (provider === "openai" && !hasOpenAIKey) ||
-        (provider === "anthropic" && !hasAnthropicKey) ||
-        (provider === "google" && !hasGeminiKey) ||
-        (provider === "xai" && !hasXaiKey) ||
-        provider === "other";
-    const openRouterFallback = providerKeyMissing && Boolean(openRouterApiKey);
+    const providerKeyMissing = !isAzureOpenAI &&
+        (providerMode === "openai"
+            ? !hasOpenAIKey
+            : (provider === "openai" && !hasOpenAIKey) ||
+                (provider === "anthropic" && !hasAnthropicKey) ||
+                (provider === "google" && !hasGeminiKey) ||
+                (provider === "xai" && !hasXaiKey) ||
+                provider === "other");
+    const providerQualifiedOpenRouterRoute = providerQualifiedOpenRouterCandidate && !baseUrl;
+    const openRouterFallback = !baseUrl &&
+        (providerQualifiedOpenRouterRoute ||
+            (providerMode !== "openai" &&
+                providerKeyMissing &&
+                (provider === "other" || Boolean(openRouterApiKey))));
     if (!baseUrl || openRouterFallback) {
         if (openRouterFallback) {
             baseUrl = defaultOpenRouterBase;
@@ -81,20 +160,24 @@ export async function runOracle(options, deps = {}) {
             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 (isAzureOpenAI) {
+            if (optionsApiKey)
+                return { key: optionsApiKey, source: "apiKey option" };
+            const key = process.env.AZURE_OPENAI_API_KEY ?? process.env.OPENAI_API_KEY;
+            return { key, source: "AZURE_OPENAI_API_KEY|OPENAI_API_KEY" };
+        }
+        if (providerMode === "openai") {
+            if (optionsApiKey)
+                return { key: optionsApiKey, source: "apiKey option" };
+            return { key: process.env.OPENAI_API_KEY, source: "OPENAI_API_KEY" };
+        }
         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" };
-            }
             return { key: process.env.OPENAI_API_KEY, source: "OPENAI_API_KEY" };
         }
         if (typeof model === "string" && model.startsWith("gemini")) {
@@ -114,19 +197,21 @@ export async function runOracle(options, deps = {}) {
     const apiKeyResult = getApiKeyForModel(options.model);
     const apiKey = apiKeyResult.key;
     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"
+                    : options.model.startsWith("gpt")
+                        ? "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 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.'
             : "";
@@ -199,14 +284,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 +326,15 @@ export async function runOracle(options, deps = {}) {
     if (!isPreview) {
         if (!options.suppressHeader) {
             log(headerLine);
+            log(dim(formatProviderRouteLogLine({
+                provider,
+                baseUrl,
+                openRouterFallback,
+                isAzureOpenAI,
+                azureEndpoint,
+                azureDeploymentName,
+                envVar,
+            })));
         }
         const maskedKey = maskApiKey(apiKey);
         if (maskedKey && options.verbose) {
@@ -249,9 +346,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 +363,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 +399,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")
+                    ? (process.env.ANTHROPIC_BASE_URL ?? 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

@@ -2,7 +2,8 @@ import path from "node:path";
 import fs from "node:fs/promises";
 import { createWriteStream } 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() {
@@ -199,8 +200,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 +211,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "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});}});\"",
@@ -47,6 +48,7 @@
     "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: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",