@steipete/oracle 0.7.2 → 0.7.3

package/dist/src/browser/chromeLifecycle.js

@@ -25,6 +25,7 @@ export async function launchChrome(config, userDataDir, logger) {
             chromePath: config.chromePath ?? undefined,
             chromeFlags,
             userDataDir,
+            handleSIGINT: false,
             port: debugPort ?? undefined,
         });
     const pidLabel = typeof launcher.pid === 'number' ? ` (pid ${launcher.pid})` : '';
@@ -216,6 +217,7 @@ async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host
         chromePath: chromePath ?? undefined,
         chromeFlags,
         userDataDir,
+        handleSIGINT: false,
         port: requestedPort ?? undefined,
     });
     if (host) {

package/dist/src/browser/index.js

@@ -37,12 +37,14 @@ export async function runBrowserMode(options) {
         if (!runtimeHintCb || !chrome?.port) {
             return;
         }
+        const conversationId = lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined;
         const hint = {
             chromePid: chrome.pid,
             chromePort: chrome.port,
             chromeHost,
             chromeTargetId: lastTargetId,
             tabUrl: lastUrl,
+            conversationId,
             userDataDir,
             controllerPid: process.pid,
         };
@@ -947,6 +949,10 @@ function isWsl() {
         return true;
     return os.release().toLowerCase().includes('microsoft');
 }
+function extractConversationIdFromUrl(url) {
+    const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
+    return match?.[1];
+}
 async function resolveUserDataBaseDir() {
     // On WSL, Chrome launched via Windows can choke on UNC paths; prefer a Windows-backed temp folder.
     if (isWsl()) {

package/dist/src/browser/reattach.js

@@ -1,5 +1,13 @@
 import CDP from 'chrome-remote-interface';
-import { waitForAssistantResponse, captureAssistantMarkdown } from './pageActions.js';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdtemp, mkdir, rm } from 'node:fs/promises';
+import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, } from './pageActions.js';
+import { launchChrome, connectToChrome, hideChromeWindow } from './chromeLifecycle.js';
+import { resolveBrowserConfig } from './config.js';
+import { syncCookies } from './cookies.js';
+import { CHATGPT_URL } from './constants.js';
+import { delay } from './utils.js';
 function pickTarget(targets, runtime) {
     if (!Array.isArray(targets) || targets.length === 0) {
         return undefined;
@@ -18,33 +26,114 @@ function pickTarget(targets, runtime) {
     return targets.find((t) => t.type === 'page') ?? targets[0];
 }
 export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
+    const recoverSession = deps.recoverSession ??
+        (async (runtimeMeta, configMeta) => resumeBrowserSessionViaNewChrome(runtimeMeta, configMeta, logger, deps));
     if (!runtime.chromePort) {
-        throw new Error('Missing chromePort; cannot reattach.');
+        logger('No running Chrome detected; reopening browser to locate the session.');
+        return recoverSession(runtime, config);
     }
     const host = runtime.chromeHost ?? '127.0.0.1';
-    const listTargets = deps.listTargets ??
-        (async () => {
-            const targets = await CDP.List({ host, port: runtime.chromePort });
-            return targets;
-        });
-    const connect = deps.connect ?? ((options) => CDP(options));
-    const targetList = (await listTargets());
-    const target = pickTarget(targetList, runtime);
-    const client = (await connect({
-        host,
-        port: runtime.chromePort,
-        target: target?.targetId,
-    }));
-    const { Runtime, DOM } = client;
+    try {
+        const listTargets = deps.listTargets ??
+            (async () => {
+                const targets = await CDP.List({ host, port: runtime.chromePort });
+                return targets;
+            });
+        const connect = deps.connect ?? ((options) => CDP(options));
+        const targetList = (await listTargets());
+        const target = pickTarget(targetList, runtime);
+        const client = (await connect({
+            host,
+            port: runtime.chromePort,
+            target: target?.targetId,
+        }));
+        const { Runtime, DOM } = client;
+        if (Runtime?.enable) {
+            await Runtime.enable();
+        }
+        if (DOM && typeof DOM.enable === 'function') {
+            await DOM.enable();
+        }
+        const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
+        const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
+        const timeoutMs = config?.timeoutMs ?? 120_000;
+        const answer = await waitForResponse(Runtime, timeoutMs, logger);
+        const markdown = (await captureMarkdown(Runtime, answer.meta, logger)) ?? answer.text;
+        if (client && typeof client.close === 'function') {
+            try {
+                await client.close();
+            }
+            catch {
+                // ignore
+            }
+        }
+        return { answerText: answer.text, answerMarkdown: markdown };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Existing Chrome reattach failed (${message}); reopening browser to locate the session.`);
+        return recoverSession(runtime, config);
+    }
+}
+async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
+    const resolved = resolveBrowserConfig(config ?? {});
+    const manualLogin = Boolean(resolved.manualLogin);
+    const userDataDir = manualLogin
+        ? resolved.manualLoginProfileDir ?? path.join(os.homedir(), '.oracle', 'browser-profile')
+        : await mkdtemp(path.join(os.tmpdir(), 'oracle-reattach-'));
+    if (manualLogin) {
+        await mkdir(userDataDir, { recursive: true });
+    }
+    const chrome = await launchChrome(resolved, userDataDir, logger);
+    const chromeHost = chrome.host ?? '127.0.0.1';
+    const client = await connectToChrome(chrome.port, logger, chromeHost);
+    const { Network, Page, Runtime, DOM } = client;
     if (Runtime?.enable) {
         await Runtime.enable();
     }
     if (DOM && typeof DOM.enable === 'function') {
         await DOM.enable();
     }
+    if (!resolved.headless && resolved.hideWindow) {
+        await hideChromeWindow(chrome, logger);
+    }
+    let appliedCookies = 0;
+    if (!manualLogin && resolved.cookieSync) {
+        appliedCookies = await syncCookies(Network, resolved.url, resolved.chromeProfile, logger, {
+            allowErrors: resolved.allowCookieErrors,
+            filterNames: resolved.cookieNames ?? undefined,
+            inlineCookies: resolved.inlineCookies ?? undefined,
+            cookiePath: resolved.chromeCookiePath ?? undefined,
+        });
+    }
+    await navigateToChatGPT(Page, Runtime, CHATGPT_URL, logger);
+    await ensureNotBlocked(Runtime, resolved.headless, logger);
+    await ensureLoggedIn(Runtime, logger, { appliedCookies });
+    if (resolved.url !== CHATGPT_URL) {
+        await navigateToChatGPT(Page, Runtime, resolved.url, logger);
+        await ensureNotBlocked(Runtime, resolved.headless, logger);
+    }
+    await ensurePromptReady(Runtime, resolved.inputTimeoutMs, logger);
+    const conversationUrl = buildConversationUrl(runtime, resolved.url);
+    if (conversationUrl) {
+        logger(`Reopening conversation at ${conversationUrl}`);
+        await navigateToChatGPT(Page, Runtime, conversationUrl, logger);
+        await ensureNotBlocked(Runtime, resolved.headless, logger);
+        await ensurePromptReady(Runtime, resolved.inputTimeoutMs, logger);
+    }
+    else {
+        const opened = await openConversationFromSidebar(Runtime, {
+            conversationId: runtime.conversationId ?? extractConversationIdFromUrl(runtime.tabUrl ?? ''),
+            preferProjects: resolved.url !== CHATGPT_URL,
+        });
+        if (!opened) {
+            throw new Error('Unable to locate prior ChatGPT conversation in sidebar.');
+        }
+        await waitForLocationChange(Runtime, 15_000);
+    }
     const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
     const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
-    const timeoutMs = config?.timeoutMs ?? 120_000;
+    const timeoutMs = resolved.timeoutMs ?? 120_000;
     const answer = await waitForResponse(Runtime, timeoutMs, logger);
     const markdown = (await captureMarkdown(Runtime, answer.meta, logger)) ?? answer.text;
     if (client && typeof client.close === 'function') {
@@ -55,5 +144,91 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
             // ignore
         }
     }
+    if (!resolved.keepBrowser && !manualLogin) {
+        try {
+            await chrome.kill();
+        }
+        catch {
+            // ignore
+        }
+        await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+    }
     return { answerText: answer.text, answerMarkdown: markdown };
 }
+function extractConversationIdFromUrl(url) {
+    if (!url)
+        return undefined;
+    const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
+    return match?.[1];
+}
+function buildConversationUrl(runtime, baseUrl) {
+    if (runtime.tabUrl) {
+        return runtime.tabUrl;
+    }
+    const conversationId = runtime.conversationId;
+    if (!conversationId) {
+        return null;
+    }
+    try {
+        const base = new URL(baseUrl);
+        return `${base.origin}/c/${conversationId}`;
+    }
+    catch {
+        return null;
+    }
+}
+async function openConversationFromSidebar(Runtime, options) {
+    const response = await Runtime.evaluate({
+        expression: `(() => {
+      const conversationId = ${JSON.stringify(options.conversationId ?? null)};
+      const preferProjects = ${JSON.stringify(Boolean(options.preferProjects))};
+      const nav = document.querySelector('nav') || document.querySelector('aside') || document.body;
+      if (preferProjects) {
+        const projectLink = Array.from(nav.querySelectorAll('a,button'))
+          .find((el) => (el.textContent || '').trim().toLowerCase() === 'projects');
+        if (projectLink) {
+          projectLink.click();
+        }
+      }
+      const links = Array.from(nav.querySelectorAll('a[href]'))
+        .filter((el) => el instanceof HTMLAnchorElement)
+        .map((el) => el);
+      const convoLinks = links.filter((el) => el.href.includes('/c/'));
+      let target = null;
+      if (conversationId) {
+        target = convoLinks.find((el) => el.href.includes('/c/' + conversationId));
+      }
+      if (!target && convoLinks.length > 0) {
+        target = convoLinks[0];
+      }
+      if (target) {
+        target.scrollIntoView({ block: 'center' });
+        target.click();
+        return { ok: true, href: target.href, count: convoLinks.length };
+      }
+      return { ok: false, count: convoLinks.length };
+    })()`,
+        returnByValue: true,
+    });
+    return Boolean(response.result?.value?.ok);
+}
+async function waitForLocationChange(Runtime, timeoutMs) {
+    const start = Date.now();
+    let lastHref = '';
+    while (Date.now() - start < timeoutMs) {
+        const { result } = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
+        const href = typeof result?.value === 'string' ? result.value : '';
+        if (lastHref && href !== lastHref) {
+            return;
+        }
+        lastHref = href;
+        await delay(200);
+    }
+}
+// biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
+export const __test__ = {
+    pickTarget,
+    extractConversationIdFromUrl,
+    buildConversationUrl,
+    openConversationFromSidebar,
+};

package/dist/src/cli/notifier.js

@@ -2,6 +2,7 @@ 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 { estimateUsdCost } from 'tokentally';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createRequire } from 'node:module';
@@ -131,8 +132,13 @@ function inferCost(payload) {
     const config = MODEL_CONFIGS[model];
     if (!config?.pricing)
         return undefined;
-    return (usage.inputTokens * config.pricing.inputPerToken +
-        usage.outputTokens * config.pricing.outputPerToken);
+    return (estimateUsdCost({
+        usage: { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens },
+        pricing: {
+            inputUsdPerToken: config.pricing.inputPerToken,
+            outputUsdPerToken: config.pricing.outputPerToken,
+        },
+    })?.totalUsd ?? undefined);
 }
 function parseToggle(value) {
     if (value == null)

package/dist/src/cli/oscUtils.js

@@ -1,20 +1,2 @@
 // Utilities for handling OSC progress codes embedded in stored logs.
-const OSC_PROGRESS_PREFIX = '\u001b]9;4;';
-const OSC_END = '\u001b\\';
-/**
- * Optionally removes OSC 9;4 progress sequences (used by Ghostty/WezTerm to show progress bars).
- * Keep them when replaying to a real TTY; strip when piping to non-TTY outputs.
- */
-export function sanitizeOscProgress(text, keepOsc) {
-    if (keepOsc) {
-        return text;
-    }
-    let current = text;
-    while (current.includes(OSC_PROGRESS_PREFIX)) {
-        const start = current.indexOf(OSC_PROGRESS_PREFIX);
-        const end = current.indexOf(OSC_END, start + OSC_PROGRESS_PREFIX.length);
-        const cutEnd = end === -1 ? start + OSC_PROGRESS_PREFIX.length : end + OSC_END.length;
-        current = `${current.slice(0, start)}${current.slice(cutEnd)}`;
-    }
-    return current;
-}
+export { sanitizeOscProgress } from 'osc-progress';

package/dist/src/cli/sessionDisplay.js

@@ -76,10 +76,13 @@ export async function attachSession(sessionId, options) {
     const isVerbose = Boolean(process.env.ORACLE_VERBOSE_RENDER);
     const runtime = metadata.browser?.runtime;
     const controllerAlive = isProcessAlive(runtime?.controllerPid);
-    const canReattach = metadata.status === 'running' &&
+    const hasChromeDisconnect = metadata.response?.incompleteReason === 'chrome-disconnected';
+    const statusAllowsReattach = metadata.status === 'running' || (metadata.status === 'error' && hasChromeDisconnect);
+    const hasFallbackSessionInfo = Boolean(runtime?.chromePort || runtime?.tabUrl || runtime?.conversationId);
+    const canReattach = statusAllowsReattach &&
         metadata.mode === 'browser' &&
-        runtime?.chromePort &&
-        (metadata.response?.incompleteReason === 'chrome-disconnected' || (runtime.controllerPid && !controllerAlive));
+        hasFallbackSessionInfo &&
+        (hasChromeDisconnect || (runtime?.controllerPid && !controllerAlive));
     if (canReattach) {
         const portInfo = runtime?.chromePort ? `port ${runtime.chromePort}` : 'unknown port';
         const urlInfo = runtime?.tabUrl ? `url=${runtime.tabUrl}` : 'url=unknown';

package/dist/src/cli/sessionTable.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import kleur from 'kleur';
 import { MODEL_CONFIGS } from '../oracle.js';
+import { estimateUsdCost } from 'tokentally';
 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;
@@ -48,7 +49,10 @@ export function resolveSessionCost(meta) {
     }
     const input = meta.usage.inputTokens ?? 0;
     const output = meta.usage.outputTokens ?? 0;
-    const cost = input * pricing.inputPerToken + output * pricing.outputPerToken;
+    const cost = estimateUsdCost({
+        usage: { inputTokens: input, outputTokens: output },
+        pricing: { inputUsdPerToken: pricing.inputPerToken, outputUsdPerToken: pricing.outputPerToken },
+    })?.totalUsd ?? 0;
     return cost > 0 ? cost : null;
 }
 export function formatTimestampAligned(iso) {

package/dist/src/oracle/files.js

@@ -13,7 +13,14 @@ export async function readFiles(filePaths, { cwd = process.cwd(), fsModule = DEF
     const useNativeFilesystem = fsModule === DEFAULT_FS || isNativeFsModule(fsModule);
     let candidatePaths = [];
     if (useNativeFilesystem) {
-        candidatePaths = await expandWithNativeGlob(partitioned, cwd);
+        if (partitioned.globPatterns.length === 0 &&
+            partitioned.excludePatterns.length === 0 &&
+            partitioned.literalDirectories.length === 0) {
+            candidatePaths = Array.from(new Set(partitioned.literalFiles));
+        }
+        else {
+            candidatePaths = await expandWithNativeGlob(partitioned, cwd);
+        }
     }
     else {
         if (partitioned.globPatterns.length > 0 || partitioned.excludePatterns.length > 0) {

package/dist/src/oracle/modelResolver.js

@@ -1,5 +1,6 @@
 import { MODEL_CONFIGS, PRO_MODELS } from './config.js';
 import { countTokens as countTokensGpt5Pro } from 'gpt-tokenizer/model/gpt-5-pro';
+import { pricingFromUsdPerMillion } from 'tokentally';
 const OPENROUTER_DEFAULT_BASE = 'https://openrouter.ai/api/v1';
 const OPENROUTER_MODELS_ENDPOINT = 'https://openrouter.ai/api/v1/models';
 export function isKnownModel(model) {
@@ -96,10 +97,16 @@ export async function resolveModelConfig(model, options = {}) {
                     provider: known?.provider ?? 'other',
                     inputLimit: info.context_length ?? known?.inputLimit ?? 200_000,
                     pricing: info.pricing && info.pricing.prompt != null && info.pricing.completion != null
-                        ? {
-                            inputPerToken: info.pricing.prompt / 1_000_000,
-                            outputPerToken: info.pricing.completion / 1_000_000,
-                        }
+                        ? (() => {
+                            const pricing = pricingFromUsdPerMillion({
+                                inputUsdPerMillion: info.pricing.prompt,
+                                outputUsdPerMillion: info.pricing.completion,
+                            });
+                            return {
+                                inputPerToken: pricing.inputUsdPerToken,
+                                outputPerToken: pricing.outputUsdPerToken,
+                            };
+                        })()
                         : known?.pricing ?? null,
                     supportsBackground: known?.supportsBackground ?? true,
                     supportsSearch: known?.supportsSearch ?? true,

package/dist/src/oracle/multiModelRunner.js

@@ -2,24 +2,13 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, } from '../oracle.js';
 import { sessionStore } from '../sessionStore.js';
-const OSC_PROGRESS_PREFIX = '\u001b]9;4;';
-const OSC_PROGRESS_END = '\u001b\\';
+import { findOscProgressSequences, OSC_PROGRESS_PREFIX } from 'osc-progress';
 function forwardOscProgress(chunk, shouldForward) {
     if (!shouldForward || !chunk.includes(OSC_PROGRESS_PREFIX)) {
         return;
     }
-    let searchFrom = 0;
-    while (searchFrom < chunk.length) {
-        const start = chunk.indexOf(OSC_PROGRESS_PREFIX, searchFrom);
-        if (start === -1) {
-            break;
-        }
-        const end = chunk.indexOf(OSC_PROGRESS_END, start + OSC_PROGRESS_PREFIX.length);
-        if (end === -1) {
-            break;
-        }
-        process.stdout.write(chunk.slice(start, end + OSC_PROGRESS_END.length));
-        searchFrom = end + OSC_PROGRESS_END.length;
+    for (const seq of findOscProgressSequences(chunk)) {
+        process.stdout.write(seq.raw);
     }
 }
 const defaultDeps = {

package/dist/src/oracle/oscProgress.js

@@ -1,66 +1,17 @@
 import process from 'node:process';
-const OSC = '\u001b]9;4;';
-const ST = '\u001b\\';
-function sanitizeLabel(label) {
-    const withoutEscape = label.split('\u001b').join('');
-    const withoutBellAndSt = withoutEscape.replaceAll('\u0007', '').replaceAll('\u009c', '');
-    return withoutBellAndSt.replaceAll(']', '').trim();
-}
+import { startOscProgress as startOscProgressShared, supportsOscProgress as supportsOscProgressShared, } from 'osc-progress';
 export function supportsOscProgress(env = process.env, isTty = process.stdout.isTTY) {
-    if (!isTty) {
-        return false;
-    }
-    if (env.ORACLE_NO_OSC_PROGRESS === '1') {
-        return false;
-    }
-    if (env.ORACLE_FORCE_OSC_PROGRESS === '1') {
-        return true;
-    }
-    const termProgram = (env.TERM_PROGRAM ?? '').toLowerCase();
-    if (termProgram.includes('ghostty')) {
-        return true;
-    }
-    if (termProgram.includes('wezterm')) {
-        return true;
-    }
-    if (env.WT_SESSION) {
-        return true; // Windows Terminal exposes this
-    }
-    return false;
+    return supportsOscProgressShared(env, isTty, {
+        disableEnvVar: 'ORACLE_NO_OSC_PROGRESS',
+        forceEnvVar: 'ORACLE_FORCE_OSC_PROGRESS',
+    });
 }
 export function startOscProgress(options = {}) {
-    const { label = 'Waiting for API', targetMs = 10 * 60_000, write = (text) => process.stdout.write(text), indeterminate = false, } = options;
-    if (!supportsOscProgress(options.env, options.isTty)) {
-        return () => { };
-    }
-    const cleanLabel = sanitizeLabel(label);
-    if (indeterminate) {
-        write(`${OSC}3;;${cleanLabel}${ST}`);
-        return () => {
-            write(`${OSC}0;0;${cleanLabel}${ST}`);
-        };
-    }
-    const target = Math.max(targetMs, 1_000);
-    const send = (state, percent) => {
-        const clamped = Math.max(0, Math.min(100, Math.round(percent)));
-        write(`${OSC}${state};${clamped};${cleanLabel}${ST}`);
-    };
-    const startedAt = Date.now();
-    send(1, 0); // activate progress bar
-    const timer = setInterval(() => {
-        const elapsed = Date.now() - startedAt;
-        const percent = Math.min(99, (elapsed / target) * 100);
-        send(1, percent);
-    }, 900);
-    timer.unref?.();
-    let stopped = false;
-    return () => {
-        // multiple callers may try to stop
-        if (stopped) {
-            return;
-        }
-        stopped = true;
-        clearInterval(timer);
-        send(0, 0); // clear the progress bar
-    };
+    return startOscProgressShared({
+        ...options,
+        // Preserve Oracle's previous default: progress emits to stdout.
+        write: options.write ?? ((text) => process.stdout.write(text)),
+        disableEnvVar: 'ORACLE_NO_OSC_PROGRESS',
+        forceEnvVar: 'ORACLE_FORCE_OSC_PROGRESS',
+    });
 }

package/dist/src/oracle/run.js

@@ -19,8 +19,10 @@ import { createFsAdapter } from './fsAdapter.js';
 import { resolveGeminiModelId } from './gemini.js';
 import { resolveClaudeModelId } from './claude.js';
 import { renderMarkdownAnsi } from '../cli/markdownRenderer.js';
+import { createLiveRenderer } from 'markdansi';
 import { executeBackgroundResponse } from './background.js';
 import { formatTokenEstimate, formatTokenValue, resolvePreviewMode } from './runUtils.js';
+import { estimateUsdCost } from 'tokentally';
 import { defaultOpenRouterBaseUrl, isKnownModel, isOpenRouterBaseUrl, isProModel, resolveModelConfig, normalizeOpenRouterBaseUrl, } from './modelResolver.js';
 const isStdoutTty = process.stdout.isTTY && chalk.level > 0;
 const dim = (text) => (isStdoutTty ? kleur.dim(text) : text);
@@ -309,8 +311,8 @@ export async function runOracle(options, deps = {}) {
     let response = null;
     let elapsedMs = 0;
     let sawTextDelta = false;
-    // Buffer streamed text so we can re-render markdown once the stream ends (TTY + non-plain mode).
-    const streamedChunks = [];
+    let streamedText = '';
+    let lastLiveFrameAtMs = 0;
     let answerHeaderPrinted = false;
     const allowAnswerHeader = options.suppressAnswerHeader !== true;
     const timeoutExceeded = () => now() - runStart >= timeoutMs;
@@ -378,31 +380,52 @@ export async function runOracle(options, deps = {}) {
                     },
                 });
             }
+            let liveRenderer = null;
             try {
+                liveRenderer =
+                    isTty && !renderPlain
+                        ? createLiveRenderer({
+                            write: stdoutWrite,
+                            width: process.stdout.columns ?? 80,
+                            renderFrame: renderMarkdownAnsi,
+                        })
+                        : null;
                 for await (const event of stream) {
                     throwIfTimedOut();
                     const isTextDelta = event.type === 'chunk' || event.type === 'response.output_text.delta';
-                    if (isTextDelta) {
-                        stopOscProgress();
-                        stopHeartbeatNow();
-                        sawTextDelta = true;
-                        ensureAnswerHeader();
-                        if (!options.silent && typeof event.delta === 'string') {
-                            // Always keep the log/bookkeeping sink up to date.
-                            sinkWrite(event.delta);
-                            if (renderPlain) {
-                                // Plain mode: stream directly to stdout regardless of write sink.
-                                stdoutWrite(event.delta);
-                            }
-                            else if (isTty) {
-                                // Buffer for end-of-stream markdown rendering on TTY.
-                                streamedChunks.push(event.delta);
-                            }
-                            else {
-                                // Non-TTY streams should still surface output; fall back to raw stdout.
-                                stdoutWrite(event.delta);
-                            }
+                    if (!isTextDelta)
+                        continue;
+                    stopOscProgress();
+                    stopHeartbeatNow();
+                    sawTextDelta = true;
+                    ensureAnswerHeader();
+                    if (options.silent || typeof event.delta !== 'string')
+                        continue;
+                    // Always keep the log/bookkeeping sink up to date.
+                    sinkWrite(event.delta);
+                    if (renderPlain) {
+                        // Plain mode: stream directly to stdout regardless of write sink.
+                        stdoutWrite(event.delta);
+                        continue;
+                    }
+                    if (liveRenderer) {
+                        streamedText += event.delta;
+                        const currentMs = now();
+                        const due = currentMs - lastLiveFrameAtMs >= 120;
+                        const hasNewline = event.delta.includes('\n');
+                        if (hasNewline || due) {
+                            liveRenderer.render(streamedText);
+                            lastLiveFrameAtMs = currentMs;
                         }
+                        continue;
+                    }
+                    // Non-TTY streams should still surface output; fall back to raw stdout.
+                    stdoutWrite(event.delta);
+                }
+                if (liveRenderer) {
+                    streamedText = streamedText.trim();
+                    if (streamedText.length > 0) {
+                        liveRenderer.render(streamedText);
                     }
                 }
                 throwIfTimedOut();
@@ -414,6 +437,9 @@ export async function runOracle(options, deps = {}) {
                 log(chalk.yellow(describeTransportError(transportError, timeoutMs)));
                 throw transportError;
             }
+            finally {
+                liveRenderer?.finish();
+            }
             response = await stream.finalResponse();
             throwIfTimedOut();
             stopHeartbeatNow();
@@ -428,21 +454,17 @@ export async function runOracle(options, deps = {}) {
     }
     // We only add spacing when streamed text was printed.
     if (sawTextDelta && !options.silent) {
-        const fullStreamedText = streamedChunks.join('');
-        const shouldRenderAfterStream = isTty && !renderPlain && fullStreamedText.length > 0;
-        if (shouldRenderAfterStream) {
-            const rendered = renderMarkdownAnsi(fullStreamedText);
-            stdoutWrite(rendered);
-            if (!rendered.endsWith('\n')) {
-                stdoutWrite('\n');
-            }
-            log('');
-        }
-        else if (renderPlain) {
+        const shouldRenderAfterStream = isTty && !renderPlain && streamedText.length > 0;
+        if (renderPlain) {
             // Plain streaming already wrote chunks; ensure clean separation.
             stdoutWrite('\n');
         }
+        else if (!shouldRenderAfterStream) {
+            // Non-TTY streams should still surface output; ensure separation.
+            log('');
+        }
         else {
+            // Live-rendered mode already drew the final frame; only separate from logs.
             log('');
         }
     }
@@ -503,7 +525,10 @@ export async function runOracle(options, deps = {}) {
     const totalTokens = usage.total_tokens ?? inputTokens + outputTokens + reasoningTokens;
     const pricing = modelConfig.pricing ?? undefined;
     const cost = pricing
-        ? inputTokens * pricing.inputPerToken + outputTokens * pricing.outputPerToken
+        ? estimateUsdCost({
+            usage: { inputTokens, outputTokens, reasoningTokens, totalTokens },
+            pricing: { inputUsdPerToken: pricing.inputPerToken, outputUsdPerToken: pricing.outputPerToken },
+        })?.totalUsd
         : undefined;
     const elapsedDisplay = formatElapsed(elapsedMs);
     const statsParts = [];
@@ -541,6 +566,9 @@ export async function runOracle(options, deps = {}) {
         statsParts.push(`files=${files.length}`);
     }
     const sessionPrefix = options.sessionId ? `${options.sessionId} ` : '';
+    if (!options.silent) {
+        log('');
+    }
     log(chalk.blue(`Finished ${sessionPrefix}in ${elapsedDisplay} (${statsParts.join(' | ')})`));
     return {
         mode: 'live',

package/dist/src/sessionManager.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import { createWriteStream } from 'node:fs';
+import net from 'node:net';
 import { DEFAULT_MODEL } from './oracle.js';
 import { safeModelSlug } from './oracle/modelResolver.js';
 import { getOracleHomeDir } from './oracleHome.js';
@@ -15,6 +16,7 @@ const MODEL_JSON_EXTENSION = '.json';
 const MODEL_LOG_EXTENSION = '.log';
 const MAX_STATUS_LIMIT = 1000;
 const ZOMBIE_MAX_AGE_MS = 60 * 60 * 1000; // 60 minutes
+const CHROME_RUNTIME_TIMEOUT_MS = 250;
 const DEFAULT_SLUG = 'session';
 const MAX_SLUG_WORDS = 5;
 const MIN_CUSTOM_SLUG_WORDS = 3;
@@ -245,7 +247,8 @@ async function readModernSessionMetadata(sessionId) {
             return null;
         }
         const enriched = await attachModelRuns(parsed, sessionId);
-        return await markZombie(enriched, { persist: false });
+        const runtimeChecked = await markDeadBrowser(enriched, { persist: false });
+        return await markZombie(runtimeChecked, { persist: false });
     }
     catch {
         return null;
@@ -256,7 +259,8 @@ async function readLegacySessionMetadata(sessionId) {
         const raw = await fs.readFile(legacySessionPath(sessionId), 'utf8');
         const parsed = JSON.parse(raw);
         const enriched = await attachModelRuns(parsed, sessionId);
-        return await markZombie(enriched, { persist: false });
+        const runtimeChecked = await markDeadBrowser(enriched, { persist: false });
+        return await markZombie(runtimeChecked, { persist: false });
     }
     catch {
         return null;
@@ -294,6 +298,7 @@ export async function listSessionsMetadata() {
     for (const entry of entries) {
         let meta = await readSessionMetadata(entry);
         if (meta) {
+            meta = await markDeadBrowser(meta, { persist: true });
             meta = await markZombie(meta, { persist: true }); // keep stored metadata consistent with zombie detection
             metas.push(meta);
         }
@@ -451,6 +456,44 @@ async function markZombie(meta, { persist }) {
     }
     return updated;
 }
+async function markDeadBrowser(meta, { persist }) {
+    if (meta.status !== 'running' || meta.mode !== 'browser') {
+        return meta;
+    }
+    const runtime = meta.browser?.runtime;
+    if (!runtime) {
+        return meta;
+    }
+    const signals = [];
+    if (runtime.chromePid) {
+        signals.push(isProcessAlive(runtime.chromePid));
+    }
+    if (runtime.chromePort) {
+        const host = runtime.chromeHost ?? '127.0.0.1';
+        signals.push(await isPortOpen(host, runtime.chromePort));
+    }
+    if (signals.length === 0 || signals.some(Boolean)) {
+        return meta;
+    }
+    const response = meta.response
+        ? {
+            ...meta.response,
+            status: 'error',
+            incompleteReason: meta.response.incompleteReason ?? 'chrome-disconnected',
+        }
+        : { status: 'error', incompleteReason: 'chrome-disconnected' };
+    const updated = {
+        ...meta,
+        status: 'error',
+        errorMessage: 'Browser session ended (Chrome is no longer reachable)',
+        completedAt: new Date().toISOString(),
+        response,
+    };
+    if (persist) {
+        await fs.writeFile(metaPath(meta.id), JSON.stringify(updated, null, 2), 'utf8');
+    }
+    return updated;
+}
 function isZombie(meta) {
     if (meta.status !== 'running') {
         return false;
@@ -465,3 +508,49 @@ function isZombie(meta) {
     }
     return Date.now() - startedMs > ZOMBIE_MAX_AGE_MS;
 }
+function isProcessAlive(pid) {
+    if (!pid)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error instanceof Error ? error.code : undefined;
+        if (code === 'ESRCH' || code === 'EINVAL') {
+            return false;
+        }
+        if (code === 'EPERM') {
+            return true;
+        }
+        return true;
+    }
+}
+async function isPortOpen(host, port) {
+    if (!port || port <= 0 || port > 65535) {
+        return false;
+    }
+    return new Promise((resolve) => {
+        const socket = net.createConnection({ host, port });
+        let settled = false;
+        const cleanup = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.removeAllListeners();
+            socket.end();
+            socket.destroy();
+            socket.unref();
+            resolve(result);
+        };
+        const timer = setTimeout(() => cleanup(false), CHROME_RUNTIME_TIMEOUT_MS);
+        socket.once('connect', () => {
+            clearTimeout(timer);
+            cleanup(true);
+        });
+        socket.once('error', () => {
+            clearTimeout(timer);
+            cleanup(false);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.2 Pro (via gpt-5.1-pro alias), GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "type": "module",
   "main": "dist/bin/oracle-cli.js",
@@ -8,6 +8,26 @@
     "oracle": "dist/bin/oracle-cli.js",
     "oracle-mcp": "dist/bin/oracle-mcp.js"
   },
+  "scripts": {
+    "docs:list": "tsx scripts/docs-list.ts",
+    "build": "tsc -p tsconfig.build.json && pnpm run build:vendor",
+    "build:vendor": "node -e \"const fs=require('fs'); const path=require('path'); const vendorRoot=path.join('dist','vendor'); fs.rmSync(vendorRoot,{recursive:true,force:true}); const vendors=[['oracle-notifier']]; vendors.forEach(([name])=>{const src=path.join('vendor',name); const dest=path.join(vendorRoot,name); fs.mkdirSync(dest,{recursive:true}); if(fs.existsSync(src)){fs.cpSync(src,dest,{recursive:true,force:true});}});\"",
+    "start": "pnpm run build && node ./dist/scripts/run-cli.js",
+    "oracle": "pnpm start",
+    "check": "pnpm run typecheck",
+    "typecheck": "tsc --noEmit",
+    "lint": "pnpm run typecheck && biome lint .",
+    "test": "vitest run",
+    "test:mcp": "pnpm run build && pnpm run test:mcp:unit && pnpm run test:mcp:mcporter",
+    "test:mcp:unit": "vitest run tests/mcp*.test.ts tests/mcp/**/*.test.ts",
+    "test:mcp:mcporter": "npx -y mcporter list oracle-local --schema --config config/mcporter.json && npx -y mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
+    "test:browser": "pnpm run build && tsx scripts/test-browser.ts && ./scripts/browser-smoke.sh",
+    "test:live": "ORACLE_LIVE_TEST=1 vitest run tests/live --exclude tests/live/openai-live.test.ts",
+    "test:pro": "ORACLE_LIVE_TEST=1 vitest run tests/live/openai-live.test.ts",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "pnpm run build",
+    "mcp": "pnpm run build && node ./dist/bin/oracle-mcp.js"
+  },
   "files": [
     "dist/**/*",
     "assets-oracle-icon.png",
@@ -57,25 +77,27 @@
     "json5": "^2.2.3",
     "keytar": "^7.9.0",
     "kleur": "^4.1.5",
-    "markdansi": "^0.1.3",
-    "openai": "^6.14.0",
+    "markdansi": "0.1.7",
+    "openai": "^6.15.0",
+    "osc-progress": "^0.1.0",
     "shiki": "^3.20.0",
     "sqlite3": "^5.1.7",
     "toasted-notifier": "^10.1.0",
+    "tokentally": "github:steipete/tokentally#v0.1.0",
     "zod": "^4.2.1"
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@biomejs/biome": "^2.3.9",
+    "@biomejs/biome": "^2.3.10",
     "@cdktf/node-pty-prebuilt-multiarch": "0.10.2",
     "@types/chrome-remote-interface": "^0.33.0",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.0.3",
     "@vitest/coverage-v8": "4.0.16",
-    "devtools-protocol": "0.0.1559729",
+    "devtools-protocol": "0.0.1561482",
     "es-toolkit": "^1.43.0",
     "esbuild": "^0.27.2",
-    "puppeteer-core": "^24.33.0",
+    "puppeteer-core": "^24.34.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
@@ -83,23 +105,18 @@
   "optionalDependencies": {
     "win-dpapi": "npm:@primno/dpapi@2.0.1"
   },
-  "scripts": {
-    "docs:list": "tsx scripts/docs-list.ts",
-    "build": "tsc -p tsconfig.build.json && pnpm run build:vendor",
-    "build:vendor": "node -e \"const fs=require('fs'); const path=require('path'); const vendorRoot=path.join('dist','vendor'); fs.rmSync(vendorRoot,{recursive:true,force:true}); const vendors=[['oracle-notifier']]; vendors.forEach(([name])=>{const src=path.join('vendor',name); const dest=path.join(vendorRoot,name); fs.mkdirSync(dest,{recursive:true}); if(fs.existsSync(src)){fs.cpSync(src,dest,{recursive:true,force:true});}});\"",
-    "start": "pnpm run build && node ./dist/scripts/run-cli.js",
-    "oracle": "pnpm start",
-    "check": "pnpm run typecheck",
-    "typecheck": "tsc --noEmit",
-    "lint": "pnpm run typecheck && biome lint .",
-    "test": "vitest run",
-    "test:mcp": "pnpm run build && pnpm run test:mcp:unit && pnpm run test:mcp:mcporter",
-    "test:mcp:unit": "vitest run tests/mcp*.test.ts tests/mcp/**/*.test.ts",
-    "test:mcp:mcporter": "npx -y mcporter list oracle-local --schema --config config/mcporter.json && npx -y mcporter call oracle-local.sessions limit:1 --config config/mcporter.json",
-    "test:browser": "pnpm run build && tsx scripts/test-browser.ts && ./scripts/browser-smoke.sh",
-    "test:live": "ORACLE_LIVE_TEST=1 vitest run tests/live --exclude tests/live/openai-live.test.ts",
-    "test:pro": "ORACLE_LIVE_TEST=1 vitest run tests/live/openai-live.test.ts",
-    "test:coverage": "vitest run --coverage",
-    "mcp": "pnpm run build && node ./dist/bin/oracle-mcp.js"
-  }
-}
+  "pnpm": {
+    "overrides": {
+      "devtools-protocol": "0.0.1561482",
+      "win-dpapi": "npm:@primno/dpapi@2.0.1"
+    },
+    "onlyBuiltDependencies": [
+      "@cdktf/node-pty-prebuilt-multiarch",
+      "esbuild",
+      "keytar",
+      "sqlite3",
+      "win-dpapi"
+    ]
+  },
+  "packageManager": "pnpm@10.23.0+sha512.21c4e5698002ade97e4efe8b8b4a89a8de3c85a37919f957e7a0f30f38fbc5bbdd05980ffe29179b2fb6e6e691242e098d945d1601772cad0fef5fb6411e2a4b"
+}

package/vendor/oracle-notifier/README.md

@@ -0,0 +1,24 @@
+# Oracle Notifier helper (macOS, arm64)
+
+Builds a tiny signed helper app for macOS notifications with the Oracle icon.
+
+## Build
+
+```bash
+cd vendor/oracle-notifier
+# Optional: notarize by setting App Store Connect key credentials
+export APP_STORE_CONNECT_API_KEY_P8="$(cat AuthKey_XXXXXX.p8)" # with literal newlines or \n escaped
+export APP_STORE_CONNECT_KEY_ID=XXXXXX
+export APP_STORE_CONNECT_ISSUER_ID=YYYYYYYY-YYYY-YYYY-YYYY-YYYYYYYYYYYY
+./build-notifier.sh
+```
+
+- Requires Xcode command line tools (swiftc) and a macOS Developer ID certificate. Without a valid cert, the build fails (no ad-hoc fallback).
+- If `APP_STORE_CONNECT_*` vars are set, the script notarizes and staples the ticket.
+- Output: `OracleNotifier.app` (arm64 only), bundled with `OracleIcon.icns`.
+
+## Usage
+The CLI prefers this helper on macOS; if it fails or is missing, it falls back to toasted-notifier/terminal-notifier.
+
+## Permissions
+After first run, allow notifications for “Oracle Notifier” in System Settings → Notifications.