@steipete/oracle 0.7.5 → 0.8.0

package/dist/src/cli/options.js

@@ -1,4 +1,6 @@
 import { InvalidArgumentError } from 'commander';
+import path from 'node:path';
+import fg from 'fast-glob';
 import { DEFAULT_MODEL, MODEL_CONFIGS } from '../oracle.js';
 export function collectPaths(value, previous = []) {
     if (!value) {
@@ -17,6 +19,31 @@ export function mergePathLikeOptions(file, include, filesAlias, pathAlias, paths
     const withPathAlias = collectPaths(pathAlias, withFilesAlias);
     return collectPaths(pathsAlias, withPathAlias);
 }
+export function dedupePathInputs(inputs, { cwd = process.cwd() } = {}) {
+    const deduped = [];
+    const duplicates = [];
+    const seen = new Set();
+    for (const entry of inputs ?? []) {
+        const raw = entry?.trim();
+        if (!raw)
+            continue;
+        let key = raw;
+        if (!raw.startsWith('!') && !fg.isDynamicPattern(raw)) {
+            const absolute = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
+            key = `path:${path.normalize(absolute)}`;
+        }
+        else {
+            key = `pattern:${raw}`;
+        }
+        if (seen.has(key)) {
+            duplicates.push(raw);
+            continue;
+        }
+        seen.add(key);
+        deduped.push(raw);
+    }
+    return { deduped, duplicates };
+}
 export function collectModelList(value, previous = []) {
     if (!value) {
         return previous;

package/dist/src/cli/sessionDisplay.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import kleur from 'kleur';
 import { renderMarkdownAnsi } from './markdownRenderer.js';
-import { formatElapsed, formatUSD } from '../oracle/format.js';
+import { formatFinishLine } from '../oracle/finishLine.js';
 import { sessionStore, wait } from '../sessionStore.js';
 import { formatTokenCount, formatTokenValue } from '../oracle/runUtils.js';
 import { resumeBrowserSession } from '../browser/reattach.js';
@@ -61,6 +61,13 @@ export async function attachSession(sessionId, options) {
         process.exitCode = 1;
         return;
     }
+    if (metadata.mode === 'browser' && metadata.status === 'running' && !metadata.browser?.runtime) {
+        await wait(250);
+        const refreshed = await sessionStore.readSession(sessionId);
+        if (refreshed) {
+            metadata = refreshed;
+        }
+    }
     const normalizedModelFilter = options?.model?.trim().toLowerCase();
     if (normalizedModelFilter) {
         const availableModels = metadata.models?.map((model) => model.model.toLowerCase()) ??
@@ -92,7 +99,7 @@ export async function attachSession(sessionId, options) {
                 if (message) {
                     console.log(dim(message));
                 }
-            }), { verbose: true }));
+            }), { verbose: true }), { promptPreview: metadata.promptPreview });
             const outputTokens = estimateTokenCount(result.answerMarkdown);
             const logWriter = sessionStore.createLogWriter(sessionId);
             logWriter.logLine('[reattach] captured assistant response from existing Chrome tab');
@@ -516,7 +523,6 @@ export function formatCompletionSummary(metadata, options = {}) {
     const modeLabel = metadata.mode === 'browser' ? `${metadata.model ?? 'n/a'}[browser]` : metadata.model ?? 'n/a';
     const usage = metadata.usage;
     const cost = resolveSessionCost(metadata);
-    const costPart = cost != null ? ` | ${formatUSD(cost)}` : '';
     const tokensDisplay = [
         usage.inputTokens ?? 0,
         usage.outputTokens ?? 0,
@@ -530,10 +536,23 @@ export function formatCompletionSummary(metadata, options = {}) {
         total_tokens: usage.totalTokens,
     }, index))
         .join('/');
+    const tokensPart = (() => {
+        const parts = tokensDisplay.split('/');
+        if (parts.length !== 4)
+            return tokensDisplay;
+        return `↑${parts[0]} ↓${parts[1]} ↻${parts[2]} Δ${parts[3]}`;
+    })();
     const filesCount = metadata.options?.file?.length ?? 0;
-    const filesPart = filesCount > 0 ? ` | files=${filesCount}` : '';
-    const slugPart = options.includeSlug ? ` | slug=${metadata.id}` : '';
-    return `Finished in ${formatElapsed(metadata.elapsedMs)} (${modeLabel}${costPart} | tok(i/o/r/t)=${tokensDisplay}${filesPart}${slugPart})`;
+    const filesPart = filesCount > 0 ? `files=${filesCount}` : null;
+    const slugPart = options.includeSlug ? `slug=${metadata.id}` : null;
+    const { line1, line2 } = formatFinishLine({
+        elapsedMs: metadata.elapsedMs,
+        model: modeLabel,
+        costUsd: cost ?? null,
+        tokensPart,
+        detailParts: [filesPart, slugPart],
+    });
+    return line2 ? `${line1} | ${line2}` : line1;
 }
 async function readStoredPrompt(sessionId) {
     const request = await sessionStore.readRequest(sessionId);

package/dist/src/cli/sessionRunner.js

@@ -15,10 +15,9 @@ import { resolveModelConfig } from '../oracle/modelResolver.js';
 import { buildPrompt, buildRequestBody } from '../oracle/request.js';
 import { estimateRequestTokens } from '../oracle/tokenEstimate.js';
 import { formatTokenEstimate, formatTokenValue } from '../oracle/runUtils.js';
-import { formatElapsed } from '../oracle/format.js';
+import { formatFinishLine } from '../oracle/finishLine.js';
 import { sanitizeOscProgress } from './oscUtils.js';
 import { readFiles } from '../oracle/files.js';
-import { formatUSD } from '../oracle/format.js';
 import { cwd as getCwd } from 'node:process';
 const isTty = process.stdout.isTTY;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
@@ -211,10 +210,21 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 total_tokens: aggregateUsage.totalTokens,
             }, idx))
                 .join('/');
-            const costLabel = aggregateUsage.cost != null ? formatUSD(aggregateUsage.cost) : 'cost=N/A';
+            const tokensPart = (() => {
+                const parts = tokensDisplay.split('/');
+                if (parts.length !== 4)
+                    return tokensDisplay;
+                return `↑${parts[0]} ↓${parts[1]} ↻${parts[2]} Δ${parts[3]}`;
+            })();
             const statusColor = summary.rejected.length === 0 ? kleur.green : summary.fulfilled.length > 0 ? kleur.yellow : kleur.red;
             const overallText = `${summary.fulfilled.length}/${multiModels.length} models`;
-            log(statusColor(`Finished in ${formatElapsed(summary.elapsedMs)} (${overallText} | ${costLabel} | tok(i/o/r/t)=${tokensDisplay})`));
+            const { line1 } = formatFinishLine({
+                elapsedMs: summary.elapsedMs,
+                model: overallText,
+                costUsd: aggregateUsage.cost ?? null,
+                tokensPart,
+            });
+            log(statusColor(line1));
             const hasFailure = summary.rejected.length > 0;
             await sessionStore.updateSession(sessionMeta.id, {
                 status: hasFailure ? 'error' : 'completed',

package/dist/src/gemini-web/executor.js

@@ -1,5 +1,27 @@
 import path from 'node:path';
+import { getCookies } from '@steipete/sweet-cookie';
 import { runGeminiWebWithFallback, saveFirstGeminiImageFromOutput } from './client.js';
+const GEMINI_COOKIE_NAMES = [
+    '__Secure-1PSID',
+    '__Secure-1PSIDTS',
+    '__Secure-1PSIDCC',
+    '__Secure-1PAPISID',
+    'NID',
+    'AEC',
+    'SOCS',
+    '__Secure-BUCKET',
+    '__Secure-ENID',
+    'SID',
+    'HSID',
+    'SSID',
+    'APISID',
+    'SAPISID',
+    '__Secure-3PSID',
+    '__Secure-3PSIDTS',
+    '__Secure-3PAPISID',
+    'SIDCC',
+];
+const GEMINI_REQUIRED_COOKIES = ['__Secure-1PSID', '__Secure-1PSIDTS'];
 function estimateTokenCount(text) {
     return Math.ceil(text.length / 4);
 }
@@ -30,59 +52,84 @@ function resolveGeminiWebModel(desiredModel, log) {
             return 'gemini-3-pro';
     }
 }
+function resolveCookieDomain(cookie) {
+    const rawDomain = cookie.domain?.trim();
+    if (rawDomain) {
+        return rawDomain.startsWith('.') ? rawDomain.slice(1) : rawDomain;
+    }
+    const rawUrl = cookie.url?.trim();
+    if (rawUrl) {
+        try {
+            return new URL(rawUrl).hostname;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function pickCookieValue(cookies, name) {
+    const matches = cookies.filter((cookie) => cookie.name === name && typeof cookie.value === 'string');
+    if (matches.length === 0)
+        return undefined;
+    const preferredDomain = matches.find((cookie) => {
+        const domain = resolveCookieDomain(cookie);
+        return domain === 'google.com' && (cookie.path ?? '/') === '/';
+    });
+    const googleDomain = matches.find((cookie) => (resolveCookieDomain(cookie) ?? '').endsWith('google.com'));
+    return (preferredDomain ?? googleDomain ?? matches[0])?.value;
+}
+function buildGeminiCookieMap(cookies) {
+    const cookieMap = {};
+    for (const name of GEMINI_COOKIE_NAMES) {
+        const value = pickCookieValue(cookies, name);
+        if (value)
+            cookieMap[name] = value;
+    }
+    return cookieMap;
+}
+function hasRequiredGeminiCookies(cookieMap) {
+    return GEMINI_REQUIRED_COOKIES.every((name) => Boolean(cookieMap[name]));
+}
+async function loadGeminiCookiesFromInline(browserConfig, log) {
+    const inline = browserConfig?.inlineCookies;
+    if (!inline || inline.length === 0)
+        return {};
+    const cookieMap = buildGeminiCookieMap(inline.filter((cookie) => Boolean(cookie?.name && typeof cookie.value === 'string')));
+    if (Object.keys(cookieMap).length > 0) {
+        const source = browserConfig?.inlineCookiesSource ?? 'inline';
+        log?.(`[gemini-web] Loaded Gemini cookies from inline payload (${source}): ${Object.keys(cookieMap).length} cookie(s).`);
+    }
+    else {
+        log?.('[gemini-web] Inline cookie payload provided but no Gemini cookies matched.');
+    }
+    return cookieMap;
+}
 async function loadGeminiCookiesFromChrome(browserConfig, log) {
     try {
-        const mod = (await import('chrome-cookies-secure'));
-        const chromeCookies = mod.default ??
-            mod;
-        const profile = typeof browserConfig?.chromeProfile === 'string' &&
-            browserConfig.chromeProfile.trim().length > 0
-            ? browserConfig.chromeProfile.trim()
+        // Learned: Gemini web relies on Google auth cookies in the *browser* profile, not API keys.
+        const profileCandidate = browserConfig?.chromeCookiePath ?? browserConfig?.chromeProfile ?? undefined;
+        const profile = typeof profileCandidate === 'string' && profileCandidate.trim().length > 0
+            ? profileCandidate.trim()
             : undefined;
         const sources = [
             'https://gemini.google.com',
             'https://accounts.google.com',
             'https://www.google.com',
         ];
-        const wantNames = [
-            '__Secure-1PSID',
-            '__Secure-1PSIDTS',
-            '__Secure-1PSIDCC',
-            '__Secure-1PAPISID',
-            'NID',
-            'AEC',
-            'SOCS',
-            '__Secure-BUCKET',
-            '__Secure-ENID',
-            'SID',
-            'HSID',
-            'SSID',
-            'APISID',
-            'SAPISID',
-            '__Secure-3PSID',
-            '__Secure-3PSIDTS',
-            '__Secure-3PAPISID',
-            'SIDCC',
-        ];
-        const cookieMap = {};
-        for (const url of sources) {
-            const cookies = (await chromeCookies.getCookiesPromised(url, 'puppeteer', profile));
-            for (const name of wantNames) {
-                if (cookieMap[name])
-                    continue;
-                const matches = cookies.filter((cookie) => cookie.name === name);
-                if (matches.length === 0)
-                    continue;
-                const preferredDomain = matches.find((cookie) => cookie.domain === '.google.com' && (cookie.path ?? '/') === '/');
-                const googleDomain = matches.find((cookie) => (cookie.domain ?? '').endsWith('google.com'));
-                const value = (preferredDomain ?? googleDomain ?? matches[0])?.value;
-                if (value)
-                    cookieMap[name] = value;
-            }
-        }
-        if (!cookieMap['__Secure-1PSID'] || !cookieMap['__Secure-1PSIDTS']) {
-            return {};
+        const { cookies, warnings } = await getCookies({
+            url: sources[0],
+            origins: sources,
+            names: [...GEMINI_COOKIE_NAMES],
+            browsers: ['chrome'],
+            mode: 'merge',
+            chromeProfile: profile,
+            timeoutMs: 5_000,
+        });
+        if (warnings.length && log?.verbose) {
+            log(`[gemini-web] Cookie warnings:\n- ${warnings.join('\n- ')}`);
         }
+        const cookieMap = buildGeminiCookieMap(cookies);
         log?.(`[gemini-web] Loaded Gemini cookies from Chrome (node): ${Object.keys(cookieMap).length} cookie(s).`);
         return cookieMap;
     }
@@ -91,13 +138,27 @@ async function loadGeminiCookiesFromChrome(browserConfig, log) {
         return {};
     }
 }
+async function loadGeminiCookies(browserConfig, log) {
+    const inlineMap = await loadGeminiCookiesFromInline(browserConfig, log);
+    const hasInlineRequired = hasRequiredGeminiCookies(inlineMap);
+    if (hasInlineRequired && browserConfig?.cookieSync === false) {
+        return inlineMap;
+    }
+    if (browserConfig?.cookieSync === false && !hasInlineRequired) {
+        log?.('[gemini-web] Cookie sync disabled and inline cookies missing Gemini auth tokens.');
+        return inlineMap;
+    }
+    const chromeMap = await loadGeminiCookiesFromChrome(browserConfig, log);
+    const merged = { ...chromeMap, ...inlineMap };
+    return merged;
+}
 export function createGeminiWebExecutor(geminiOptions) {
     return async (runOptions) => {
         const startTime = Date.now();
         const log = runOptions.log;
         log?.('[gemini-web] Starting Gemini web executor (TypeScript)');
-        const cookieMap = await loadGeminiCookiesFromChrome(runOptions.config, log);
-        if (!cookieMap['__Secure-1PSID'] || !cookieMap['__Secure-1PSIDTS']) {
+        const cookieMap = await loadGeminiCookies(runOptions.config, log);
+        if (!hasRequiredGeminiCookies(cookieMap)) {
             throw new Error('Gemini browser mode requires Chrome cookies for google.com (missing __Secure-1PSID/__Secure-1PSIDTS).');
         }
         const configTimeout = typeof runOptions.config?.timeoutMs === 'number' && Number.isFinite(runOptions.config.timeoutMs)

package/dist/src/oracle/finishLine.js

@@ -0,0 +1,32 @@
+import { formatUSD } from './format.js';
+export function formatElapsedCompact(ms) {
+    if (!Number.isFinite(ms) || ms < 0) {
+        return 'unknown';
+    }
+    if (ms < 60_000) {
+        return `${(ms / 1000).toFixed(1)}s`;
+    }
+    if (ms < 60 * 60_000) {
+        const minutes = Math.floor(ms / 60_000);
+        const seconds = Math.floor((ms % 60_000) / 1000);
+        return `${minutes}m${seconds.toString().padStart(2, '0')}s`;
+    }
+    const hours = Math.floor(ms / (60 * 60_000));
+    const minutes = Math.floor((ms % (60 * 60_000)) / 60_000);
+    return `${hours}h${minutes.toString().padStart(2, '0')}m`;
+}
+export function formatFinishLine({ elapsedMs, model, costUsd, tokensPart, summaryExtraParts, detailParts, }) {
+    const line1Parts = [
+        formatElapsedCompact(elapsedMs),
+        typeof costUsd === 'number' ? formatUSD(costUsd) : null,
+        model,
+        tokensPart,
+        ...(summaryExtraParts ?? []),
+    ];
+    const line1 = line1Parts.filter((part) => typeof part === 'string' && part.length > 0).join(' · ');
+    const line2Parts = (detailParts ?? []).filter((part) => typeof part === 'string' && part.length > 0);
+    if (line2Parts.length === 0) {
+        return { line1 };
+    }
+    return { line1, line2: line2Parts.join(' | ') };
+}

package/dist/src/oracle/run.js

@@ -8,7 +8,8 @@ import { DEFAULT_SYSTEM_PROMPT, MODEL_CONFIGS, TOKENIZER_OPTIONS } from './confi
 import { readFiles } from './files.js';
 import { buildPrompt, buildRequestBody } from './request.js';
 import { estimateRequestTokens } from './tokenEstimate.js';
-import { formatElapsed, formatUSD } from './format.js';
+import { formatElapsed } from './format.js';
+import { formatFinishLine } from './finishLine.js';
 import { getFileTokenStats, printFileTokenStats } from './tokenStats.js';
 import { OracleResponseError, OracleTransportError, PromptValidationError, describeTransportError, toTransportError, } from './errors.js';
 import { createDefaultClientFactory } from './client.js';
@@ -19,7 +20,7 @@ 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 { createMarkdownStreamer } from 'markdansi';
 import { executeBackgroundResponse } from './background.js';
 import { formatTokenEstimate, formatTokenValue, resolvePreviewMode } from './runUtils.js';
 import { estimateUsdCost } from 'tokentally';
@@ -311,8 +312,6 @@ export async function runOracle(options, deps = {}) {
     let response = null;
     let elapsedMs = 0;
     let sawTextDelta = false;
-    let streamedText = '';
-    let lastLiveFrameAtMs = 0;
     let answerHeaderPrinted = false;
     const allowAnswerHeader = options.suppressAnswerHeader !== true;
     const timeoutExceeded = () => now() - runStart >= timeoutMs;
@@ -380,14 +379,23 @@ export async function runOracle(options, deps = {}) {
                     },
                 });
             }
-            let liveRenderer = null;
+            let markdownStreamer = null;
+            const flushMarkdownStreamer = () => {
+                if (!markdownStreamer)
+                    return;
+                const rendered = markdownStreamer.finish();
+                markdownStreamer = null;
+                if (rendered) {
+                    stdoutWrite(rendered);
+                }
+            };
             try {
-                liveRenderer =
+                markdownStreamer =
                     isTty && !renderPlain
-                        ? createLiveRenderer({
-                            write: stdoutWrite,
-                            width: process.stdout.columns ?? 80,
-                            renderFrame: renderMarkdownAnsi,
+                        ? createMarkdownStreamer({
+                            render: renderMarkdownAnsi,
+                            spacing: 'single',
+                            mode: 'hybrid',
                         })
                         : null;
                 for await (const event of stream) {
@@ -408,38 +416,27 @@ export async function runOracle(options, deps = {}) {
                         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;
+                    if (markdownStreamer) {
+                        const rendered = markdownStreamer.push(event.delta);
+                        if (rendered) {
+                            stdoutWrite(rendered);
                         }
                         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);
-                    }
-                }
+                flushMarkdownStreamer();
                 throwIfTimedOut();
             }
             catch (streamError) {
                 // stream.abort() is not available on the interface
+                flushMarkdownStreamer();
                 stopHeartbeatNow();
                 const transportError = toTransportError(streamError, requestBody.model);
                 log(chalk.yellow(describeTransportError(transportError, timeoutMs)));
                 throw transportError;
             }
-            finally {
-                liveRenderer?.finish();
-            }
             response = await stream.finalResponse();
             throwIfTimedOut();
             stopHeartbeatNow();
@@ -454,17 +451,12 @@ export async function runOracle(options, deps = {}) {
     }
     // We only add spacing when streamed text was printed.
     if (sawTextDelta && !options.silent) {
-        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.
+            // Separate streamed output from logs.
             log('');
         }
     }
@@ -530,46 +522,48 @@ export async function runOracle(options, deps = {}) {
             pricing: { inputUsdPerToken: pricing.inputPerToken, outputUsdPerToken: pricing.outputPerToken },
         })?.totalUsd
         : undefined;
-    const elapsedDisplay = formatElapsed(elapsedMs);
-    const statsParts = [];
     const effortLabel = modelConfig.reasoning?.effort;
     const modelLabel = effortLabel ? `${modelConfig.model}[${effortLabel}]` : modelConfig.model;
     const sessionIdContainsModel = typeof options.sessionId === 'string' && options.sessionId.toLowerCase().includes(modelConfig.model.toLowerCase());
-    // Avoid duplicating the model name in the prefix (session id) and the stats bundle; keep a single source of truth.
-    if (!sessionIdContainsModel) {
-        statsParts.push(modelLabel);
-    }
-    if (cost != null) {
-        statsParts.push(formatUSD(cost));
-    }
-    else {
-        statsParts.push('cost=N/A');
-    }
     const tokensDisplay = [inputTokens, outputTokens, reasoningTokens, totalTokens]
         .map((value, index) => formatTokenValue(value, usage, index))
         .join('/');
-    const tokensLabel = options.verbose ? 'tokens (input/output/reasoning/total)' : 'tok(i/o/r/t)';
-    statsParts.push(`${tokensLabel}=${tokensDisplay}`);
-    if (options.verbose) {
-        // Only surface request-vs-response deltas when verbose is explicitly requested to keep default stats compact.
-        const actualInput = usage.input_tokens;
-        if (actualInput !== undefined) {
-            const delta = actualInput - estimatedInputTokens;
-            const deltaText = delta === 0 ? '' : delta > 0 ? ` (+${delta.toLocaleString()})` : ` (${delta.toLocaleString()})`;
-            statsParts.push(`est→actual=${estimatedInputTokens.toLocaleString()}→${actualInput.toLocaleString()}${deltaText}`);
-        }
-    }
-    if (!searchEnabled) {
-        statsParts.push('search=off');
-    }
-    if (files.length > 0) {
-        statsParts.push(`files=${files.length}`);
-    }
-    const sessionPrefix = options.sessionId ? `${options.sessionId} ` : '';
+    const tokensPart = (() => {
+        const parts = tokensDisplay.split('/');
+        if (parts.length !== 4)
+            return tokensDisplay;
+        return `↑${parts[0]} ↓${parts[1]} ↻${parts[2]} Δ${parts[3]}`;
+    })();
+    const modelPart = sessionIdContainsModel ? null : modelLabel;
+    const actualInput = usage.input_tokens;
+    const estActualPart = (() => {
+        if (!options.verbose)
+            return null;
+        if (actualInput === undefined)
+            return null;
+        const delta = actualInput - estimatedInputTokens;
+        const deltaText = delta === 0 ? '' : delta > 0 ? ` (+${delta.toLocaleString()})` : ` (${delta.toLocaleString()})`;
+        return `est→actual=${estimatedInputTokens.toLocaleString()}→${actualInput.toLocaleString()}${deltaText}`;
+    })();
+    const { line1, line2 } = formatFinishLine({
+        elapsedMs,
+        model: modelPart,
+        costUsd: cost ?? null,
+        tokensPart,
+        summaryExtraParts: options.sessionId ? [`sid=${options.sessionId}`] : null,
+        detailParts: [
+            estActualPart,
+            !searchEnabled ? 'search=off' : null,
+            files.length > 0 ? `files=${files.length}` : null,
+        ],
+    });
     if (!options.silent) {
         log('');
     }
-    log(chalk.blue(`Finished ${sessionPrefix}in ${elapsedDisplay} (${statsParts.join(' | ')})`));
+    log(chalk.blue(line1));
+    if (line2) {
+        log(dim(line2));
+    }
     return {
         mode: 'live',
         response,

package/dist/src/remote/server.js

@@ -7,7 +7,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
 import chalk from 'chalk';
 import { runBrowserMode } from '../browserMode.js';
-import { loadChromeCookies } from '../browser/chromeCookies.js';
+import { getCookies } from '@steipete/sweet-cookie';
 import { CHATGPT_URL } from '../browser/constants.js';
 import { cleanupStaleProfileState, readDevToolsPort, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from '../browser/profileState.js';
 import { normalizeChatgptUrl } from '../browser/utils.js';
@@ -331,13 +331,17 @@ function formatReachableAddresses(bindAddress, port) {
 async function loadLocalChatgptCookies(logger, targetUrl) {
     try {
         logger('Loading ChatGPT cookies from this host\'s Chrome profile...');
-        const cookies = await Promise.resolve(loadChromeCookies({
-            targetUrl,
-            profile: 'Default',
-        })).catch((error) => {
-            logger(`Unable to load local ChatGPT cookies on this host: ${error instanceof Error ? error.message : String(error)}`);
-            return [];
+        const { cookies: rawCookies, warnings } = await getCookies({
+            url: targetUrl,
+            browsers: ['chrome'],
+            mode: 'merge',
+            chromeProfile: 'Default',
+            timeoutMs: 5_000,
         });
+        if (warnings.length) {
+            logger(`Cookie warnings:\n- ${warnings.join('\n- ')}`);
+        }
+        const cookies = rawCookies.map(toCdpCookie).filter((c) => Boolean(c));
         if (!cookies || cookies.length === 0) {
             logger('No local ChatGPT cookies found on this host. Please log in once; opening ChatGPT...');
             const opened = triggerLocalLoginPrompt(logger, targetUrl);
@@ -348,14 +352,7 @@ async function loadLocalChatgptCookies(logger, targetUrl) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        const missingDbMatch = message.match(/Unable to locate Chrome cookie DB at (.+)/);
-        if (missingDbMatch) {
-            const lookedPath = missingDbMatch[1];
-            logger(`Chrome cookies not found at ${lookedPath}. Set --browser-cookie-path to your Chrome profile or log in manually.`);
-        }
-        else {
-            logger(`Unable to load local ChatGPT cookies on this host: ${message}`);
-        }
+        logger(`Unable to load local ChatGPT cookies on this host: ${message}`);
         if (process.platform === 'linux' && isWsl()) {
             logger('WSL hint: Chrome lives under /mnt/c/Users/<you>/AppData/Local/Google/Chrome/User Data/Default; pass --browser-cookie-path to that directory if auto-detect fails.');
         }
@@ -363,6 +360,24 @@ async function loadLocalChatgptCookies(logger, targetUrl) {
         return { cookies: null, opened };
     }
 }
+function toCdpCookie(cookie) {
+    if (!cookie?.name)
+        return null;
+    const out = {
+        name: cookie.name,
+        value: cookie.value,
+        domain: cookie.domain,
+        path: cookie.path ?? '/',
+        secure: cookie.secure ?? true,
+        httpOnly: cookie.httpOnly ?? false,
+    };
+    if (typeof cookie.expires === 'number')
+        out.expires = cookie.expires;
+    if (cookie.sameSite === 'Lax' || cookie.sameSite === 'Strict' || cookie.sameSite === 'None') {
+        out.sameSite = cookie.sameSite;
+    }
+    return out;
+}
 function triggerLocalLoginPrompt(logger, url) {
     const verbose = process.argv.includes('--verbose') || process.env.ORACLE_SERVE_VERBOSE === '1';
     const openers = [];

package/dist/src/sessionManager.js

@@ -445,6 +445,22 @@ async function markZombie(meta, { persist }) {
     if (!isZombie(meta)) {
         return meta;
     }
+    if (meta.mode === 'browser') {
+        const runtime = meta.browser?.runtime;
+        if (runtime) {
+            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.some(Boolean)) {
+                return meta;
+            }
+        }
+    }
     const updated = {
         ...meta,
         status: 'error',