@steipete/oracle 1.1.0 → 1.3.0

package/dist/src/cli/sessionDisplay.js

@@ -1,10 +1,12 @@
 import chalk from 'chalk';
 import kleur from 'kleur';
-import { filterSessionsByRange, listSessionsMetadata, readSessionLog, readSessionMetadata, SESSIONS_DIR, wait, } from '../sessionManager.js';
+import { filterSessionsByRange, listSessionsMetadata, readSessionLog, readSessionMetadata, readSessionRequest, SESSIONS_DIR, wait, } from '../sessionManager.js';
 import { renderMarkdownAnsi } from './markdownRenderer.js';
+import { formatElapsed, formatUSD } from '../oracle/format.js';
+import { MODEL_CONFIGS } from '../oracle.js';
 const isTty = () => Boolean(process.stdout.isTTY);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
-const MAX_RENDER_BYTES = 200_000;
+export const MAX_RENDER_BYTES = 200_000;
 const CLEANUP_TIP = 'Tip: Run "oracle session --clear --hours 24" to prune cached runs (add --all to wipe everything).';
 export async function showStatus({ hours, includeAll, limit, showExamples = false }) {
     const metas = await listSessionsMetadata();
@@ -18,12 +20,17 @@ export async function showStatus({ hours, includeAll, limit, showExamples = fals
         return;
     }
     console.log(chalk.bold('Recent Sessions'));
+    console.log(chalk.dim('Timestamp             Chars  Cost  Status     Model      ID'));
     for (const entry of entries) {
         const statusRaw = (entry.status || 'unknown').padEnd(9);
         const status = richTty ? colorStatus(entry.status ?? 'unknown', statusRaw) : statusRaw;
         const model = (entry.model || 'n/a').padEnd(9);
-        const created = entry.createdAt.replace('T', ' ').replace('Z', '');
-        console.log(`${created} | ${status} | ${model} | ${entry.id}`);
+        const created = formatTimestamp(entry.createdAt);
+        const chars = entry.options?.prompt?.length ?? entry.promptPreview?.length ?? 0;
+        const charLabel = chars > 0 ? String(chars).padStart(5) : '    -';
+        const costValue = resolveCost(entry);
+        const costLabel = costValue != null ? formatCostTable(costValue) : '     -';
+        console.log(`${created} | ${charLabel} | ${costLabel} | ${status} | ${model} | ${entry.id}`);
     }
     if (truncated) {
         console.log(chalk.yellow(`Showing ${entries.length} of ${total} sessions from the requested range. Run "oracle session --clear" or delete entries in ${SESSIONS_DIR} to free space, or rerun with --status-limit/--status-all.`));
@@ -76,6 +83,14 @@ export async function attachSession(sessionId, options) {
         }
     }
     const shouldTrimIntro = initialStatus === 'completed' || initialStatus === 'error';
+    if (options?.renderPrompt !== false) {
+        const prompt = await readStoredPrompt(sessionId);
+        if (prompt) {
+            console.log(chalk.bold('Prompt:'));
+            console.log(renderMarkdownAnsi(prompt));
+            console.log(dim('---'));
+        }
+    }
     if (shouldTrimIntro) {
         const fullLog = await readSessionLog(sessionId);
         const trimmed = trimBeforeFirstAnswer(fullLog);
@@ -104,6 +119,10 @@ export async function attachSession(sessionId, options) {
         else {
             process.stdout.write(trimmed);
         }
+        const summary = formatCompletionSummary(metadata, { includeSlug: true });
+        if (summary) {
+            console.log(`\n${chalk.green.bold(summary)}`);
+        }
         return;
     }
     if (wantsRender) {
@@ -187,9 +206,15 @@ export async function attachSession(sessionId, options) {
                     console.log('\nResult:');
                     console.log(`Session failed: ${latest.errorMessage}`);
                 }
-                if (latest.usage && initialStatus === 'running') {
-                    const usage = latest.usage;
-                    console.log(`\nFinished (tok i/o/r/t: ${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens})`);
+                if (latest.status === 'completed' && latest.usage) {
+                    const summary = formatCompletionSummary(latest, { includeSlug: true });
+                    if (summary) {
+                        console.log(`\n${chalk.green.bold(summary)}`);
+                    }
+                    else {
+                        const usage = latest.usage;
+                        console.log(`\nFinished (tok i/o/r/t: ${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens})`);
+                    }
                 }
             }
             break;
@@ -359,3 +384,65 @@ function extractRenderableChunks(text, state) {
     }
     return { chunks, remainder: buffer };
 }
+function formatTimestamp(iso) {
+    const date = new Date(iso);
+    const locale = 'en-US';
+    const opts = {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: 'numeric',
+        minute: '2-digit',
+        second: undefined,
+        hour12: true,
+    };
+    const formatted = date.toLocaleString(locale, opts);
+    return formatted.replace(/(, )(\d:)/, '$1 $2');
+}
+export function formatCompletionSummary(metadata, options = {}) {
+    if (!metadata.usage || metadata.elapsedMs == null) {
+        return null;
+    }
+    const modeLabel = metadata.mode === 'browser' ? `${metadata.model ?? 'n/a'}[browser]` : metadata.model ?? 'n/a';
+    const usage = metadata.usage;
+    const cost = metadata.mode === 'browser' ? null : resolveCost(metadata);
+    const costPart = cost != null ? ` | ${formatUSD(cost)}` : '';
+    const tokensDisplay = `${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens}`;
+    const filesCount = metadata.options?.file?.length ?? 0;
+    const filesPart = filesCount > 0 ? ` | files=${filesCount}` : '';
+    const slugPart = options.includeSlug ? ` | slug=${metadata.id}` : '';
+    return `Finished in ${formatElapsed(metadata.elapsedMs)} (${modeLabel}${costPart} | tok(i/o/r/t)=${tokensDisplay}${filesPart}${slugPart})`;
+}
+function resolveCost(metadata) {
+    if (metadata.mode === 'browser') {
+        return null;
+    }
+    if (metadata.usage?.cost != null) {
+        return metadata.usage.cost;
+    }
+    if (!metadata.model || !metadata.usage) {
+        return null;
+    }
+    const pricing = MODEL_CONFIGS[metadata.model]?.pricing;
+    if (!pricing) {
+        return null;
+    }
+    const input = metadata.usage.inputTokens ?? 0;
+    const output = metadata.usage.outputTokens ?? 0;
+    const cost = input * pricing.inputPerToken + output * pricing.outputPerToken;
+    return cost > 0 ? cost : null;
+}
+function formatCostTable(cost) {
+    return `$${cost.toFixed(3)}`.padStart(7);
+}
+async function readStoredPrompt(sessionId) {
+    const request = await readSessionRequest(sessionId);
+    if (request?.prompt && request.prompt.trim().length > 0) {
+        return request.prompt;
+    }
+    const meta = await readSessionMetadata(sessionId);
+    if (meta?.options?.prompt && meta.options.prompt.trim().length > 0) {
+        return meta.options.prompt;
+    }
+    return null;
+}

package/dist/src/cli/sessionRunner.js

@@ -1,20 +1,28 @@
 import kleur from 'kleur';
 import { updateSessionMetadata } from '../sessionManager.js';
-import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, } from '../oracle.js';
+import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, } from '../oracle.js';
 import { runBrowserSessionExecution } from '../browser/sessionRunner.js';
 import { formatResponseMetadata, formatTransportMetadata } from './sessionDisplay.js';
 import { markErrorLogged } from './errorUtils.js';
+import { sendSessionNotification, deriveNotificationSettingsFromMetadata, } from './notifier.js';
 const isTty = process.stdout.isTTY;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
-export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, }) {
+export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, }) {
     await updateSessionMetadata(sessionMeta.id, {
         status: 'running',
         startedAt: new Date().toISOString(),
         mode,
         ...(browserConfig ? { browser: { config: browserConfig } } : {}),
     });
+    const notificationSettings = notifications ?? deriveNotificationSettingsFromMetadata(sessionMeta, process.env);
     try {
         if (mode === 'browser') {
+            if (runOptions.model.startsWith('gemini')) {
+                throw new Error('Gemini models are not available in browser mode. Re-run with --engine api.');
+            }
+            if (process.platform !== 'darwin') {
+                throw new Error('Browser engine is only supported on macOS today. Use --engine api instead, or run on macOS.');
+            }
             if (!browserConfig) {
                 throw new Error('Missing browser configuration for session.');
             }
@@ -32,6 +40,14 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 transport: undefined,
                 error: undefined,
             });
+            await sendSessionNotification({
+                sessionId: sessionMeta.id,
+                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+                mode,
+                model: sessionMeta.model,
+                usage: result.usage,
+                characters: result.answerText?.length,
+            }, notificationSettings, log, result.answerText?.slice(0, 140));
             return;
         }
         const result = await runOracle(runOptions, {
@@ -51,6 +67,15 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             transport: undefined,
             error: undefined,
         });
+        const answerText = extractTextOutput(result.response);
+        await sendSessionNotification({
+            sessionId: sessionMeta.id,
+            sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+            mode,
+            model: sessionMeta.model ?? runOptions.model,
+            usage: result.usage,
+            characters: answerText.length,
+        }, notificationSettings, log, answerText.slice(0, 140));
     }
     catch (error) {
         const message = formatError(error);
@@ -86,6 +111,11 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 }
                 : undefined,
         });
+        if (mode === 'browser') {
+            log(dim('Browser fallback:')); // guides users when automation breaks
+            log(dim('- Use --engine api to run the same prompt without Chrome.'));
+            log(dim('- Add --browser-bundle-files to bundle attachments into a single text file you can drag into ChatGPT.'));
+        }
         throw error;
     }
 }

package/dist/src/cli/tui/index.js

@@ -0,0 +1,457 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import kleur from 'kleur';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { MODEL_CONFIGS } from '../../oracle.js';
+import { renderMarkdownAnsi } from '../markdownRenderer.js';
+import { createSessionLogWriter, getSessionPaths, initializeSession, listSessionsMetadata, readSessionLog, readSessionMetadata, readSessionRequest, ensureSessionStorage, } from '../../sessionManager.js';
+import { performSessionRun } from '../sessionRunner.js';
+import { MAX_RENDER_BYTES, trimBeforeFirstAnswer } from '../sessionDisplay.js';
+import { buildBrowserConfig, resolveBrowserModelLabel } from '../browserConfig.js';
+import { resolveNotificationSettings } from '../notifier.js';
+import { loadUserConfig } from '../../config.js';
+const isTty = () => Boolean(process.stdout.isTTY && chalk.level > 0);
+const dim = (text) => (isTty() ? kleur.dim(text) : text);
+const RECENT_WINDOW_HOURS = 24;
+const PAGE_SIZE = 10;
+const STATUS_PAD = 9;
+const MODEL_PAD = 13;
+const MODE_PAD = 7;
+const TIMESTAMP_PAD = 19;
+const CHARS_PAD = 5;
+const COST_PAD = 7;
+export async function launchTui({ version }) {
+    const userConfig = (await loadUserConfig()).config;
+    console.log(chalk.bold(`🧿 oracle v${version}`), dim('— Whispering your tokens to the silicon sage'));
+    console.log('');
+    let showingOlder = false;
+    for (;;) {
+        const { recent, older, olderTotal } = await fetchSessionBuckets();
+        const choices = [];
+        const headerLabel = dim(`${'Status'.padEnd(STATUS_PAD)} ${'Model'.padEnd(MODEL_PAD)} ${'Mode'.padEnd(MODE_PAD)} ${'Timestamp'.padEnd(TIMESTAMP_PAD)} ${'Chars'.padStart(CHARS_PAD)} ${'Cost'.padStart(COST_PAD)}  Slug`);
+        // Start with a selectable row so focus never lands on a separator
+        choices.push({ name: chalk.bold.green('ask oracle'), value: '__ask__' });
+        choices.push(new inquirer.Separator());
+        if (!showingOlder) {
+            if (recent.length > 0) {
+                choices.push(new inquirer.Separator(headerLabel));
+                choices.push(...recent.map(toSessionChoice));
+            }
+            else if (older.length > 0) {
+                // No recent entries; show first page of older.
+                choices.push(new inquirer.Separator(headerLabel));
+                choices.push(...older.slice(0, PAGE_SIZE).map(toSessionChoice));
+            }
+        }
+        else if (older.length > 0) {
+            choices.push(new inquirer.Separator(headerLabel));
+            choices.push(...older.map(toSessionChoice));
+        }
+        choices.push(new inquirer.Separator());
+        choices.push(new inquirer.Separator('Actions'));
+        choices.push({ name: chalk.bold.green('ask oracle'), value: '__ask__' });
+        if (!showingOlder && olderTotal > 0) {
+            choices.push({ name: 'Older page', value: '__older__' });
+        }
+        else {
+            choices.push({ name: 'Newer (recent)', value: '__reset__' });
+        }
+        choices.push({ name: 'Exit', value: '__exit__' });
+        const selection = await new Promise((resolve) => {
+            const prompt = inquirer.prompt([
+                {
+                    name: 'selection',
+                    type: 'list',
+                    message: 'Select a session or action',
+                    choices,
+                    pageSize: 16,
+                    loop: false,
+                },
+            ]);
+            prompt
+                .then(({ selection: answer }) => resolve(answer))
+                .catch((error) => {
+                console.error(chalk.red('Paging failed; returning to recent list.'), error instanceof Error ? error.message : error);
+                resolve('__reset__');
+            });
+        });
+        if (selection === '__exit__') {
+            console.log(chalk.green('🧿 Closing the book. See you next prompt.'));
+            return;
+        }
+        if (selection === '__ask__') {
+            await askOracleFlow(version, userConfig);
+            continue;
+        }
+        if (selection === '__older__') {
+            showingOlder = true;
+            continue;
+        }
+        if (selection === '__reset__') {
+            showingOlder = false;
+            continue;
+        }
+        await showSessionDetail(selection);
+    }
+}
+async function fetchSessionBuckets() {
+    const all = await listSessionsMetadata();
+    const cutoff = Date.now() - RECENT_WINDOW_HOURS * 60 * 60 * 1000;
+    const recent = all.filter((meta) => new Date(meta.createdAt).getTime() >= cutoff).slice(0, PAGE_SIZE);
+    const olderAll = all.filter((meta) => new Date(meta.createdAt).getTime() < cutoff);
+    const older = olderAll.slice(0, PAGE_SIZE);
+    const hasMoreOlder = olderAll.length > PAGE_SIZE;
+    if (recent.length === 0 && older.length === 0 && olderAll.length > 0) {
+        // No recent entries; fall back to top 10 overall.
+        return { recent: olderAll.slice(0, PAGE_SIZE), older: [], hasMoreOlder: olderAll.length > PAGE_SIZE, olderTotal: olderAll.length };
+    }
+    return { recent, older, hasMoreOlder, olderTotal: olderAll.length };
+}
+function toSessionChoice(meta) {
+    return {
+        name: formatSessionLabel(meta),
+        value: meta.id,
+    };
+}
+function formatSessionLabel(meta) {
+    const status = colorStatus(meta.status ?? 'unknown');
+    const created = formatTimestampAligned(meta.createdAt);
+    const model = meta.model ?? 'n/a';
+    const mode = meta.mode ?? meta.options?.mode ?? 'api';
+    const slug = meta.id;
+    const chars = meta.options?.prompt?.length ?? meta.promptPreview?.length ?? 0;
+    const charLabel = chars > 0 ? chalk.gray(String(chars).padStart(CHARS_PAD)) : chalk.gray(`${''.padStart(CHARS_PAD - 1)}-`);
+    const cost = mode === 'browser' ? null : resolveCost(meta);
+    const costLabel = cost != null ? chalk.gray(formatCostTable(cost)) : chalk.gray(`${''.padStart(COST_PAD - 1)}-`);
+    return `${status} ${chalk.white(model.padEnd(MODEL_PAD))} ${chalk.gray(mode.padEnd(MODE_PAD))} ${chalk.gray(created.padEnd(TIMESTAMP_PAD))} ${charLabel} ${costLabel}  ${chalk.cyan(slug)}`;
+}
+function resolveCost(meta) {
+    if (meta.usage?.cost != null) {
+        return meta.usage.cost;
+    }
+    if (!meta.model || !meta.usage) {
+        return null;
+    }
+    const pricing = MODEL_CONFIGS[meta.model]?.pricing;
+    if (!pricing)
+        return null;
+    const input = meta.usage.inputTokens ?? 0;
+    const output = meta.usage.outputTokens ?? 0;
+    const cost = input * pricing.inputPerToken + output * pricing.outputPerToken;
+    return cost > 0 ? cost : null;
+}
+function formatCostTable(cost) {
+    return `$${cost.toFixed(3)}`.padStart(COST_PAD);
+}
+function formatTimestampAligned(iso) {
+    const date = new Date(iso);
+    const locale = 'en-US';
+    const opts = {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: 'numeric',
+        minute: '2-digit',
+        second: undefined,
+        hour12: true,
+    };
+    let formatted = date.toLocaleString(locale, opts);
+    // Drop the comma and use double-space between date and time for alignment.
+    formatted = formatted.replace(', ', '  ');
+    // Insert a leading space when hour is a single digit to align AM/PM column.
+    // Example: "11/18/2025  1:07 AM" -> "11/18/2025   1:07 AM"
+    return formatted.replace(/(\s)(\d:)/, '$1 $2');
+}
+function colorStatus(status) {
+    const padded = status.padEnd(9);
+    switch (status) {
+        case 'completed':
+            return chalk.green(padded);
+        case 'error':
+            return chalk.red(padded);
+        case 'running':
+            return chalk.yellow(padded);
+        default:
+            return padded;
+    }
+}
+async function showSessionDetail(sessionId) {
+    for (;;) {
+        const meta = await readSessionMetadataSafe(sessionId);
+        if (!meta) {
+            console.log(chalk.red(`No session found with ID ${sessionId}`));
+            return;
+        }
+        console.clear();
+        printSessionHeader(meta);
+        const prompt = await readStoredPrompt(sessionId);
+        if (prompt) {
+            console.log(chalk.bold('Prompt:'));
+            console.log(renderMarkdownAnsi(prompt));
+            console.log(dim('---'));
+        }
+        const logPath = await getSessionLogPath(sessionId);
+        if (logPath) {
+            console.log(dim(`Log file: ${logPath}`));
+        }
+        console.log('');
+        await renderSessionLog(sessionId);
+        const isRunning = meta.status === 'running';
+        const actions = [
+            ...(isRunning ? [{ name: 'Refresh', value: 'refresh' }] : []),
+            { name: 'Back', value: 'back' },
+        ];
+        const { next } = await inquirer.prompt([
+            {
+                name: 'next',
+                type: 'list',
+                message: 'Actions',
+                choices: actions,
+            },
+        ]);
+        if (next === 'back') {
+            return;
+        }
+        // refresh loops
+    }
+}
+async function renderSessionLog(sessionId) {
+    const raw = await readSessionLog(sessionId);
+    const text = trimBeforeFirstAnswer(raw);
+    const size = Buffer.byteLength(text, 'utf8');
+    if (size > MAX_RENDER_BYTES) {
+        console.log(chalk.yellow(`Log is large (${size.toLocaleString()} bytes). Rendering raw text; open the log file for full context.`));
+        process.stdout.write(text);
+        console.log('');
+        return;
+    }
+    process.stdout.write(renderMarkdownAnsi(text));
+    console.log('');
+}
+async function getSessionLogPath(sessionId) {
+    try {
+        const paths = await getSessionPaths(sessionId);
+        return paths.log;
+    }
+    catch {
+        return null;
+    }
+}
+function printSessionHeader(meta) {
+    console.log(chalk.bold(`Session ${chalk.cyan(meta.id)}`));
+    console.log(`${chalk.white('Status:')} ${meta.status}`);
+    console.log(`${chalk.white('Created:')} ${meta.createdAt}`);
+    if (meta.model) {
+        console.log(`${chalk.white('Model:')} ${meta.model}`);
+    }
+    const mode = meta.mode ?? meta.options?.mode;
+    if (mode) {
+        console.log(`${chalk.white('Mode:')} ${mode}`);
+    }
+    if (meta.errorMessage) {
+        console.log(chalk.red(`Error: ${meta.errorMessage}`));
+    }
+}
+async function askOracleFlow(version, userConfig) {
+    const modelChoices = Object.keys(MODEL_CONFIGS);
+    const hasApiKey = Boolean(process.env.OPENAI_API_KEY);
+    const initialMode = hasApiKey ? 'api' : 'browser';
+    const preferredMode = userConfig.engine ?? initialMode;
+    const answers = await inquirer.prompt([
+        {
+            name: 'promptInput',
+            type: 'input',
+            message: 'Paste your prompt text or a path to a file (leave blank to cancel):',
+        },
+        ...(hasApiKey
+            ? [
+                {
+                    name: 'mode',
+                    type: 'list',
+                    message: 'Engine',
+                    default: preferredMode,
+                    choices: [
+                        { name: 'API', value: 'api' },
+                        { name: 'Browser', value: 'browser' },
+                    ],
+                },
+            ]
+            : [
+                {
+                    name: 'mode',
+                    type: 'list',
+                    message: 'Engine',
+                    default: preferredMode,
+                    choices: [{ name: 'Browser', value: 'browser' }],
+                },
+            ]),
+        {
+            name: 'slug',
+            type: 'input',
+            message: 'Optional slug (3–5 words, leave blank for auto):',
+        },
+        {
+            name: 'model',
+            type: 'list',
+            message: 'Model',
+            default: 'gpt-5-pro',
+            choices: modelChoices,
+        },
+        {
+            name: 'files',
+            type: 'input',
+            message: 'Files or globs to attach (comma-separated, optional):',
+            filter: (value) => value
+                .split(',')
+                .map((entry) => entry.trim())
+                .filter(Boolean),
+        },
+        {
+            name: 'chromeProfile',
+            type: 'input',
+            message: 'Chrome profile to reuse cookies from:',
+            default: 'Default',
+            when: (ans) => ans.mode === 'browser',
+        },
+        {
+            name: 'headless',
+            type: 'confirm',
+            message: 'Run Chrome headless?',
+            default: false,
+            when: (ans) => ans.mode === 'browser',
+        },
+        {
+            name: 'hideWindow',
+            type: 'confirm',
+            message: 'Hide Chrome window (macOS headful only)?',
+            default: false,
+            when: (ans) => ans.mode === 'browser',
+        },
+        {
+            name: 'keepBrowser',
+            type: 'confirm',
+            message: 'Keep browser open after completion?',
+            default: false,
+            when: (ans) => ans.mode === 'browser',
+        },
+    ]);
+    const mode = (answers.mode ?? initialMode);
+    const prompt = await resolvePromptInput(answers.promptInput);
+    if (!prompt.trim()) {
+        console.log(chalk.yellow('Cancelled.'));
+        return;
+    }
+    const promptWithSuffix = userConfig.promptSuffix ? `${prompt.trim()}\n${userConfig.promptSuffix}` : prompt;
+    await ensureSessionStorage();
+    const runOptions = {
+        prompt: promptWithSuffix,
+        model: answers.model,
+        file: answers.files,
+        slug: answers.slug,
+        filesReport: false,
+        maxInput: undefined,
+        maxOutput: undefined,
+        system: undefined,
+        silent: false,
+        search: undefined,
+        preview: false,
+        previewMode: undefined,
+        apiKey: undefined,
+        sessionId: undefined,
+        verbose: false,
+        heartbeatIntervalMs: undefined,
+        browserInlineFiles: false,
+        browserBundleFiles: false,
+        background: undefined,
+    };
+    const browserConfig = mode === 'browser'
+        ? await buildBrowserConfig({
+            browserChromeProfile: answers.chromeProfile,
+            browserHeadless: answers.headless,
+            browserHideWindow: answers.hideWindow,
+            browserKeepBrowser: answers.keepBrowser,
+            browserModelLabel: resolveBrowserModelLabel(undefined, answers.model),
+            model: answers.model,
+        })
+        : undefined;
+    const notifications = resolveNotificationSettings({
+        cliNotify: undefined,
+        cliNotifySound: undefined,
+        env: process.env,
+        config: userConfig.notify,
+    });
+    const sessionMeta = await initializeSession({
+        ...runOptions,
+        mode,
+        browserConfig,
+    }, process.cwd(), notifications);
+    const { logLine, writeChunk, stream } = createSessionLogWriter(sessionMeta.id);
+    const combinedLog = (message) => {
+        if (message) {
+            console.log(message);
+            logLine(message);
+        }
+    };
+    const combinedWrite = (chunk) => {
+        writeChunk(chunk);
+        return process.stdout.write(chunk);
+    };
+    console.log(chalk.bold(`Session ${sessionMeta.id} starting...`));
+    console.log(dim(`Log path: ${path.join(os.homedir(), '.oracle', 'sessions', sessionMeta.id, 'output.log')}`));
+    try {
+        await performSessionRun({
+            sessionMeta,
+            runOptions: { ...runOptions, sessionId: sessionMeta.id },
+            mode,
+            browserConfig,
+            cwd: process.cwd(),
+            log: combinedLog,
+            write: combinedWrite,
+            version,
+            notifications,
+        });
+        console.log(chalk.green(`Session ${sessionMeta.id} completed.`));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(chalk.red(`Session ${sessionMeta.id} failed: ${message}`));
+    }
+    finally {
+        stream.end();
+    }
+}
+const readSessionMetadataSafe = (sessionId) => readSessionMetadata(sessionId);
+async function resolvePromptInput(rawInput) {
+    const trimmed = rawInput.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    const asPath = path.resolve(process.cwd(), trimmed);
+    try {
+        const stats = await fs.stat(asPath);
+        if (stats.isFile()) {
+            const contents = await fs.readFile(asPath, 'utf8');
+            return contents;
+        }
+    }
+    catch {
+        // not a file; fall through
+    }
+    return trimmed;
+}
+async function readStoredPrompt(sessionId) {
+    const request = await readSessionRequest(sessionId);
+    if (request?.prompt && request.prompt.trim().length > 0) {
+        return request.prompt;
+    }
+    const meta = await readSessionMetadata(sessionId);
+    if (meta?.options?.prompt && meta.options.prompt.trim().length > 0) {
+        return meta.options.prompt;
+    }
+    return null;
+}
+// Exported for testing
+export { askOracleFlow, showSessionDetail };
+export { resolveCost };