@steipete/oracle 1.1.0 → 1.3.0

package/dist/src/cli/dryRun.js

@@ -2,9 +2,9 @@ import chalk from 'chalk';
 import { MODEL_CONFIGS, TOKENIZER_OPTIONS, DEFAULT_SYSTEM_PROMPT, buildPrompt, readFiles, getFileTokenStats, printFileTokenStats, } from '../oracle.js';
 import { assembleBrowserPrompt } from '../browser/prompt.js';
 import { buildTokenEstimateSuffix, formatAttachmentLabel } from '../browser/promptSummary.js';
-export async function runDryRunSummary({ engine, runOptions, cwd, version, log, }, deps = {}) {
+export async function runDryRunSummary({ engine, runOptions, cwd, version, log, browserConfig, }, deps = {}) {
     if (engine === 'browser') {
-        await runBrowserDryRun({ runOptions, cwd, version, log }, deps);
+        await runBrowserDryRun({ runOptions, cwd, version, log, browserConfig }, deps);
         return;
     }
     await runApiDryRun({ runOptions, cwd, version, log }, deps);
@@ -34,26 +34,78 @@ async function runApiDryRun({ runOptions, cwd, version, log, }, deps) {
     });
     printFileTokenStats(stats, { inputTokenBudget: inputBudget, log });
 }
-async function runBrowserDryRun({ runOptions, cwd, version, log, }, deps) {
+async function runBrowserDryRun({ runOptions, cwd, version, log, browserConfig, }, deps) {
     const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
     const artifacts = await assemblePromptImpl(runOptions, { cwd });
     const suffix = buildTokenEstimateSuffix(artifacts);
     const headerLine = `[dry-run] Oracle (${version}) would launch browser mode (${runOptions.model}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
     log(chalk.cyan(headerLine));
-    logBrowserFileSummary(artifacts, log);
+    logBrowserCookieStrategy(browserConfig, log, 'dry-run');
+    logBrowserFileSummary(artifacts, log, 'dry-run');
 }
-function logBrowserFileSummary(artifacts, log) {
+function logBrowserCookieStrategy(browserConfig, log, label) {
+    if (!browserConfig)
+        return;
+    if (browserConfig.inlineCookies && browserConfig.inlineCookies.length > 0) {
+        const source = browserConfig.inlineCookiesSource ?? 'inline';
+        log(chalk.bold(`[${label}] Cookies: inline payload (${browserConfig.inlineCookies.length}) via ${source}.`));
+        return;
+    }
+    if (browserConfig.cookieSync === false) {
+        log(chalk.bold(`[${label}] Cookies: sync disabled (--browser-no-cookie-sync).`));
+        return;
+    }
+    const allowlist = browserConfig.cookieNames?.length ? browserConfig.cookieNames.join(', ') : 'all from Chrome profile';
+    log(chalk.bold(`[${label}] Cookies: copy from Chrome (${allowlist}).`));
+}
+function logBrowserFileSummary(artifacts, log, label) {
     if (artifacts.attachments.length > 0) {
-        log(chalk.bold('[dry-run] Attachments to upload:'));
+        const prefix = artifacts.bundled ? `[${label}] Bundled upload:` : `[${label}] Attachments to upload:`;
+        log(chalk.bold(prefix));
         artifacts.attachments.forEach((attachment) => {
             log(`  • ${formatAttachmentLabel(attachment)}`);
         });
+        if (artifacts.bundled) {
+            log(chalk.dim(`  (bundled ${artifacts.bundled.originalCount} files into ${artifacts.bundled.bundlePath})`));
+        }
         return;
     }
     if (artifacts.inlineFileCount > 0) {
-        log(chalk.bold('[dry-run] Inline file content:'));
+        log(chalk.bold(`[${label}] Inline file content:`));
         log(`  • ${artifacts.inlineFileCount} file${artifacts.inlineFileCount === 1 ? '' : 's'} pasted directly into the composer.`);
         return;
     }
-    log(chalk.dim('[dry-run] No files attached.'));
+    log(chalk.dim(`[${label}] No files attached.`));
+}
+export async function runBrowserPreview({ runOptions, cwd, version, previewMode, log, }, deps = {}) {
+    const assemblePromptImpl = deps.assembleBrowserPromptImpl ?? assembleBrowserPrompt;
+    const artifacts = await assemblePromptImpl(runOptions, { cwd });
+    const suffix = buildTokenEstimateSuffix(artifacts);
+    const headerLine = `[preview] Oracle (${version}) browser mode (${runOptions.model}) with ~${artifacts.estimatedInputTokens.toLocaleString()} tokens${suffix}.`;
+    log(chalk.cyan(headerLine));
+    logBrowserFileSummary(artifacts, log, 'preview');
+    if (previewMode === 'json' || previewMode === 'full') {
+        const attachmentSummary = artifacts.attachments.map((attachment) => ({
+            path: attachment.path,
+            displayPath: attachment.displayPath,
+            sizeBytes: attachment.sizeBytes,
+        }));
+        const previewPayload = {
+            model: runOptions.model,
+            engine: 'browser',
+            composerText: artifacts.composerText,
+            attachments: attachmentSummary,
+            inlineFileCount: artifacts.inlineFileCount,
+            bundled: artifacts.bundled,
+            tokenEstimate: artifacts.estimatedInputTokens,
+        };
+        log('');
+        log(chalk.bold('Preview JSON'));
+        log(JSON.stringify(previewPayload, null, 2));
+    }
+    if (previewMode === 'full') {
+        log('');
+        log(chalk.bold('Composer Text'));
+        log(artifacts.composerText || chalk.dim('(empty prompt)'));
+    }
 }

package/dist/src/cli/engine.js

@@ -1,3 +1,10 @@
+export function defaultWaitPreference(model, engine) {
+    // gpt-5-pro (API) can take up to 10 minutes; default to non-blocking
+    if (engine === 'api' && model === 'gpt-5-pro') {
+        return false;
+    }
+    return true; // browser or gpt-5.1 are fast enough to block by default
+}
 /**
  * Determine which engine to use based on CLI flags and the environment.
  *

package/dist/src/cli/help.js

@@ -43,11 +43,13 @@ function renderHelpBanner(version, colors) {
 }
 function renderHelpFooter(program, colors) {
     const tips = [
+        `${colors.bullet('•')} Oracle cannot see your project unless you pass ${colors.accent('--file …')} — attach the files/dirs you want it to read.`,
         `${colors.bullet('•')} Attach lots of source (whole directories beat single files) and keep total input under ~196k tokens.`,
         `${colors.bullet('•')} Oracle starts empty—open with a short project briefing (stack, services, build steps), spell out the question and prior attempts, and why it matters; the more explanation and context you provide, the better the response will be.`,
+        `${colors.bullet('•')} Best results: 6–30 sentences plus key source files; very short prompts often yield generic answers.`,
         `${colors.bullet('•')} Oracle is one-shot: it does not remember prior runs, so start fresh each time with full context.`,
         `${colors.bullet('•')} Run ${colors.accent('--files-report')} to inspect token spend before hitting the API.`,
-        `${colors.bullet('•')} Non-preview runs spawn detached sessions so they keep streaming even if your terminal closes — reattach anytime via ${colors.accent('pnpm oracle session <slug>')}.`,
+        `${colors.bullet('•')} Non-preview runs spawn detached sessions (especially gpt-5-pro API). If the CLI times out, do not re-run — reattach with ${colors.accent('oracle session <slug>')} to resume/inspect the existing run.`,
         `${colors.bullet('•')} Set a memorable 3–5 word slug via ${colors.accent('--slug "<words>"')} to keep session IDs tidy.`,
         `${colors.bullet('•')} Finished sessions auto-hide preamble logs when reattached; raw timestamps remain in the saved log file.`,
         `${colors.bullet('•')} Need hidden flags? Run ${colors.accent(`${program.name()} --help --verbose`)} to list search/token/browser overrides.`,

package/dist/src/cli/hiddenAliases.js

@@ -0,0 +1,17 @@
+/**
+ * Normalize hidden alias flags so they behave like their primary counterparts.
+ *
+ * - `--message` maps to `--prompt` when no prompt is provided.
+ * - `--include` extends the `--file` list.
+ */
+export function applyHiddenAliases(options, setOptionValue) {
+    if (options.include && options.include.length > 0) {
+        const mergedFiles = [...(options.file ?? []), ...options.include];
+        options.file = mergedFiles;
+        setOptionValue?.('file', mergedFiles);
+    }
+    if (!options.prompt && options.message) {
+        options.prompt = options.message;
+        setOptionValue?.('prompt', options.message);
+    }
+}

package/dist/src/cli/markdownRenderer.js

@@ -1,4 +1,82 @@
+import chalk from 'chalk';
 import { render as renderMarkdown } from 'markdansi';
+import { bundledLanguages, bundledThemes, createHighlighter, } from 'shiki';
+const DEFAULT_THEME = 'github-dark';
+const HIGHLIGHT_LANGS = ['ts', 'tsx', 'js', 'jsx', 'json', 'swift'];
+const SUPPORTED_LANG_ALIASES = {
+    ts: 'ts',
+    typescript: 'ts',
+    tsx: 'tsx',
+    js: 'js',
+    javascript: 'js',
+    jsx: 'jsx',
+    json: 'json',
+    swift: 'swift',
+};
+const shikiPromise = createHighlighter({
+    themes: [bundledThemes[DEFAULT_THEME]],
+    langs: HIGHLIGHT_LANGS.map((lang) => bundledLanguages[lang]),
+});
+let shiki = null;
+void shikiPromise
+    .then((instance) => {
+    shiki = instance;
+})
+    .catch(() => {
+    shiki = null;
+});
+export async function ensureShikiReady() {
+    if (shiki)
+        return;
+    try {
+        shiki = await shikiPromise;
+    }
+    catch {
+        shiki = null;
+    }
+}
+function normalizeLanguage(lang) {
+    if (!lang)
+        return null;
+    const key = lang.toLowerCase();
+    return SUPPORTED_LANG_ALIASES[key] ?? null;
+}
+function styleToken(text, fontStyle = 0) {
+    let styled = text;
+    if (fontStyle & 1)
+        styled = chalk.italic(styled);
+    if (fontStyle & 2)
+        styled = chalk.bold(styled);
+    if (fontStyle & 4)
+        styled = chalk.underline(styled);
+    if (fontStyle & 8)
+        styled = chalk.strikethrough(styled);
+    return styled;
+}
+function shikiHighlighter(code, lang) {
+    if (!process.stdout.isTTY || !shiki)
+        return code;
+    const normalizedLang = normalizeLanguage(lang);
+    if (!normalizedLang)
+        return code;
+    try {
+        if (!shiki.getLoadedLanguages().includes(normalizedLang)) {
+            return code;
+        }
+        const { tokens } = shiki.codeToTokens(code, { lang: normalizedLang, theme: DEFAULT_THEME });
+        return tokens
+            .map((line) => line
+            .map((token) => {
+            const colored = token.color ? chalk.hex(token.color)(token.content) : token.content;
+            return styleToken(colored, token.fontStyle);
+        })
+            .join(''))
+            .join('\n');
+    }
+    catch {
+        return code;
+    }
+}
 export function renderMarkdownAnsi(markdown) {
     try {
         const color = Boolean(process.stdout.isTTY);
@@ -9,6 +87,7 @@ export function renderMarkdownAnsi(markdown) {
             width,
             wrap: true,
             hyperlinks,
+            highlighter: color ? shikiHighlighter : undefined,
         });
     }
     catch {

package/dist/src/cli/notifier.js

@@ -0,0 +1,223 @@
+import notifier from 'toasted-notifier';
+import { spawn } from 'node:child_process';
+import { formatUSD, formatNumber } from '../oracle/format.js';
+import { MODEL_CONFIGS } from '../oracle/config.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+const ORACLE_EMOJI = '🧿';
+export function resolveNotificationSettings({ cliNotify, cliNotifySound, env, config, }) {
+    const defaultEnabled = !(bool(env.CI) || bool(env.SSH_CONNECTION) || muteByConfig(env, config));
+    const envNotify = parseToggle(env.ORACLE_NOTIFY);
+    const envSound = parseToggle(env.ORACLE_NOTIFY_SOUND);
+    const enabled = cliNotify ?? envNotify ?? config?.enabled ?? defaultEnabled;
+    const sound = cliNotifySound ?? envSound ?? config?.sound ?? false;
+    return { enabled, sound };
+}
+export function deriveNotificationSettingsFromMetadata(metadata, env, config) {
+    if (metadata?.notifications) {
+        return metadata.notifications;
+    }
+    return resolveNotificationSettings({ cliNotify: undefined, cliNotifySound: undefined, env, config });
+}
+export async function sendSessionNotification(payload, settings, log, answerPreview) {
+    if (!settings.enabled || isTestEnv(process.env)) {
+        return;
+    }
+    const title = `Oracle${ORACLE_EMOJI} finished`;
+    const message = buildMessage(payload, sanitizePreview(answerPreview));
+    try {
+        if (await tryMacNativeNotifier(title, message, settings)) {
+            return;
+        }
+        // Fallback to toasted-notifier (cross-platform). macAppIconOption() is only honored on macOS.
+        await notifier.notify({
+            title,
+            message,
+            sound: settings.sound,
+        });
+    }
+    catch (error) {
+        if (isMacExecError(error)) {
+            const repaired = await repairMacNotifier(log);
+            if (repaired) {
+                try {
+                    await notifier.notify({ title, message, sound: settings.sound, ...(macAppIconOption()) });
+                    return;
+                }
+                catch (retryError) {
+                    const reason = retryError instanceof Error ? retryError.message : String(retryError);
+                    log(`(notify skipped after retry: ${reason})`);
+                    return;
+                }
+            }
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        log(`(notify skipped: ${reason})`);
+    }
+}
+function buildMessage(payload, answerPreview) {
+    const parts = [];
+    const sessionLabel = payload.sessionName || payload.sessionId;
+    parts.push(sessionLabel);
+    // Show cost only for API runs.
+    if (payload.mode === 'api') {
+        const cost = payload.costUsd ?? inferCost(payload);
+        if (cost !== undefined) {
+            // Round to $0.00 for a concise toast.
+            parts.push(formatUSD(Number(cost.toFixed(2))));
+        }
+    }
+    if (payload.characters != null) {
+        parts.push(`${formatNumber(payload.characters)} chars`);
+    }
+    if (answerPreview) {
+        parts.push(answerPreview);
+    }
+    return parts.join(' · ');
+}
+function sanitizePreview(preview) {
+    if (!preview)
+        return undefined;
+    let text = preview;
+    // Strip code fences and inline code markers.
+    text = text.replace(/```[\s\S]*?```/g, ' ');
+    text = text.replace(/`([^`]+)`/g, '$1');
+    // Convert markdown links and images to their visible text.
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1');
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+    // Drop bold/italic markers.
+    text = text.replace(/(\*\*|__|\*|_)/g, '');
+    // Remove headings / list markers / blockquotes.
+    text = text.replace(/^\s*#+\s*/gm, '');
+    text = text.replace(/^\s*[-*+]\s+/gm, '');
+    text = text.replace(/^\s*>\s+/gm, '');
+    // Collapse whitespace and trim.
+    text = text.replace(/\s+/g, ' ').trim();
+    // Limit length to keep notifications short.
+    const max = 200;
+    if (text.length > max) {
+        text = `${text.slice(0, max - 1)}…`;
+    }
+    return text;
+}
+// Exposed for unit tests only.
+export const testHelpers = { sanitizePreview };
+function inferCost(payload) {
+    const model = payload.model;
+    const usage = payload.usage;
+    if (!model || !usage)
+        return undefined;
+    const config = MODEL_CONFIGS[model];
+    if (!config)
+        return undefined;
+    return (usage.inputTokens * config.pricing.inputPerToken +
+        usage.outputTokens * config.pricing.outputPerToken);
+}
+function parseToggle(value) {
+    if (value == null)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return undefined;
+}
+function bool(value) {
+    return Boolean(value && String(value).length > 0);
+}
+function isMacExecError(error) {
+    return Boolean(process.platform === 'darwin' &&
+        error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        error.code === 'EACCES');
+}
+async function repairMacNotifier(log) {
+    const binPath = macNotifierPath();
+    if (!binPath)
+        return false;
+    try {
+        await fs.chmod(binPath, 0o755);
+        return true;
+    }
+    catch (chmodError) {
+        const reason = chmodError instanceof Error ? chmodError.message : String(chmodError);
+        log(`(notify repair failed: ${reason} — try: xattr -dr com.apple.quarantine "${path.dirname(binPath)}")`);
+        return false;
+    }
+}
+function macNotifierPath() {
+    if (process.platform !== 'darwin')
+        return null;
+    try {
+        const req = createRequire(import.meta.url);
+        const modPath = req.resolve('toasted-notifier');
+        const base = path.dirname(modPath);
+        return path.join(base, 'vendor', 'mac.noindex', 'terminal-notifier.app', 'Contents', 'MacOS', 'terminal-notifier');
+    }
+    catch {
+        return null;
+    }
+}
+function macAppIconOption() {
+    if (process.platform !== 'darwin')
+        return {};
+    const iconPaths = [
+        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../assets-oracle-icon.png'),
+        path.resolve(process.cwd(), 'assets-oracle-icon.png'),
+    ];
+    for (const candidate of iconPaths) {
+        if (candidate && fsExistsSync(candidate)) {
+            return { appIcon: candidate };
+        }
+    }
+    return {};
+}
+function fsExistsSync(target) {
+    try {
+        return Boolean(require('node:fs').statSync(target));
+    }
+    catch {
+        return false;
+    }
+}
+async function tryMacNativeNotifier(title, message, settings) {
+    const binary = macNativeNotifierPath();
+    if (!binary)
+        return false;
+    return new Promise((resolve) => {
+        const child = spawn(binary, [title, message, settings.sound ? 'Glass' : ''], {
+            stdio: 'ignore',
+        });
+        child.on('error', () => resolve(false));
+        child.on('exit', (code) => resolve(code === 0));
+    });
+}
+function macNativeNotifierPath() {
+    if (process.platform !== 'darwin')
+        return null;
+    const candidates = [
+        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../vendor/oracle-notifier/OracleNotifier.app/Contents/MacOS/OracleNotifier'),
+        path.resolve(process.cwd(), 'vendor/oracle-notifier/OracleNotifier.app/Contents/MacOS/OracleNotifier'),
+    ];
+    for (const candidate of candidates) {
+        if (fsExistsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function muteByConfig(env, config) {
+    if (!config?.muteIn)
+        return false;
+    return ((config.muteIn.includes('CI') && bool(env.CI)) ||
+        (config.muteIn.includes('SSH') && bool(env.SSH_CONNECTION)));
+}
+function isTestEnv(env) {
+    return (env.ORACLE_DISABLE_NOTIFICATIONS === '1' ||
+        env.NODE_ENV === 'test' ||
+        Boolean(env.VITEST || env.VITEST_WORKER_ID || env.JEST_WORKER_ID));
+}

package/dist/src/cli/options.js

@@ -75,11 +75,30 @@ export function parseSearchOption(value) {
 export function normalizeModelOption(value) {
     return (value ?? '').trim();
 }
+export function normalizeBaseUrl(value) {
+    const trimmed = value?.trim();
+    return trimmed?.length ? trimmed : undefined;
+}
+export function parseTimeoutOption(value) {
+    if (value == null)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'auto')
+        return 'auto';
+    const parsed = Number.parseFloat(normalized);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new InvalidArgumentError('Timeout must be a positive number of seconds or "auto".');
+    }
+    return parsed;
+}
 export function resolveApiModel(modelValue) {
     const normalized = normalizeModelOption(modelValue).toLowerCase();
     if (normalized in MODEL_CONFIGS) {
         return normalized;
     }
+    if (normalized.includes('gemini')) {
+        return 'gemini-3-pro';
+    }
     throw new InvalidArgumentError(`Unsupported model "${modelValue}". Choose one of: ${Object.keys(MODEL_CONFIGS).join(', ')}`);
 }
 export function inferModelFromLabel(modelValue) {
@@ -90,6 +109,9 @@ export function inferModelFromLabel(modelValue) {
     if (normalized in MODEL_CONFIGS) {
         return normalized;
     }
+    if (normalized.includes('gemini')) {
+        return 'gemini-3-pro';
+    }
     if (normalized.includes('pro')) {
         return 'gpt-5-pro';
     }

package/dist/src/cli/promptRequirement.js

@@ -2,6 +2,9 @@
  * Determine whether the CLI should enforce a prompt requirement based on raw args and options.
  */
 export function shouldRequirePrompt(rawArgs, options) {
+    if (rawArgs.length === 0) {
+        return !options.prompt;
+    }
     const firstArg = rawArgs[0];
     const bypassPrompt = Boolean(options.session ||
         options.execSession ||

package/dist/src/cli/runOptions.js

@@ -0,0 +1,43 @@
+import { resolveEngine } from './engine.js';
+import { normalizeModelOption, inferModelFromLabel, resolveApiModel, normalizeBaseUrl } from './options.js';
+import { resolveGeminiModelId } from '../oracle/gemini.js';
+export function resolveRunOptionsFromConfig({ prompt, files = [], model, engine, userConfig, env = process.env, }) {
+    const resolvedEngine = resolveEngineWithConfig({ engine, configEngine: userConfig?.engine, env });
+    const browserRequested = engine === 'browser';
+    const cliModelArg = normalizeModelOption(model ?? userConfig?.model) || 'gpt-5-pro';
+    const resolvedModel = resolvedEngine === 'browser' ? inferModelFromLabel(cliModelArg) : resolveApiModel(cliModelArg);
+    const isGemini = resolvedModel.startsWith('gemini');
+    // Keep the resolved model id alongside the canonical model name so we can log
+    // and dispatch the exact identifier (useful for Gemini preview aliases).
+    const effectiveModelId = isGemini ? resolveGeminiModelId(resolvedModel) : resolvedModel;
+    if (isGemini && browserRequested) {
+        throw new Error('Gemini is only supported via API. Use --engine api.');
+    }
+    // When Gemini is selected, always force API engine (overrides config/env auto browser).
+    const fixedEngine = isGemini ? 'api' : resolvedEngine;
+    const promptWithSuffix = userConfig?.promptSuffix && userConfig.promptSuffix.trim().length > 0
+        ? `${prompt.trim()}\n${userConfig.promptSuffix}`
+        : prompt;
+    const search = userConfig?.search !== 'off';
+    const heartbeatIntervalMs = userConfig?.heartbeatSeconds !== undefined ? userConfig.heartbeatSeconds * 1000 : 30_000;
+    const baseUrl = normalizeBaseUrl(userConfig?.apiBaseUrl ?? env.OPENAI_BASE_URL);
+    const runOptions = {
+        prompt: promptWithSuffix,
+        model: resolvedModel,
+        file: files ?? [],
+        search,
+        heartbeatIntervalMs,
+        filesReport: userConfig?.filesReport,
+        background: userConfig?.background,
+        baseUrl,
+        effectiveModelId,
+    };
+    return { runOptions, resolvedEngine: fixedEngine };
+}
+function resolveEngineWithConfig({ engine, configEngine, env, }) {
+    if (engine)
+        return engine;
+    if (configEngine)
+        return configEngine;
+    return resolveEngine({ engine: undefined, env });
+}

package/dist/src/cli/sessionCommand.js

@@ -77,7 +77,7 @@ export async function handleSessionCommand(sessionId, command, deps = defaultDep
         console.log(`Ignoring flags on session attach: ${ignoredFlags.join(', ')}`);
     }
     const renderMarkdown = Boolean(sessionOptions.render || sessionOptions.renderMarkdown || autoRender);
-    await deps.attachSession(sessionId, { renderMarkdown });
+    await deps.attachSession(sessionId, { renderMarkdown, renderPrompt: !sessionOptions.hidePrompt });
 }
 export function formatSessionCleanupMessage(result, scope) {
     const deletedLabel = `${result.deleted} ${result.deleted === 1 ? 'session' : 'sessions'}`;