@steipete/oracle 1.1.0 → 1.3.0

package/dist/bin/oracle-cli.js

@@ -2,43 +2,57 @@
 import 'dotenv/config';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { once } from 'node:events';
 import { Command, Option } from 'commander';
-import { resolveEngine } from '../src/cli/engine.js';
+import { resolveEngine, defaultWaitPreference } from '../src/cli/engine.js';
 import { shouldRequirePrompt } from '../src/cli/promptRequirement.js';
 import chalk from 'chalk';
 import { ensureSessionStorage, initializeSession, readSessionMetadata, createSessionLogWriter, deleteSessionsOlderThan, } from '../src/sessionManager.js';
-import { runOracle, renderPromptMarkdown, readFiles } from '../src/oracle.js';
+import { renderPromptMarkdown, readFiles } from '../src/oracle.js';
 import { CHATGPT_URL } from '../src/browserMode.js';
 import { applyHelpStyling } from '../src/cli/help.js';
-import { collectPaths, parseFloatOption, parseIntOption, parseSearchOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, } from '../src/cli/options.js';
+import { collectPaths, parseFloatOption, parseIntOption, parseSearchOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, normalizeBaseUrl, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, parseTimeoutOption, } from '../src/cli/options.js';
+import { shouldDetachSession } from '../src/cli/detach.js';
+import { applyHiddenAliases } from '../src/cli/hiddenAliases.js';
 import { buildBrowserConfig, resolveBrowserModelLabel } from '../src/cli/browserConfig.js';
 import { performSessionRun } from '../src/cli/sessionRunner.js';
-import { attachSession, showStatus } from '../src/cli/sessionDisplay.js';
+import { attachSession, showStatus, formatCompletionSummary } from '../src/cli/sessionDisplay.js';
+import { resolveGeminiModelId } from '../src/oracle/gemini.js';
 import { handleSessionCommand, formatSessionCleanupMessage } from '../src/cli/sessionCommand.js';
 import { isErrorLogged } from '../src/cli/errorUtils.js';
 import { handleSessionAlias, handleStatusFlag } from '../src/cli/rootAlias.js';
 import { getCliVersion } from '../src/version.js';
-import { runDryRunSummary } from '../src/cli/dryRun.js';
+import { runDryRunSummary, runBrowserPreview } from '../src/cli/dryRun.js';
+import { launchTui } from '../src/cli/tui/index.js';
+import { resolveNotificationSettings, deriveNotificationSettingsFromMetadata, } from '../src/cli/notifier.js';
+import { loadUserConfig } from '../src/config.js';
 const VERSION = getCliVersion();
 const CLI_ENTRYPOINT = fileURLToPath(import.meta.url);
 const rawCliArgs = process.argv.slice(2);
+const userCliArgs = rawCliArgs[0] === CLI_ENTRYPOINT ? rawCliArgs.slice(1) : rawCliArgs;
 const isTty = process.stdout.isTTY;
+const tuiEnabled = () => isTty && process.env.ORACLE_NO_TUI !== '1';
 const program = new Command();
 applyHelpStyling(program, VERSION, isTty);
 program.hook('preAction', (thisCommand) => {
     if (thisCommand !== program) {
         return;
     }
-    if (rawCliArgs.some((arg) => arg === '--help' || arg === '-h')) {
+    if (userCliArgs.some((arg) => arg === '--help' || arg === '-h')) {
+        return;
+    }
+    if (userCliArgs.length === 0 && tuiEnabled()) {
+        // Skip prompt enforcement; runRootCommand will launch the TUI.
         return;
     }
     const opts = thisCommand.optsWithGlobals();
+    applyHiddenAliases(opts, (key, value) => thisCommand.setOptionValue(key, value));
     const positional = thisCommand.args?.[0];
     if (!opts.prompt && positional) {
         opts.prompt = positional;
         thisCommand.setOptionValue('prompt', positional);
     }
-    if (shouldRequirePrompt(rawCliArgs, opts)) {
+    if (shouldRequirePrompt(userCliArgs, opts)) {
         console.log(chalk.yellow('Prompt is required. Provide it via --prompt "<text>" or positional [prompt].'));
         thisCommand.help({ error: false });
         process.exitCode = 1;
@@ -51,16 +65,31 @@ program
     .version(VERSION)
     .argument('[prompt]', 'Prompt text (shorthand for --prompt).')
     .option('-p, --prompt <text>', 'User prompt to send to the model.')
+    .addOption(new Option('--message <text>', 'Alias for --prompt.').hideHelp())
     .option('-f, --file <paths...>', 'Files/directories or glob patterns to attach (prefix with !pattern to exclude). Files larger than 1 MB are rejected automatically.', collectPaths, [])
+    .addOption(new Option('--include <paths...>', 'Alias for --file.')
+    .argParser(collectPaths)
+    .default([])
+    .hideHelp())
     .option('-s, --slug <words>', 'Custom session slug (3-5 words).')
     .option('-m, --model <model>', 'Model to target (gpt-5-pro | gpt-5.1, or ChatGPT labels like "5.1 Instant" for browser runs).', normalizeModelOption, 'gpt-5-pro')
-    .addOption(new Option('-e, --engine <mode>', 'Execution engine (api | browser). If omitted, Oracle picks api when OPENAI_API_KEY is set, otherwise browser.').choices(['api', 'browser']))
+    .addOption(new Option('-e, --engine <mode>', 'Execution engine (api | browser). If omitted, oracle picks api when OPENAI_API_KEY is set, otherwise browser.').choices(['api', 'browser']))
     .option('--files-report', 'Show token usage per attached file (also prints automatically when files exceed the token budget).', false)
     .option('-v, --verbose', 'Enable verbose logging for all operations.', false)
-    .option('--dry-run', 'Validate inputs and show token estimates without calling the model.', false)
-    .addOption(new Option('--preview [mode]', 'Preview the request without calling the API (summary | json | full).')
+    .addOption(new Option('--[no-]notify', 'Desktop notification when a session finishes (default on unless CI/SSH).')
+    .default(undefined))
+    .addOption(new Option('--[no-]notify-sound', 'Play a notification sound on completion (default off).').default(undefined))
+    .addOption(new Option('--timeout <seconds|auto>', 'Overall timeout before aborting the API call (auto = 20m for gpt-5-pro, 30s otherwise).')
+    .argParser(parseTimeoutOption)
+    .default('auto'))
+    .addOption(new Option('--preview [mode]', '(alias) Preview the request without calling the model (summary | json | full). Deprecated: use --dry-run instead.')
+    .hideHelp()
     .choices(['summary', 'json', 'full'])
     .preset('summary'))
+    .addOption(new Option('--dry-run [mode]', 'Preview without calling the model (summary | json | full).')
+    .choices(['summary', 'json', 'full'])
+    .preset('summary')
+    .default(false))
     .addOption(new Option('--exec-session <id>').hideHelp())
     .addOption(new Option('--session <id>').hideHelp())
     .addOption(new Option('--status', 'Show stored sessions (alias for `oracle status`).').default(false).hideHelp())
@@ -75,20 +104,30 @@ program
     .addOption(new Option('--max-output <tokens>', 'Override the max output tokens for the selected model.')
     .argParser(parseIntOption)
     .hideHelp())
+    .option('--base-url <url>', 'Override the OpenAI-compatible base URL for API runs (e.g. LiteLLM proxy endpoint).')
+    .option('--azure-endpoint <url>', 'Azure OpenAI Endpoint (e.g. https://resource.openai.azure.com/).')
+    .option('--azure-deployment <name>', 'Azure OpenAI Deployment Name.')
+    .option('--azure-api-version <version>', 'Azure OpenAI API Version.')
     .addOption(new Option('--browser', '(deprecated) Use --engine browser instead.').default(false).hideHelp())
     .addOption(new Option('--browser-chrome-profile <name>', 'Chrome profile name/path for cookie reuse.').hideHelp())
     .addOption(new Option('--browser-chrome-path <path>', 'Explicit Chrome or Chromium executable path.').hideHelp())
     .addOption(new Option('--browser-url <url>', `Override the ChatGPT URL (default ${CHATGPT_URL}).`).hideHelp())
     .addOption(new Option('--browser-timeout <ms|s|m>', 'Maximum time to wait for an answer (default 900s).').hideHelp())
     .addOption(new Option('--browser-input-timeout <ms|s|m>', 'Maximum time to wait for the prompt textarea (default 30s).').hideHelp())
+    .addOption(new Option('--browser-cookie-names <names>', 'Comma-separated cookie allowlist for sync.').hideHelp())
+    .addOption(new Option('--browser-inline-cookies <jsonOrBase64>', 'Inline cookies payload (JSON array or base64-encoded JSON).').hideHelp())
+    .addOption(new Option('--browser-inline-cookies-file <path>', 'Load inline cookies from file (JSON or base64 JSON).').hideHelp())
     .addOption(new Option('--browser-no-cookie-sync', 'Skip copying cookies from Chrome.').hideHelp())
     .addOption(new Option('--browser-headless', 'Launch Chrome in headless mode.').hideHelp())
     .addOption(new Option('--browser-hide-window', 'Hide the Chrome window after launch (macOS headful only).').hideHelp())
     .addOption(new Option('--browser-keep-browser', 'Keep Chrome running after completion.').hideHelp())
     .addOption(new Option('--browser-allow-cookie-errors', 'Continue even if Chrome cookies cannot be copied.').hideHelp())
     .addOption(new Option('--browser-inline-files', 'Paste files directly into the ChatGPT composer instead of uploading attachments.').default(false))
+    .addOption(new Option('--browser-bundle-files', 'Bundle all attachments into a single archive before uploading.').default(false))
     .option('--debug-help', 'Show the advanced/debug option set and exit.', false)
     .option('--heartbeat <seconds>', 'Emit periodic in-progress updates (0 to disable).', parseHeartbeatOption, 30)
+    .addOption(new Option('--wait').default(undefined))
+    .addOption(new Option('--no-wait').default(undefined).hideHelp())
     .showHelpAfterError('(use --help for usage)');
 program.addHelpText('after', `
 Examples:
@@ -106,6 +145,7 @@ const sessionCommand = program
     .option('--limit <count>', 'Maximum sessions to show when listing (max 1000).', parseIntOption, 100)
     .option('--all', 'Include all stored sessions regardless of age.', false)
     .option('--clear', 'Delete stored sessions older than the provided window (24h default).', false)
+    .option('--hide-prompt', 'Hide stored prompt when displaying a session.', false)
     .option('--render', 'Render completed session output as markdown (rich TTY only).', false)
     .option('--render-markdown', 'Alias for --render.', false)
     .option('--path', 'Print the stored session paths instead of attaching.', false)
@@ -122,6 +162,7 @@ const statusCommand = program
     .option('--clear', 'Delete stored sessions older than the provided window (24h default).', false)
     .option('--render', 'Render completed session output as markdown (rich TTY only).', false)
     .option('--render-markdown', 'Alias for --render.', false)
+    .option('--hide-prompt', 'Hide stored prompt when displaying a session.', false)
     .addOption(new Option('--clean', 'Deprecated alias for --clear.').default(false).hideHelp())
     .action(async (sessionId, _options, command) => {
     const statusOptions = command.opts();
@@ -145,7 +186,11 @@ const statusCommand = program
         return;
     }
     if (sessionId) {
-        await attachSession(sessionId);
+        const autoRender = !command.getOptionValueSource?.('render') && !command.getOptionValueSource?.('renderMarkdown')
+            ? process.stdout.isTTY
+            : false;
+        const renderMarkdown = Boolean(statusOptions.render || statusOptions.renderMarkdown || autoRender);
+        await attachSession(sessionId, { renderMarkdown, renderPrompt: !statusOptions.hidePrompt });
         return;
     }
     const showExamples = usesDefaultStatusFilters(command);
@@ -160,27 +205,46 @@ function buildRunOptions(options, overrides = {}) {
     if (!options.prompt) {
         throw new Error('Prompt is required.');
     }
+    const normalizedBaseUrl = normalizeBaseUrl(overrides.baseUrl ?? options.baseUrl);
+    const azure = options.azureEndpoint || overrides.azure?.endpoint
+        ? {
+            endpoint: overrides.azure?.endpoint ?? options.azureEndpoint,
+            deployment: overrides.azure?.deployment ?? options.azureDeployment,
+            apiVersion: overrides.azure?.apiVersion ?? options.azureApiVersion,
+        }
+        : undefined;
     return {
         prompt: options.prompt,
         model: options.model,
+        effectiveModelId: overrides.effectiveModelId ?? options.effectiveModelId ?? options.model,
         file: overrides.file ?? options.file ?? [],
         slug: overrides.slug ?? options.slug,
         filesReport: overrides.filesReport ?? options.filesReport,
         maxInput: overrides.maxInput ?? options.maxInput,
         maxOutput: overrides.maxOutput ?? options.maxOutput,
         system: overrides.system ?? options.system,
+        timeoutSeconds: overrides.timeoutSeconds ?? options.timeout,
         silent: overrides.silent ?? options.silent,
         search: overrides.search ?? options.search,
         preview: overrides.preview ?? undefined,
         previewMode: overrides.previewMode ?? options.previewMode,
         apiKey: overrides.apiKey ?? options.apiKey,
+        baseUrl: normalizedBaseUrl,
+        azure,
         sessionId: overrides.sessionId ?? options.sessionId,
         verbose: overrides.verbose ?? options.verbose,
         heartbeatIntervalMs: overrides.heartbeatIntervalMs ?? resolveHeartbeatIntervalMs(options.heartbeat),
         browserInlineFiles: overrides.browserInlineFiles ?? options.browserInlineFiles ?? false,
+        browserBundleFiles: overrides.browserBundleFiles ?? options.browserBundleFiles ?? false,
         background: overrides.background ?? undefined,
     };
 }
+export function enforceBrowserSearchFlag(runOptions, sessionMode, logFn = console.log) {
+    if (sessionMode === 'browser' && runOptions.search === false) {
+        logFn(chalk.dim('Note: search is not available in browser engine; ignoring search=false.'));
+        runOptions.search = undefined;
+    }
+}
 function resolveHeartbeatIntervalMs(seconds) {
     if (typeof seconds !== 'number' || seconds <= 0) {
         return undefined;
@@ -192,6 +256,7 @@ function buildRunOptionsFromMetadata(metadata) {
     return {
         prompt: stored.prompt ?? '',
         model: stored.model ?? 'gpt-5-pro',
+        effectiveModelId: stored.effectiveModelId ?? stored.model,
         file: stored.file ?? [],
         slug: stored.slug,
         filesReport: stored.filesReport,
@@ -199,14 +264,17 @@ function buildRunOptionsFromMetadata(metadata) {
         maxOutput: stored.maxOutput,
         system: stored.system,
         silent: stored.silent,
-        search: undefined,
+        search: stored.search,
         preview: false,
         previewMode: undefined,
         apiKey: undefined,
+        baseUrl: normalizeBaseUrl(stored.baseUrl),
+        azure: stored.azure,
         sessionId: metadata.id,
         verbose: stored.verbose,
         heartbeatIntervalMs: stored.heartbeatIntervalMs,
         browserInlineFiles: stored.browserInlineFiles,
+        browserBundleFiles: stored.browserBundleFiles,
         background: stored.background,
     };
 }
@@ -217,7 +285,18 @@ function getBrowserConfigFromMetadata(metadata) {
     return metadata.options?.browserConfig ?? metadata.browser?.config;
 }
 async function runRootCommand(options) {
+    if (process.env.ORACLE_FORCE_TUI === '1') {
+        await ensureSessionStorage();
+        await launchTui({ version: VERSION });
+        return;
+    }
+    const userConfig = (await loadUserConfig()).config;
     const helpRequested = rawCliArgs.some((arg) => arg === '--help' || arg === '-h');
+    const optionUsesDefault = (name) => {
+        // Commander reports undefined for untouched options, so treat undefined/default the same
+        const source = program.getOptionValueSource?.(name);
+        return source == null || source === 'default';
+    };
     if (helpRequested) {
         if (options.verbose) {
             console.log('');
@@ -227,8 +306,12 @@ async function runRootCommand(options) {
         program.help({ error: false });
         return;
     }
-    const previewMode = resolvePreviewMode(options.preview);
-    if (rawCliArgs.length === 0) {
+    const previewMode = resolvePreviewMode(options.dryRun || options.preview);
+    if (userCliArgs.length === 0) {
+        if (tuiEnabled()) {
+            await launchTui({ version: VERSION });
+            return;
+        }
         console.log(chalk.yellow('No prompt or subcommand supplied. See `oracle --help` for usage.'));
         program.help({ error: false });
         return;
@@ -237,19 +320,77 @@ async function runRootCommand(options) {
         printDebugHelp(program.name());
         return;
     }
-    if (options.dryRun && previewMode) {
-        throw new Error('--dry-run cannot be combined with --preview.');
-    }
     if (options.dryRun && options.renderMarkdown) {
         throw new Error('--dry-run cannot be combined with --render-markdown.');
     }
-    const engine = resolveEngine({ engine: options.engine, browserFlag: options.browser, env: process.env });
+    const preferredEngine = options.engine ?? userConfig.engine;
+    let engine = resolveEngine({ engine: preferredEngine, browserFlag: options.browser, env: process.env });
     if (options.browser) {
         console.log(chalk.yellow('`--browser` is deprecated; use `--engine browser` instead.'));
     }
+    if (optionUsesDefault('model') && userConfig.model) {
+        options.model = userConfig.model;
+    }
+    if (optionUsesDefault('search') && userConfig.search) {
+        options.search = userConfig.search === 'on';
+    }
+    if (optionUsesDefault('filesReport') && userConfig.filesReport != null) {
+        options.filesReport = Boolean(userConfig.filesReport);
+    }
+    if (optionUsesDefault('heartbeat') && typeof userConfig.heartbeatSeconds === 'number') {
+        options.heartbeat = userConfig.heartbeatSeconds;
+    }
+    if (optionUsesDefault('baseUrl') && userConfig.apiBaseUrl) {
+        options.baseUrl = userConfig.apiBaseUrl;
+    }
+    if (optionUsesDefault('azureEndpoint')) {
+        if (process.env.AZURE_OPENAI_ENDPOINT) {
+            options.azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
+        }
+        else if (userConfig.azure?.endpoint) {
+            options.azureEndpoint = userConfig.azure.endpoint;
+        }
+    }
+    if (optionUsesDefault('azureDeployment')) {
+        if (process.env.AZURE_OPENAI_DEPLOYMENT) {
+            options.azureDeployment = process.env.AZURE_OPENAI_DEPLOYMENT;
+        }
+        else if (userConfig.azure?.deployment) {
+            options.azureDeployment = userConfig.azure.deployment;
+        }
+    }
+    if (optionUsesDefault('azureApiVersion')) {
+        if (process.env.AZURE_OPENAI_API_VERSION) {
+            options.azureApiVersion = process.env.AZURE_OPENAI_API_VERSION;
+        }
+        else if (userConfig.azure?.apiVersion) {
+            options.azureApiVersion = userConfig.azure.apiVersion;
+        }
+    }
     const cliModelArg = normalizeModelOption(options.model) || 'gpt-5-pro';
-    const resolvedModel = engine === 'browser' ? inferModelFromLabel(cliModelArg) : resolveApiModel(cliModelArg);
+    const resolvedModelCandidate = engine === 'browser' ? inferModelFromLabel(cliModelArg) : resolveApiModel(cliModelArg);
+    const isGemini = resolvedModelCandidate.startsWith('gemini');
+    const userForcedBrowser = options.browser || options.engine === 'browser';
+    if (isGemini && userForcedBrowser) {
+        throw new Error('Gemini is only supported via API. Use --engine api.');
+    }
+    if (isGemini && engine === 'browser') {
+        engine = 'api';
+    }
+    const resolvedModel = isGemini ? resolveApiModel(cliModelArg) : resolvedModelCandidate;
+    const effectiveModelId = resolvedModel.startsWith('gemini') ? resolveGeminiModelId(resolvedModel) : resolvedModel;
+    const resolvedBaseUrl = normalizeBaseUrl(options.baseUrl ?? process.env.OPENAI_BASE_URL);
     const resolvedOptions = { ...options, model: resolvedModel };
+    resolvedOptions.baseUrl = resolvedBaseUrl;
+    // Decide whether to block until completion:
+    // - explicit --wait / --no-wait wins
+    // - otherwise block for fast models (gpt-5.1, browser) and detach by default for gpt-5-pro API
+    const waitPreference = resolveWaitFlag({
+        waitFlag: options.wait,
+        noWaitFlag: options.noWait,
+        model: resolvedModel,
+        engine,
+    });
     if (await handleStatusFlag(options, { attachSession, showStatus })) {
         return;
     }
@@ -269,77 +410,146 @@ async function runRootCommand(options) {
         return;
     }
     if (previewMode) {
+        if (!options.prompt) {
+            throw new Error('Prompt is required when using --dry-run/preview.');
+        }
+        if (userConfig.promptSuffix) {
+            options.prompt = `${options.prompt.trim()}\n${userConfig.promptSuffix}`;
+        }
+        resolvedOptions.prompt = options.prompt;
+        const runOptions = buildRunOptions(resolvedOptions, { preview: true, previewMode, baseUrl: resolvedBaseUrl });
         if (engine === 'browser') {
-            throw new Error('--engine browser cannot be combined with --preview.');
+            await runBrowserPreview({
+                runOptions,
+                cwd: process.cwd(),
+                version: VERSION,
+                previewMode,
+                log: console.log,
+            }, {});
+            return;
         }
-        if (!options.prompt) {
-            throw new Error('Prompt is required when using --preview.');
+        // API dry-run/preview path
+        if (previewMode === 'summary') {
+            await runDryRunSummary({
+                engine,
+                runOptions,
+                cwd: process.cwd(),
+                version: VERSION,
+                log: console.log,
+            }, {});
+            return;
         }
-        const runOptions = buildRunOptions(resolvedOptions, { preview: true, previewMode });
-        await runOracle(runOptions, { log: console.log, write: (chunk) => process.stdout.write(chunk) });
-        return;
-    }
-    if (!options.prompt) {
-        throw new Error('Prompt is required when starting a new session.');
-    }
-    if (options.dryRun) {
-        const baseRunOptions = buildRunOptions(resolvedOptions, { preview: false, previewMode: undefined });
         await runDryRunSummary({
             engine,
-            runOptions: baseRunOptions,
+            runOptions,
             cwd: process.cwd(),
             version: VERSION,
             log: console.log,
         }, {});
         return;
     }
+    if (!options.prompt) {
+        throw new Error('Prompt is required when starting a new session.');
+    }
+    if (userConfig.promptSuffix) {
+        options.prompt = `${options.prompt.trim()}\n${userConfig.promptSuffix}`;
+    }
+    resolvedOptions.prompt = options.prompt;
     if (options.file && options.file.length > 0) {
         await readFiles(options.file, { cwd: process.cwd() });
     }
+    applyBrowserDefaultsFromConfig(options, userConfig);
+    const notifications = resolveNotificationSettings({
+        cliNotify: options.notify,
+        cliNotifySound: options.notifySound,
+        env: process.env,
+        config: userConfig.notify,
+    });
     const sessionMode = engine === 'browser' ? 'browser' : 'api';
     const browserModelLabelOverride = sessionMode === 'browser' ? resolveBrowserModelLabel(cliModelArg, resolvedModel) : undefined;
     const browserConfig = sessionMode === 'browser'
-        ? buildBrowserConfig({
+        ? await buildBrowserConfig({
             ...options,
             model: resolvedModel,
             browserModelLabel: browserModelLabelOverride,
         })
         : undefined;
+    if (options.dryRun) {
+        const baseRunOptions = buildRunOptions(resolvedOptions, {
+            preview: false,
+            previewMode: undefined,
+            baseUrl: resolvedBaseUrl,
+        });
+        await runDryRunSummary({
+            engine,
+            runOptions: baseRunOptions,
+            cwd: process.cwd(),
+            version: VERSION,
+            log: console.log,
+            browserConfig,
+        }, {});
+        return;
+    }
     await ensureSessionStorage();
-    const baseRunOptions = buildRunOptions(resolvedOptions, { preview: false, previewMode: undefined });
+    const baseRunOptions = buildRunOptions(resolvedOptions, {
+        preview: false,
+        previewMode: undefined,
+        background: userConfig.background ?? resolvedOptions.background,
+        baseUrl: resolvedBaseUrl,
+    });
+    enforceBrowserSearchFlag(baseRunOptions, sessionMode, console.log);
+    if (sessionMode === 'browser' && baseRunOptions.search === false) {
+        console.log(chalk.dim('Note: search is not available in browser engine; ignoring search=false.'));
+        baseRunOptions.search = undefined;
+    }
     const sessionMeta = await initializeSession({
         ...baseRunOptions,
         mode: sessionMode,
         browserConfig,
-    }, process.cwd());
-    const reattachCommand = `pnpm oracle session ${sessionMeta.id}`;
-    console.log(chalk.bold(`Reattach later with: ${chalk.cyan(reattachCommand)}`));
-    console.log('');
-    const liveRunOptions = { ...baseRunOptions, sessionId: sessionMeta.id };
-    const disableDetach = process.env.ORACLE_NO_DETACH === '1';
-    const detached = disableDetach
+    }, process.cwd(), notifications);
+    const liveRunOptions = {
+        ...baseRunOptions,
+        sessionId: sessionMeta.id,
+        effectiveModelId,
+    };
+    const disableDetachEnv = process.env.ORACLE_NO_DETACH === '1';
+    const detachAllowed = shouldDetachSession({
+        engine,
+        model: resolvedModel,
+        waitPreference,
+        disableDetachEnv,
+    });
+    const detached = !detachAllowed
         ? false
         : await launchDetachedSession(sessionMeta.id).catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
             console.log(chalk.yellow(`Unable to detach session runner (${message}). Running inline...`));
             return false;
         });
+    if (!waitPreference) {
+        if (!detached) {
+            console.log(chalk.red('Unable to start in background; use --wait to run inline.'));
+            process.exitCode = 1;
+            return;
+        }
+        console.log(chalk.blue(`Session running in background. Reattach via: oracle session ${sessionMeta.id}`));
+        console.log(chalk.dim('Pro runs can take up to 10 minutes. Add --wait to stay attached.'));
+        return;
+    }
     if (detached === false) {
-        await runInteractiveSession(sessionMeta, liveRunOptions, sessionMode, browserConfig, true);
-        console.log(chalk.bold(`Session ${sessionMeta.id} completed`));
+        await runInteractiveSession(sessionMeta, liveRunOptions, sessionMode, browserConfig, false, notifications, userConfig, true);
         return;
     }
     if (detached) {
         console.log(chalk.blue(`Reattach via: oracle session ${sessionMeta.id}`));
         await attachSession(sessionMeta.id, { suppressMetadata: true });
-        console.log(chalk.bold(`Session ${sessionMeta.id} completed`));
     }
 }
-async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfig, showReattachHint = true) {
+async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfig, showReattachHint = true, notifications, userConfig, suppressSummary = false) {
     const { logLine, writeChunk, stream } = createSessionLogWriter(sessionMeta.id);
     let headerAugmented = false;
     const combinedLog = (message = '') => {
-        if (!headerAugmented && message.startsWith('Oracle (')) {
+        if (!headerAugmented && message.startsWith('oracle (')) {
             headerAugmented = true;
             if (showReattachHint) {
                 console.log(`${message}\n${chalk.blue(`Reattach via: oracle session ${sessionMeta.id}`)}`);
@@ -367,7 +577,16 @@ async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfi
             log: combinedLog,
             write: combinedWrite,
             version: VERSION,
+            notifications: notifications ?? deriveNotificationSettingsFromMetadata(sessionMeta, process.env, userConfig?.notify),
         });
+        const latest = await readSessionMetadata(sessionMeta.id);
+        if (!suppressSummary) {
+            const summary = latest ? formatCompletionSummary(latest, { includeSlug: true }) : null;
+            if (summary) {
+                console.log('\n' + chalk.green.bold(summary));
+                logLine(summary); // plain text in log, colored on stdout
+            }
+        }
     }
     catch (error) {
         throw error;
@@ -407,6 +626,8 @@ async function executeSession(sessionId) {
     const sessionMode = getSessionMode(metadata);
     const browserConfig = getBrowserConfigFromMetadata(metadata);
     const { logLine, writeChunk, stream } = createSessionLogWriter(sessionId);
+    const userConfig = (await loadUserConfig()).config;
+    const notifications = deriveNotificationSettingsFromMetadata(metadata, process.env, userConfig.notify);
     try {
         await performSessionRun({
             sessionMeta: metadata,
@@ -417,6 +638,7 @@ async function executeSession(sessionId) {
             log: logLine,
             write: writeChunk,
             version: VERSION,
+            notifications,
         });
     }
     catch {
@@ -456,11 +678,57 @@ function printDebugOptionGroup(entries) {
         console.log(`  ${label}${description}`);
     });
 }
+function resolveWaitFlag({ waitFlag, noWaitFlag, model, engine, }) {
+    if (waitFlag === true)
+        return true;
+    if (noWaitFlag === true)
+        return false;
+    return defaultWaitPreference(model, engine);
+}
+function applyBrowserDefaultsFromConfig(options, config) {
+    const browser = config.browser;
+    if (!browser)
+        return;
+    const source = (key) => program.getOptionValueSource?.(key);
+    if (source('browserChromeProfile') === 'default' && browser.chromeProfile !== undefined) {
+        options.browserChromeProfile = browser.chromeProfile ?? undefined;
+    }
+    if (source('browserChromePath') === 'default' && browser.chromePath !== undefined) {
+        options.browserChromePath = browser.chromePath ?? undefined;
+    }
+    if (source('browserUrl') === 'default' && browser.url !== undefined) {
+        options.browserUrl = browser.url;
+    }
+    if (source('browserTimeout') === 'default' && typeof browser.timeoutMs === 'number') {
+        options.browserTimeout = String(browser.timeoutMs);
+    }
+    if (source('browserInputTimeout') === 'default' && typeof browser.inputTimeoutMs === 'number') {
+        options.browserInputTimeout = String(browser.inputTimeoutMs);
+    }
+    if (source('browserHeadless') === 'default' && browser.headless !== undefined) {
+        options.browserHeadless = browser.headless;
+    }
+    if (source('browserHideWindow') === 'default' && browser.hideWindow !== undefined) {
+        options.browserHideWindow = browser.hideWindow;
+    }
+    if (source('browserKeepBrowser') === 'default' && browser.keepBrowser !== undefined) {
+        options.browserKeepBrowser = browser.keepBrowser;
+    }
+}
 program.action(async function () {
     const options = this.optsWithGlobals();
     await runRootCommand(options);
 });
-await program.parseAsync(process.argv).catch((error) => {
+async function main() {
+    const parsePromise = program.parseAsync(process.argv);
+    const sigintPromise = once(process, 'SIGINT').then(() => 'sigint');
+    const result = await Promise.race([parsePromise.then(() => 'parsed'), sigintPromise]);
+    if (result === 'sigint') {
+        console.log(chalk.yellow('\nCancelled.'));
+        process.exitCode = 130;
+    }
+}
+void main().catch((error) => {
     if (error instanceof Error) {
         if (!isErrorLogged(error)) {
             console.error(chalk.red('✖'), error.message);

package/dist/bin/oracle-mcp.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { startMcpServer } from '../src/mcp/server.js';
+startMcpServer().catch((error) => {
+    console.error('oracle-mcp exited with an error:', error);
+    process.exitCode = 1;
+});