@steipete/oracle 0.5.0 → 0.5.2

package/dist/src/browser/actions/assistantResponse.js

@@ -1,6 +1,7 @@
 import { ANSWER_SELECTORS, ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, COPY_BUTTON_SELECTOR, FINISHED_ACTIONS_SELECTOR, STOP_BUTTON_SELECTOR, } from '../constants.js';
 import { delay } from '../utils.js';
 import { logDomFailure, logConversationSnapshot, buildConversationDebugExpression } from '../domDebug.js';
+import { buildClickDispatcher } from './domEvents.js';
 const ASSISTANT_POLL_TIMEOUT_ERROR = 'assistant-response-watchdog-timeout';
 export async function waitForAssistantResponse(Runtime, timeoutMs, logger) {
     logger('Waiting for ChatGPT response');
@@ -257,6 +258,7 @@ function buildAssistantSnapshotExpression() {
 function buildResponseObserverExpression(timeoutMs) {
     const selectorsLiteral = JSON.stringify(ANSWER_SELECTORS);
     return `(() => {
+    ${buildClickDispatcher()}
     const SELECTORS = ${selectorsLiteral};
     const STOP_SELECTOR = '${STOP_BUTTON_SELECTOR}';
     const FINISHED_SELECTOR = '${FINISHED_ACTIONS_SELECTOR}';
@@ -293,7 +295,7 @@ function buildResponseObserverExpression(timeoutMs) {
           if (ariaLabel.toLowerCase().includes('stop')) {
             return;
           }
-          stop.click();
+          dispatchClickSequence(stop);
         }, 500);
         setTimeout(() => {
           if (stopInterval) {
@@ -340,6 +342,7 @@ function buildAssistantExtractor(functionName) {
     const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
     return `const ${functionName} = () => {
+    ${buildClickDispatcher()}
     const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const isAssistantTurn = (node) => {
@@ -367,7 +370,7 @@ function buildAssistantExtractor(functionName) {
           testid.includes('markdown') ||
           testid.includes('toggle')
         ) {
-          button.click();
+          dispatchClickSequence(button);
         }
       }
     };
@@ -397,6 +400,7 @@ function buildAssistantExtractor(functionName) {
 }
 function buildCopyExpression(meta) {
     return `(() => {
+    ${buildClickDispatcher()}
     const BUTTON_SELECTOR = '${COPY_BUTTON_SELECTOR}';
     const TIMEOUT_MS = 5000;
 
@@ -498,7 +502,7 @@ function buildCopyExpression(meta) {
 
       button.addEventListener('copy', handleCopy, true);
       button.scrollIntoView({ block: 'center', behavior: 'instant' });
-      button.click();
+      dispatchClickSequence(button);
       pollId = setInterval(() => {
         const payload = readIntercepted();
         if (payload.success) {

package/dist/src/browser/actions/attachments.js

@@ -28,6 +28,7 @@ export async function uploadAttachmentFile(deps, attachment, logger) {
         await logDomFailure(runtime, logger, 'file-upload');
         throw new Error('Attachment did not register with the ChatGPT composer in time.');
     }
+    await waitForAttachmentVisible(runtime, expectedName, 10_000, logger);
     logger('Attachment queued');
 }
 export async function waitForAttachmentCompletion(Runtime, timeoutMs, logger) {
@@ -83,6 +84,29 @@ export async function waitForAttachmentCompletion(Runtime, timeoutMs, logger) {
     await logDomFailure(Runtime, logger ?? (() => { }), 'file-upload-timeout');
     throw new Error('Attachments did not finish uploading before timeout.');
 }
+export async function waitForAttachmentVisible(Runtime, expectedName, timeoutMs, logger) {
+    const deadline = Date.now() + Math.min(timeoutMs, 2_000);
+    const expression = `(() => {
+    const expected = ${JSON.stringify(expectedName)};
+    const turns = Array.from(document.querySelectorAll('article[data-testid^="conversation-turn"]'));
+    const userTurns = turns.filter((node) => node.querySelector('[data-message-author-role="user"]'));
+    const lastUser = userTurns[userTurns.length - 1];
+    if (!lastUser) return { found: false, userTurns: userTurns.length };
+    const chips = Array.from(lastUser.querySelectorAll('a, div')).some((el) => (el.textContent || '').includes(expected));
+    return { found: chips, userTurns: userTurns.length };
+  })()`;
+    while (Date.now() < deadline) {
+        const { result } = await Runtime.evaluate({ expression, returnByValue: true });
+        const value = result?.value;
+        if (value?.found) {
+            return;
+        }
+        await delay(200);
+    }
+    logger?.('Attachment not visible in composer; giving up.');
+    await logDomFailure(Runtime, logger ?? (() => { }), 'attachment-visible');
+    throw new Error('Attachment did not appear in ChatGPT composer.');
+}
 async function waitForAttachmentSelection(Runtime, expectedName, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     const expression = `(() => {

package/dist/src/browser/actions/domEvents.js

@@ -0,0 +1,19 @@
+const CLICK_TYPES = ['pointerdown', 'mousedown', 'pointerup', 'mouseup', 'click'];
+export function buildClickDispatcher(functionName = 'dispatchClickSequence') {
+    const typesLiteral = JSON.stringify(CLICK_TYPES);
+    return `function ${functionName}(target){
+    if(!target || !(target instanceof EventTarget)) return false;
+    const types = ${typesLiteral};
+    for (const type of types) {
+      const common = { bubbles: true, cancelable: true, view: window };
+      let event;
+      if (type.startsWith('pointer') && 'PointerEvent' in window) {
+        event = new PointerEvent(type, { ...common, pointerId: 1, pointerType: 'mouse' });
+      } else {
+        event = new MouseEvent(type, common);
+      }
+      target.dispatchEvent(event);
+    }
+    return true;
+  }`;
+}

package/dist/src/browser/actions/modelSelection.js

@@ -1,5 +1,6 @@
 import { MENU_CONTAINER_SELECTOR, MENU_ITEM_SELECTOR, MODEL_BUTTON_SELECTOR, } from '../constants.js';
 import { logDomFailure } from '../domDebug.js';
+import { buildClickDispatcher } from './domEvents.js';
 export async function ensureModelSelection(Runtime, desiredModel, logger) {
     const outcome = await Runtime.evaluate({
         expression: buildModelSelectionExpression(desiredModel),
@@ -37,6 +38,7 @@ function buildModelSelectionExpression(targetModel) {
     const menuContainerLiteral = JSON.stringify(MENU_CONTAINER_SELECTOR);
     const menuItemLiteral = JSON.stringify(MENU_ITEM_SELECTOR);
     return `(() => {
+    ${buildClickDispatcher()}
     // Capture the selectors and matcher literals up front so the browser expression stays pure.
     const BUTTON_SELECTOR = '${MODEL_BUTTON_SELECTOR}';
     const LABEL_TOKENS = ${labelLiteral};
@@ -69,14 +71,9 @@ function buildModelSelectionExpression(targetModel) {
 
     let lastPointerClick = 0;
     const pointerClick = () => {
-      // Some menus ignore synthetic click events.
-      const down = new PointerEvent('pointerdown', { bubbles: true, pointerId: 1, pointerType: 'mouse' });
-      const up = new PointerEvent('pointerup', { bubbles: true, pointerId: 1, pointerType: 'mouse' });
-      const click = new MouseEvent('click', { bubbles: true });
-      button.dispatchEvent(down);
-      button.dispatchEvent(up);
-      button.dispatchEvent(click);
-      lastPointerClick = performance.now();
+      if (dispatchClickSequence(button)) {
+        lastPointerClick = performance.now();
+      }
     };
 
     const getOptionLabel = (node) => node?.textContent?.trim() ?? '';
@@ -188,7 +185,7 @@ function buildModelSelectionExpression(targetModel) {
             resolve({ status: 'already-selected', label: match.label });
             return;
           }
-          match.node.click();
+          dispatchClickSequence(match.node);
           resolve({ status: 'switched', label: match.label });
           return;
         }

package/dist/src/browser/actions/promptComposer.js

@@ -1,6 +1,7 @@
 import { INPUT_SELECTORS, PROMPT_PRIMARY_SELECTOR, PROMPT_FALLBACK_SELECTOR, SEND_BUTTON_SELECTORS, CONVERSATION_TURN_SELECTOR, } from '../constants.js';
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
+import { buildClickDispatcher } from './domEvents.js';
 const ENTER_KEY_EVENT = {
     key: 'Enter',
     code: 'Enter',
@@ -13,20 +14,13 @@ export async function submitPrompt(deps, prompt, logger) {
     const encodedPrompt = JSON.stringify(prompt);
     const focusResult = await runtime.evaluate({
         expression: `(() => {
+      ${buildClickDispatcher()}
       const SELECTORS = ${JSON.stringify(INPUT_SELECTORS)};
-      const dispatchPointer = (target) => {
-        if (!(target instanceof HTMLElement)) {
-          return;
-        }
-        for (const type of ['pointerdown', 'mousedown', 'pointerup', 'mouseup', 'click']) {
-          target.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window }));
-        }
-      };
       const focusNode = (node) => {
         if (!node) {
           return false;
         }
-        dispatchPointer(node);
+        dispatchClickSequence(node);
         if (typeof node.focus === 'function') {
           node.focus();
         }
@@ -59,6 +53,9 @@ export async function submitPrompt(deps, prompt, logger) {
         throw new Error('Failed to focus prompt textarea');
     }
     await input.insertText({ text: prompt });
+    // Some pages (notably ChatGPT when subscriptions/widgets load) need a brief settle
+    // before the send button becomes enabled; give it a short breather to avoid races.
+    await delay(500);
     const primarySelectorLiteral = JSON.stringify(PROMPT_PRIMARY_SELECTOR);
     const fallbackSelectorLiteral = JSON.stringify(PROMPT_FALLBACK_SELECTOR);
     const verification = await runtime.evaluate({
@@ -86,6 +83,8 @@ export async function submitPrompt(deps, prompt, logger) {
         const editor = document.querySelector(${primarySelectorLiteral});
         if (editor) {
           editor.textContent = ${encodedPrompt};
+          // Nudge ProseMirror to register the textContent write so its state/send-button updates
+          editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${encodedPrompt}, inputType: 'insertFromPaste' }));
         }
       })()`,
         });
@@ -108,9 +107,11 @@ export async function submitPrompt(deps, prompt, logger) {
         logger('Clicked send button');
     }
     await verifyPromptCommitted(runtime, prompt, 30_000, logger);
+    await clickAnswerNowIfPresent(runtime, logger);
 }
 async function attemptSendButton(Runtime) {
     const script = `(() => {
+    ${buildClickDispatcher()}
     const selectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
     let button = null;
     for (const selector of selectors) {
@@ -128,7 +129,8 @@ async function attemptSendButton(Runtime) {
       style.pointerEvents === 'none' ||
       style.display === 'none';
     if (disabled) return 'disabled';
-    (button as HTMLElement).click();
+    // Use unified pointer/mouse sequence to satisfy React handlers.
+    dispatchClickSequence(button);
     return 'clicked';
   })()`;
     const deadline = Date.now() + 2_000;
@@ -144,6 +146,37 @@ async function attemptSendButton(Runtime) {
     }
     return false;
 }
+async function clickAnswerNowIfPresent(Runtime, logger) {
+    const script = `(() => {
+    ${buildClickDispatcher()}
+    const matchesText = (el) => (el?.textContent || '').trim().toLowerCase() === 'answer now';
+    const candidate = Array.from(document.querySelectorAll('button,span')).find(matchesText);
+    if (!candidate) return 'missing';
+    const button = candidate.closest('button') ?? candidate;
+    const style = window.getComputedStyle(button);
+    const disabled =
+      button.hasAttribute('disabled') ||
+      button.getAttribute('aria-disabled') === 'true' ||
+      style.pointerEvents === 'none' ||
+      style.display === 'none';
+    if (disabled) return 'disabled';
+    dispatchClickSequence(button);
+    return 'clicked';
+  })()`;
+    const deadline = Date.now() + 3_000;
+    while (Date.now() < deadline) {
+        const { result } = await Runtime.evaluate({ expression: script, returnByValue: true });
+        const status = result.value;
+        if (status === 'clicked') {
+            logger?.('Clicked "Answer now" gate');
+            await delay(500);
+            return;
+        }
+        if (status === 'missing')
+            return;
+        await delay(100);
+    }
+}
 async function verifyPromptCommitted(Runtime, prompt, timeoutMs, logger) {
     const deadline = Date.now() + timeoutMs;
     const encodedPrompt = JSON.stringify(prompt.trim());

package/dist/src/browser/actions/remoteFileTransfer.js

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { FILE_INPUT_SELECTORS } from '../constants.js';
+import { waitForAttachmentVisible } from './attachments.js';
 import { delay } from '../utils.js';
 import { logDomFailure } from '../domDebug.js';
 /**
@@ -132,6 +133,7 @@ export async function uploadAttachmentViaDataTransfer(deps, attachment, logger)
     logger(`File transferred: ${uploadResult.fileName} (${uploadResult.size} bytes)`);
     // Give ChatGPT a moment to process the file
     await delay(500);
+    await waitForAttachmentVisible(runtime, fileName, 10_000, logger);
     logger('Attachment queued');
 }
 function guessMimeType(fileName) {

package/dist/src/browser/chromeCookies.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import os from 'node:os';
 import fs from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import chromeCookies from 'chrome-cookies-secure';
 import { COOKIE_URLS } from './constants.js';
 import { ensureCookiesDirForFallback } from './windowsCookies.js';
@@ -57,13 +58,19 @@ async function ensureMacKeychainReadable() {
     // chrome-cookies-secure can hang forever when the platform keyring rejects access (e.g., SSH/no GUI).
     // Probe the keyring ourselves with a timeout so callers fail fast instead of blocking the run.
     let keytar = null;
+    let keytarPath = null;
     try {
+        const require = createRequire(import.meta.url);
+        keytarPath = require.resolve('keytar');
         const keytarModule = await import('keytar');
         keytar = (keytarModule.default ?? keytarModule);
     }
     catch (error) {
         const base = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to load keytar for secure cookie copy (${base}). Install keyring deps (macOS Keychain / libsecret) or rerun with --render --copy to paste into ChatGPT manually.`);
+        const rebuildHint = keytarPath
+            ? ` You may need to rebuild keytar: PYTHON=/usr/bin/python3 /Users/steipete/Projects/oracle/runner npx node-gyp rebuild (run inside ${path.dirname(keytarPath)}).`
+            : '';
+        throw new Error(`Failed to load keytar for secure cookie copy (${base}). Install keyring deps (macOS Keychain / libsecret) or rerun with --render --copy to paste into ChatGPT manually.${rebuildHint}`);
     }
     const password = await settleWithTimeout(findKeychainPassword(keytar, MAC_KEYCHAIN_LABELS), KEYCHAIN_PROBE_TIMEOUT_MS, `Timed out reading macOS Keychain while looking up Chrome Safe Storage (after ${KEYCHAIN_PROBE_TIMEOUT_MS} ms). Unlock the login keychain or start oracle serve from a GUI session.`);
     if (!password) {

package/dist/src/browser/index.js

@@ -1,6 +1,7 @@
 import { mkdtemp, rm, mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
+import net from 'node:net';
 import { resolveBrowserConfig } from './config.js';
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToChrome, connectToRemoteChrome, closeRemoteChromeTarget, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
@@ -18,7 +19,7 @@ export async function runBrowserMode(options) {
         throw new Error('Prompt text is required when using browser mode.');
     }
     const attachments = options.attachments ?? [];
-    const config = resolveBrowserConfig(options.config);
+    let config = resolveBrowserConfig(options.config);
     const logger = options.log ?? ((_message) => { });
     if (logger.verbose === undefined) {
         logger.verbose = Boolean(config.debug);
@@ -56,6 +57,14 @@ export async function runBrowserMode(options) {
             promptLength: promptText.length,
         })}`);
     }
+    if (!config.remoteChrome && !config.manualLogin) {
+        const preferredPort = config.debugPort ?? DEFAULT_DEBUG_PORT;
+        const availablePort = await pickAvailableDebugPort(preferredPort, logger);
+        if (availablePort !== preferredPort) {
+            logger(`DevTools port ${preferredPort} busy; using ${availablePort} to avoid attaching to stray Chrome.`);
+        }
+        config = { ...config, debugPort: availablePort };
+    }
     // Remote Chrome mode - connect to existing browser
     if (config.remoteChrome) {
         // Warn about ignored local-only options
@@ -165,6 +174,17 @@ export async function runBrowserMode(options) {
                 ? 'Skipping Chrome cookie sync (--browser-manual-login enabled); reuse the opened profile after signing in.'
                 : 'Skipping Chrome cookie sync (--browser-no-cookie-sync)');
         }
+        if (cookieSyncEnabled && !manualLogin && (appliedCookies ?? 0) === 0 && !config.inlineCookies) {
+            throw new BrowserAutomationError('No ChatGPT cookies were applied from your Chrome profile; cannot proceed in browser mode. ' +
+                'Make sure ChatGPT is signed in in the selected profile or rebuild the keytar native module if it failed to load.', {
+                stage: 'execute-browser',
+                details: {
+                    profile: config.chromeProfile ?? 'Default',
+                    cookiePath: config.chromeCookiePath ?? null,
+                    hint: 'Rebuild keytar: PYTHON=/usr/bin/python3 /Users/steipete/Projects/oracle/runner npx node-gyp rebuild (run inside the keytar path from the error), then retry.',
+                },
+            });
+        }
         const baseUrl = CHATGPT_URL;
         // First load the base ChatGPT homepage to satisfy potential interstitials,
         // then hop to the requested URL if it differs.
@@ -383,6 +403,48 @@ export async function runBrowserMode(options) {
         }
     }
 }
+const DEFAULT_DEBUG_PORT = 9222;
+async function pickAvailableDebugPort(preferredPort, logger) {
+    const start = Number.isFinite(preferredPort) && preferredPort > 0 ? preferredPort : DEFAULT_DEBUG_PORT;
+    for (let offset = 0; offset < 10; offset++) {
+        const candidate = start + offset;
+        if (await isPortAvailable(candidate)) {
+            return candidate;
+        }
+    }
+    const fallback = await findEphemeralPort();
+    logger(`DevTools ports ${start}-${start + 9} are occupied; falling back to ${fallback}.`);
+    return fallback;
+}
+async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', () => resolve(false));
+        server.once('listening', () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+async function findEphemeralPort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once('error', (error) => {
+            server.close();
+            reject(error);
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (address && typeof address === 'object') {
+                const port = address.port;
+                server.close(() => resolve(port));
+            }
+            else {
+                server.close(() => reject(new Error('Failed to acquire ephemeral port')));
+            }
+        });
+    });
+}
 async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, }) {
     if (!manualLogin) {
         await ensureLoggedIn(runtime, logger, { appliedCookies });
@@ -412,6 +474,26 @@ async function waitForLogin({ runtime, logger, appliedCookies, manualLogin, time
     }
     throw new Error('Manual login mode timed out waiting for ChatGPT session; please sign in and retry.');
 }
+async function _assertNavigatedToHttp(runtime, _logger, timeoutMs = 10_000) {
+    const deadline = Date.now() + timeoutMs;
+    let lastUrl = '';
+    while (Date.now() < deadline) {
+        const { result } = await runtime.evaluate({
+            expression: 'typeof location === "object" && location.href ? location.href : ""',
+            returnByValue: true,
+        });
+        const url = typeof result?.value === 'string' ? result.value : '';
+        lastUrl = url;
+        if (/^https?:\/\//i.test(url)) {
+            return url;
+        }
+        await delay(250);
+    }
+    throw new BrowserAutomationError('ChatGPT session not detected; page never left new tab.', {
+        stage: 'execute-browser',
+        details: { url: lastUrl || '(empty)' },
+    });
+}
 async function maybeReuseRunningChrome(userDataDir, logger) {
     const port = await readDevToolsPort(userDataDir);
     if (!port)

package/dist/src/browser/profileSync.js

@@ -0,0 +1,141 @@
+import { mkdir, rm, cp as copyDir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { defaultProfileRoot, expandPath, looksLikePath } from './chromeCookies.js';
+const DIR_EXCLUDES = [
+    'Cache',
+    'Code Cache',
+    'GPUCache',
+    'Service Worker',
+    'Crashpad',
+    'BrowserMetrics*',
+    'GrShaderCache',
+    'ShaderCache',
+    'OptimizationGuide',
+];
+const FILE_EXCLUDES = [
+    'SingletonLock',
+    'SingletonSocket',
+    'SingletonCookie',
+    '*.lock',
+    'lockfile',
+    'Lock',
+    '*.tmp',
+    'DevToolsActivePort',
+    path.join('Default', 'DevToolsActivePort'),
+    path.join('Sessions', '*'),
+    'Current Session',
+    'Current Tabs',
+    'Last Session',
+    'Last Tabs',
+];
+export async function syncChromeProfile(options) {
+    const { targetDir } = options;
+    await mkdir(targetDir, { recursive: true });
+    const { sourceDir, profileName } = await resolveProfileSource(options.profile, options.explicitPath);
+    const logger = options.logger;
+    if (!existsSync(sourceDir)) {
+        throw new Error(`Chrome profile not found at ${sourceDir}. Log in once in Chrome, then retry.`);
+    }
+    // Clean any stale DevTools ports/locks in the target before copying.
+    await rm(targetDir, { recursive: true, force: true }).catch(() => undefined);
+    await mkdir(targetDir, { recursive: true });
+    const result = process.platform === 'win32'
+        ? await copyWithRobocopy(sourceDir, targetDir, logger)
+        : await copyWithRsync(sourceDir, targetDir, logger);
+    // Remove lock files in the copied profile to avoid "already running" errors.
+    await removeLocks(targetDir);
+    return {
+        source: sourceDir,
+        profileName,
+        method: result.method,
+        status: result.copied ? 'copied' : 'skipped',
+    };
+}
+async function copyWithRsync(sourceDir, targetDir, logger) {
+    const rsyncArgs = [
+        '-a',
+        '--delete',
+        ...DIR_EXCLUDES.flatMap((entry) => ['--exclude', entry]),
+        ...FILE_EXCLUDES.flatMap((entry) => ['--exclude', entry]),
+        `${sourceDir}/`,
+        `${targetDir}/`,
+    ];
+    const attempt = spawnSync('rsync', rsyncArgs, { stdio: 'pipe' });
+    if (!attempt.error && (attempt.status ?? 0) === 0) {
+        return { copied: true, method: 'rsync' };
+    }
+    logger?.('rsync unavailable or failed; falling back to Node copy');
+    await copyDirWithFilter(sourceDir, targetDir);
+    return copyWithNodeFs();
+}
+async function copyWithRobocopy(sourceDir, targetDir, logger) {
+    const args = [sourceDir, targetDir, '/MIR', '/NFL', '/NDL', '/NJH', '/NJS', '/NP', '/Z'];
+    if (DIR_EXCLUDES.length) {
+        args.push('/XD', ...DIR_EXCLUDES);
+    }
+    if (FILE_EXCLUDES.length) {
+        args.push('/XF', ...FILE_EXCLUDES);
+    }
+    const attempt = spawnSync('robocopy', args, { stdio: 'pipe' });
+    const exitCode = attempt.status ?? 0;
+    // Robocopy treats 0-7 as success/partial success; >=8 is failure.
+    if (!attempt.error && exitCode < 8) {
+        return { copied: true, method: 'robocopy' };
+    }
+    logger?.('robocopy failed; falling back to Node copy');
+    await copyDirWithFilter(sourceDir, targetDir);
+    return copyWithNodeFs();
+}
+function copyWithNodeFs() {
+    return { copied: true, method: 'node' };
+}
+function shouldExclude(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    return DIR_EXCLUDES.some((entry) => normalized === entry || normalized.startsWith(`${entry}/`)) ||
+        FILE_EXCLUDES.some((entry) => {
+            if (entry.endsWith('*')) {
+                return normalized.startsWith(entry.slice(0, -1));
+            }
+            if (entry.includes('*')) {
+                // simple glob support for BrowserMetrics*
+                const prefix = entry.replace('*', '');
+                return normalized.startsWith(prefix);
+            }
+            return path.basename(normalized) === entry || normalized.endsWith(`/${entry}`);
+        });
+}
+async function removeLocks(targetDir) {
+    const lockNames = ['SingletonLock', 'SingletonSocket', 'SingletonCookie', 'DevToolsActivePort'];
+    for (const lock of lockNames) {
+        await rm(path.join(targetDir, lock), { force: true }).catch(() => undefined);
+        await rm(path.join(targetDir, 'Default', lock), { force: true }).catch(() => undefined);
+    }
+}
+async function resolveProfileSource(profile, explicitPath) {
+    const profileName = profile?.trim() ? profile.trim() : 'Default';
+    if (explicitPath?.trim()) {
+        const resolved = expandPath(explicitPath.trim());
+        if (resolved.toLowerCase().endsWith('cookies')) {
+            return { sourceDir: path.dirname(resolved), profileName };
+        }
+        return { sourceDir: resolved, profileName };
+    }
+    if (looksLikePath(profileName)) {
+        return { sourceDir: expandPath(profileName), profileName };
+    }
+    const baseRoot = await defaultProfileRoot();
+    return { sourceDir: path.join(baseRoot, profileName), profileName };
+}
+async function copyDirWithFilter(sourceDir, targetDir) {
+    await copyDir(sourceDir, targetDir, {
+        recursive: true,
+        filter: async (source) => {
+            const rel = path.relative(sourceDir, source);
+            if (!rel)
+                return true;
+            return !shouldExclude(rel);
+        },
+    });
+}

package/dist/src/cli/browserDefaults.js

@@ -3,39 +3,43 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     const browser = config.browser;
     if (!browser)
         return;
+    const isUnset = (key) => {
+        const source = getSource(key);
+        return source === undefined || source === 'default';
+    };
     const configuredChatgptUrl = browser.chatgptUrl ?? browser.url;
     const cliChatgptSet = options.chatgptUrl !== undefined || options.browserUrl !== undefined;
-    if ((getSource('chatgptUrl') === 'default' || getSource('chatgptUrl') === undefined) && !cliChatgptSet && configuredChatgptUrl !== undefined) {
+    if (isUnset('chatgptUrl') && !cliChatgptSet && configuredChatgptUrl !== undefined) {
         options.chatgptUrl = normalizeChatgptUrl(configuredChatgptUrl ?? '', CHATGPT_URL);
     }
-    if (getSource('browserChromeProfile') === 'default' && browser.chromeProfile !== undefined) {
+    if (isUnset('browserChromeProfile') && browser.chromeProfile !== undefined) {
         options.browserChromeProfile = browser.chromeProfile ?? undefined;
     }
-    if (getSource('browserChromePath') === 'default' && browser.chromePath !== undefined) {
+    if (isUnset('browserChromePath') && browser.chromePath !== undefined) {
         options.browserChromePath = browser.chromePath ?? undefined;
     }
-    if (getSource('browserCookiePath') === 'default' && browser.chromeCookiePath !== undefined) {
+    if (isUnset('browserCookiePath') && browser.chromeCookiePath !== undefined) {
         options.browserCookiePath = browser.chromeCookiePath ?? undefined;
     }
-    if ((getSource('browserUrl') === 'default' || getSource('browserUrl') === undefined) && options.browserUrl === undefined && browser.url !== undefined) {
+    if (isUnset('browserUrl') && options.browserUrl === undefined && browser.url !== undefined) {
         options.browserUrl = browser.url;
     }
-    if (getSource('browserTimeout') === 'default' && typeof browser.timeoutMs === 'number') {
+    if (isUnset('browserTimeout') && typeof browser.timeoutMs === 'number') {
         options.browserTimeout = String(browser.timeoutMs);
     }
-    if (getSource('browserPort') === 'default' && typeof browser.debugPort === 'number') {
+    if (isUnset('browserPort') && typeof browser.debugPort === 'number') {
         options.browserPort = browser.debugPort;
     }
-    if (getSource('browserInputTimeout') === 'default' && typeof browser.inputTimeoutMs === 'number') {
+    if (isUnset('browserInputTimeout') && typeof browser.inputTimeoutMs === 'number') {
         options.browserInputTimeout = String(browser.inputTimeoutMs);
     }
-    if (getSource('browserHeadless') === 'default' && browser.headless !== undefined) {
+    if (isUnset('browserHeadless') && browser.headless !== undefined) {
         options.browserHeadless = browser.headless;
     }
-    if (getSource('browserHideWindow') === 'default' && browser.hideWindow !== undefined) {
+    if (isUnset('browserHideWindow') && browser.hideWindow !== undefined) {
         options.browserHideWindow = browser.hideWindow;
     }
-    if (getSource('browserKeepBrowser') === 'default' && browser.keepBrowser !== undefined) {
+    if (isUnset('browserKeepBrowser') && browser.keepBrowser !== undefined) {
         options.browserKeepBrowser = browser.keepBrowser;
     }
 }

package/dist/src/cli/sessionDisplay.js

@@ -2,15 +2,14 @@ import chalk from 'chalk';
 import kleur from 'kleur';
 import { renderMarkdownAnsi } from './markdownRenderer.js';
 import { formatElapsed, formatUSD } from '../oracle/format.js';
-import { MODEL_CONFIGS } from '../oracle.js';
 import { sessionStore, wait } from '../sessionStore.js';
 import { formatTokenCount, formatTokenValue } from '../oracle/runUtils.js';
 import { resumeBrowserSession } from '../browser/reattach.js';
 import { estimateTokenCount } from '../browser/utils.js';
+import { formatSessionTableHeader, formatSessionTableRow, resolveSessionCost } from './sessionTable.js';
 const isTty = () => Boolean(process.stdout.isTTY);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 export const MAX_RENDER_BYTES = 200_000;
-const MODEL_COLUMN_WIDTH = 18;
 function isProcessAlive(pid) {
     if (!pid)
         return false;
@@ -36,17 +35,9 @@ export async function showStatus({ hours, includeAll, limit, showExamples = fals
         return;
     }
     console.log(chalk.bold('Recent Sessions'));
-    console.log(chalk.dim('Timestamp             Chars  Cost  Status     Models              ID'));
+    console.log(formatSessionTableHeader(richTty));
     for (const entry of filteredEntries) {
-        const statusRaw = (entry.status || 'unknown').padEnd(9);
-        const status = richTty ? colorStatus(entry.status ?? 'unknown', statusRaw) : statusRaw;
-        const modelColumn = formatModelColumn(entry, MODEL_COLUMN_WIDTH, richTty);
-        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} | ${modelColumn} | ${entry.id}`);
+        console.log(formatSessionTableRow(entry, { rich: richTty }));
     }
     if (truncated) {
         const sessionsDir = sessionStore.sessionsDir();
@@ -56,18 +47,6 @@ export async function showStatus({ hours, includeAll, limit, showExamples = fals
         printStatusExamples();
     }
 }
-function colorStatus(status, padded) {
-    switch (status) {
-        case 'completed':
-            return chalk.green(padded);
-        case 'error':
-            return chalk.red(padded);
-        case 'running':
-            return chalk.yellow(padded);
-        default:
-            return padded;
-    }
-}
 export async function attachSession(sessionId, options) {
     let metadata = await sessionStore.readSession(sessionId);
     if (!metadata) {
@@ -450,43 +429,6 @@ function matchesModel(entry, filter) {
     const models = entry.models?.map((model) => model.model.toLowerCase()) ?? (entry.model ? [entry.model.toLowerCase()] : []);
     return models.includes(normalized);
 }
-function formatModelColumn(entry, width, richTty) {
-    const models = entry.models && entry.models.length > 0
-        ? entry.models
-        : entry.model
-            ? [{ model: entry.model, status: entry.status }]
-            : [];
-    if (models.length === 0) {
-        return 'n/a'.padEnd(width);
-    }
-    const badges = models.map((model) => formatModelBadge(model, richTty));
-    const text = badges.join(' ');
-    if (text.length > width) {
-        return `${text.slice(0, width - 1)}…`;
-    }
-    return text.padEnd(width);
-}
-function formatModelBadge(model, richTty) {
-    const glyph = statusGlyph(model.status);
-    const text = `${model.model}${glyph}`;
-    return richTty ? chalk.cyan(text) : text;
-}
-function statusGlyph(status) {
-    switch (status) {
-        case 'completed':
-            return '✓';
-        case 'running':
-            return '⌛';
-        case 'pending':
-            return '…';
-        case 'error':
-            return '✖';
-        case 'cancelled':
-            return '⦻';
-        default:
-            return '?';
-    }
-}
 async function buildSessionLogForDisplay(sessionId, fallbackMeta, modelFilter) {
     const normalizedFilter = modelFilter?.trim().toLowerCase();
     const freshMetadata = (await sessionStore.readSession(sessionId)) ?? fallbackMeta;
@@ -557,28 +499,13 @@ 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 cost = resolveSessionCost(metadata);
     const costPart = cost != null ? ` | ${formatUSD(cost)}` : '';
     const tokensDisplay = [
         usage.inputTokens ?? 0,
@@ -598,28 +525,6 @@ export function formatCompletionSummary(metadata, options = {}) {
     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 sessionStore.readRequest(sessionId);
     if (request?.prompt && request.prompt.trim().length > 0) {

package/dist/src/cli/sessionTable.js

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import kleur from 'kleur';
+import { MODEL_CONFIGS } from '../oracle.js';
+const isRich = (rich) => rich ?? Boolean(process.stdout.isTTY && chalk.level > 0);
+const dim = (text, rich) => (rich ? kleur.dim(text) : text);
+export const STATUS_PAD = 9;
+export const MODEL_PAD = 13;
+export const MODE_PAD = 7;
+export const TIMESTAMP_PAD = 19;
+export const CHARS_PAD = 5;
+export const COST_PAD = 7;
+export function formatSessionTableHeader(rich) {
+    const header = `${'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`;
+    return dim(header, isRich(rich));
+}
+export function formatSessionTableRow(meta, options) {
+    const rich = isRich(options?.rich);
+    const status = colorStatus(meta.status ?? 'unknown', rich);
+    const modelLabel = (meta.model ?? 'n/a').padEnd(MODEL_PAD);
+    const model = rich ? chalk.white(modelLabel) : modelLabel;
+    const modeLabel = (meta.mode ?? meta.options?.mode ?? 'api').padEnd(MODE_PAD);
+    const mode = rich ? chalk.gray(modeLabel) : modeLabel;
+    const timestampLabel = formatTimestampAligned(meta.createdAt).padEnd(TIMESTAMP_PAD);
+    const timestamp = rich ? chalk.gray(timestampLabel) : timestampLabel;
+    const charsValue = meta.options?.prompt?.length ?? meta.promptPreview?.length ?? 0;
+    const charsRaw = charsValue > 0 ? String(charsValue).padStart(CHARS_PAD) : `${''.padStart(CHARS_PAD - 1)}-`;
+    const chars = rich ? chalk.gray(charsRaw) : charsRaw;
+    const costValue = resolveSessionCost(meta);
+    const costRaw = costValue != null ? formatCostTable(costValue) : `${''.padStart(COST_PAD - 1)}-`;
+    const cost = rich ? chalk.gray(costRaw) : costRaw;
+    const slug = rich ? chalk.cyan(meta.id) : meta.id;
+    return `${status} ${model} ${mode} ${timestamp} ${chars} ${cost}  ${slug}`;
+}
+export function resolveSessionCost(meta) {
+    const mode = meta.mode ?? meta.options?.mode;
+    if (mode === 'browser') {
+        return null;
+    }
+    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;
+}
+export 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);
+    formatted = formatted.replace(', ', '  ');
+    return formatted.replace(/(\s)(\d:)/, '$1 $2');
+}
+function formatCostTable(cost) {
+    return `$${cost.toFixed(3)}`.padStart(COST_PAD);
+}
+function colorStatus(status, rich) {
+    const padded = status.padEnd(STATUS_PAD);
+    if (!rich) {
+        return padded;
+    }
+    switch (status) {
+        case 'completed':
+            return chalk.green(padded);
+        case 'error':
+            return chalk.red(padded);
+        case 'running':
+            return chalk.yellow(padded);
+        default:
+            return padded;
+    }
+}

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

@@ -9,6 +9,7 @@ import { renderMarkdownAnsi } from '../markdownRenderer.js';
 import { sessionStore, pruneOldSessions } from '../../sessionStore.js';
 import { performSessionRun } from '../sessionRunner.js';
 import { MAX_RENDER_BYTES, trimBeforeFirstAnswer } from '../sessionDisplay.js';
+import { formatSessionTableHeader, formatSessionTableRow } from '../sessionTable.js';
 import { buildBrowserConfig, resolveBrowserModelLabel } from '../browserConfig.js';
 import { resolveNotificationSettings } from '../notifier.js';
 import { loadUserConfig } from '../../config.js';
@@ -17,12 +18,6 @@ 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, printIntro = true }) {
     const userConfig = (await loadUserConfig()).config;
     const rich = isTty();
@@ -39,7 +34,7 @@ export async function launchTui({ version, printIntro = true }) {
     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`);
+        const headerLabel = formatSessionTableHeader(isTty());
         // Start with a selectable row so focus never lands on a separator
         choices.push({ name: chalk.bold.green('ask oracle'), value: '__ask__' });
         if (!showingOlder) {
@@ -71,7 +66,7 @@ export async function launchTui({ version, printIntro = true }) {
             const prompt = inquirer.prompt([
                 {
                     name: 'selection',
-                    type: 'list',
+                    type: 'select',
                     message: 'Select a session or action',
                     choices,
                     pageSize: 16,
@@ -85,6 +80,9 @@ export async function launchTui({ version, printIntro = true }) {
                 resolve('__reset__');
             });
         });
+        if (process.env.ORACLE_DEBUG_TUI === '1') {
+            console.error(`[tui] selection=${JSON.stringify(selection)}`);
+        }
         if (selection === '__exit__') {
             console.log(chalk.green('🧿 Closing the book. See you next prompt.'));
             return;
@@ -119,72 +117,10 @@ async function fetchSessionBuckets() {
 }
 function toSessionChoice(meta) {
     return {
-        name: formatSessionLabel(meta),
+        name: formatSessionTableRow(meta, { rich: isTty() }),
         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);
@@ -223,7 +159,7 @@ async function showSessionDetail(sessionId) {
         const { next } = await inquirer.prompt([
             {
                 name: 'next',
-                type: 'list',
+                type: 'select',
                 message: 'Actions',
                 choices: actions,
             },
@@ -302,7 +238,7 @@ async function askOracleFlow(version, userConfig) {
     const hasApiKey = Boolean(process.env.OPENAI_API_KEY);
     const initialMode = hasApiKey ? 'api' : 'browser';
     const preferredMode = userConfig.engine ?? initialMode;
-    const answers = await inquirer.prompt([
+    const wizardQuestions = [
         {
             name: 'promptInput',
             type: 'input',
@@ -312,7 +248,7 @@ async function askOracleFlow(version, userConfig) {
             ? [
                 {
                     name: 'mode',
-                    type: 'list',
+                    type: 'select',
                     message: 'Engine',
                     default: preferredMode,
                     choices: [
@@ -324,7 +260,7 @@ async function askOracleFlow(version, userConfig) {
             : [
                 {
                     name: 'mode',
-                    type: 'list',
+                    type: 'select',
                     message: 'Engine',
                     default: preferredMode,
                     choices: [{ name: 'Browser', value: 'browser' }],
@@ -337,7 +273,7 @@ async function askOracleFlow(version, userConfig) {
         },
         {
             name: 'model',
-            type: 'list',
+            type: 'select',
             message: 'Model',
             default: DEFAULT_MODEL,
             choices: modelChoices,
@@ -390,7 +326,8 @@ async function askOracleFlow(version, userConfig) {
             default: false,
             when: (ans) => ans.mode === 'browser',
         },
-    ]);
+    ];
+    const answers = await inquirer.prompt(wizardQuestions);
     const mode = (answers.mode ?? initialMode);
     const prompt = await resolvePromptInput(answers.promptInput);
     if (!prompt.trim()) {
@@ -514,4 +451,4 @@ async function readStoredPrompt(sessionId) {
 }
 // Exported for testing
 export { askOracleFlow, showSessionDetail };
-export { resolveCost };
+export { resolveSessionCost as resolveCost } from '../sessionTable.js';

package/dist/src/oracle/client.js

@@ -17,9 +17,8 @@ export function createDefaultClientFactory() {
             return createClaudeClient(key, options.model, options.resolvedModelId, options.baseUrl);
         }
         let instance;
-        const defaultHeaders = isOpenRouterBaseUrl(options?.baseUrl)
-            ? buildOpenRouterHeaders()
-            : undefined;
+        const openRouter = isOpenRouterBaseUrl(options?.baseUrl);
+        const defaultHeaders = openRouter ? buildOpenRouterHeaders() : undefined;
         if (options?.azure?.endpoint) {
             instance = new AzureOpenAI({
                 apiKey: key,
@@ -37,6 +36,9 @@ export function createDefaultClientFactory() {
                 defaultHeaders,
             });
         }
+        if (openRouter) {
+            return buildOpenRouterCompletionClient(instance);
+        }
         return {
             responses: {
                 stream: (body) => instance.responses.stream(body),
@@ -102,3 +104,91 @@ function loadCustomClientFactory() {
 }
 // Exposed for tests
 export { loadCustomClientFactory as __loadCustomClientFactory };
+function buildOpenRouterCompletionClient(instance) {
+    const adaptRequest = (body) => {
+        const messages = [];
+        if (body.instructions) {
+            messages.push({ role: 'system', content: body.instructions });
+        }
+        for (const entry of body.input) {
+            const textParts = entry.content
+                .map((c) => (c.type === 'input_text' ? c.text : ''))
+                .filter((t) => t)
+                .join('\n\n');
+            messages.push({ role: entry.role ?? 'user', content: textParts });
+        }
+        const base = {
+            model: body.model,
+            messages,
+            max_tokens: body.max_output_tokens,
+        };
+        const streaming = { ...base, stream: true };
+        const nonStreaming = { ...base, stream: false };
+        return { streaming, nonStreaming };
+    };
+    const adaptResponse = (response) => {
+        const text = response.choices?.[0]?.message?.content ?? '';
+        const usage = {
+            input_tokens: response.usage?.prompt_tokens ?? 0,
+            output_tokens: response.usage?.completion_tokens ?? 0,
+            total_tokens: response.usage?.total_tokens ?? 0,
+        };
+        return {
+            id: response.id ?? `openrouter-${Date.now()}`,
+            status: 'completed',
+            output_text: [text],
+            output: [{ type: 'text', text }],
+            usage,
+        };
+    };
+    const stream = async (body) => {
+        const { streaming } = adaptRequest(body);
+        let finalUsage;
+        let finalId;
+        let aggregated = '';
+        async function* iterator() {
+            const completion = await instance.chat.completions.create(streaming);
+            for await (const chunk of completion) {
+                finalId = chunk.id ?? finalId;
+                const delta = chunk.choices?.[0]?.delta?.content ?? '';
+                if (delta) {
+                    aggregated += delta;
+                    yield { type: 'chunk', delta };
+                }
+                if (chunk.usage) {
+                    finalUsage = chunk.usage;
+                }
+            }
+        }
+        const gen = iterator();
+        return {
+            [Symbol.asyncIterator]() {
+                return gen;
+            },
+            async finalResponse() {
+                return adaptResponse({
+                    id: finalId ?? `openrouter-${Date.now()}`,
+                    choices: [{ message: { role: 'assistant', content: aggregated } }],
+                    usage: finalUsage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+                    created: Math.floor(Date.now() / 1000),
+                    model: '',
+                    object: 'chat.completion',
+                });
+            },
+        };
+    };
+    const create = async (body) => {
+        const { nonStreaming } = adaptRequest(body);
+        const response = (await instance.chat.completions.create(nonStreaming));
+        return adaptResponse(response);
+    };
+    return {
+        responses: {
+            stream,
+            create,
+            retrieve: async () => {
+                throw new Error('retrieve is not supported for OpenRouter chat/completions fallback.');
+            },
+        },
+    };
+}

package/dist/src/oracle/run.js

@@ -133,9 +133,10 @@ export async function runOracle(options, deps = {}) {
     if (isProTierModel && !Number.isNaN(minPromptLength) && promptLength < minPromptLength) {
         throw new PromptValidationError(`Prompt is too short (<${minPromptLength} chars). This was likely accidental; please provide more detail.`, { minPromptLength, promptLength });
     }
+    const resolverOpenRouterApiKey = openRouterFallback || isOpenRouterBaseUrl(baseUrl) ? openRouterApiKey ?? apiKey : undefined;
     const modelConfig = await resolveModelConfig(options.model, {
         baseUrl,
-        openRouterApiKey: openRouterApiKey ?? (isOpenRouterBaseUrl(baseUrl) ? apiKey : undefined),
+        openRouterApiKey: resolverOpenRouterApiKey,
     });
     const isLongRunningModel = isProTierModel;
     const supportsBackground = modelConfig.supportsBackground !== false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.1 Pro, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "type": "module",
   "main": "dist/bin/oracle-cli.js",
@@ -45,9 +45,9 @@
   "homepage": "https://github.com/steipete/oracle#readme",
   "dependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@google/genai": "^1.30.0",
+    "@google/genai": "^1.31.0",
     "@google/generative-ai": "^0.24.1",
-    "@modelcontextprotocol/sdk": "^1.22.0",
+    "@modelcontextprotocol/sdk": "^1.24.3",
     "chalk": "^5.6.2",
     "chrome-cookies-secure": "3.0.0",
     "chrome-launcher": "^1.2.1",
@@ -57,33 +57,32 @@
     "dotenv": "^17.2.3",
     "fast-glob": "^3.3.3",
     "gpt-tokenizer": "^3.4.0",
-    "inquirer": "9.3.8",
+    "inquirer": "13.0.2",
     "json5": "^2.2.3",
     "keytar": "^7.9.0",
     "kleur": "^4.1.5",
     "markdansi": "^0.1.3",
-    "openai": "^6.9.1",
-    "shiki": "^3.15.0",
+    "openai": "^6.10.0",
+    "shiki": "^3.19.0",
     "sqlite3": "^5.1.7",
     "toasted-notifier": "^10.1.0",
-    "zod": "3.24.1"
+    "zod": "^4.1.13"
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@biomejs/biome": "^2.3.7",
+    "@biomejs/biome": "^2.3.8",
     "@cdktf/node-pty-prebuilt-multiarch": "0.10.2",
-    "@types/chrome-remote-interface": "^0.31.14",
+    "@types/chrome-remote-interface": "^0.33.0",
     "@types/inquirer": "^9.0.9",
-    "@types/json5": "^2.2.0",
     "@types/node": "^24.10.1",
-    "@vitest/coverage-v8": "4.0.13",
-    "devtools-protocol": "^0.0.1548823",
+    "@vitest/coverage-v8": "4.0.15",
+    "devtools-protocol": "^0.0.1551306",
     "es-toolkit": "^1.42.0",
-    "esbuild": "^0.27.0",
-    "puppeteer-core": "^24.31.0",
-    "tsx": "^4.20.6",
+    "esbuild": "^0.27.1",
+    "puppeteer-core": "^24.32.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.13"
+    "vitest": "^4.0.15"
   },
   "optionalDependencies": {
     "win-dpapi": "npm:@primno/dpapi@2.0.1"