@steipete/oracle 1.1.0 → 1.3.0

package/dist/src/oracle/run.js

@@ -8,34 +8,31 @@ import { APIConnectionError, APIConnectionTimeoutError } from 'openai';
 import { DEFAULT_SYSTEM_PROMPT, MODEL_CONFIGS, TOKENIZER_OPTIONS } from './config.js';
 import { readFiles } from './files.js';
 import { buildPrompt, buildRequestBody } from './request.js';
+import { estimateRequestTokens } from './tokenEstimate.js';
 import { formatElapsed, formatUSD } from './format.js';
 import { getFileTokenStats, printFileTokenStats } from './tokenStats.js';
 import { OracleResponseError, OracleTransportError, PromptValidationError, describeTransportError, toTransportError, } from './errors.js';
 import { createDefaultClientFactory } from './client.js';
+import { formatBaseUrlForLog, maskApiKey } from './logging.js';
 import { startHeartbeat } from '../heartbeat.js';
 import { startOscProgress } from './oscProgress.js';
 import { getCliVersion } from '../version.js';
 import { createFsAdapter } from './fsAdapter.js';
-const isTty = process.stdout.isTTY;
+import { resolveGeminiModelId } from './gemini.js';
+const isTty = process.stdout.isTTY && chalk.level > 0;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
 const BACKGROUND_MAX_WAIT_MS = 30 * 60 * 1000;
 const BACKGROUND_POLL_INTERVAL_MS = 5000;
 const BACKGROUND_RETRY_BASE_MS = 3000;
 const BACKGROUND_RETRY_MAX_MS = 15000;
+const DEFAULT_TIMEOUT_NON_PRO_MS = 30_000;
+const DEFAULT_TIMEOUT_PRO_MS = 20 * 60 * 1000;
 const defaultWait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
 export async function runOracle(options, deps = {}) {
-    const { apiKey = options.apiKey ?? process.env.OPENAI_API_KEY, cwd = process.cwd(), fs: fsModule = createFsAdapter(fs), log = console.log, write = (text) => process.stdout.write(text), now = () => performance.now(), clientFactory = createDefaultClientFactory(), client, wait = defaultWait, } = deps;
-    const maskApiKey = (key) => {
-        if (!key)
-            return null;
-        if (key.length <= 8)
-            return `${key[0] ?? ''}***${key[key.length - 1] ?? ''}`;
-        const prefix = key.slice(0, 4);
-        const suffix = key.slice(-4);
-        return `${prefix}****${suffix}`;
-    };
+    const { apiKey: optionsApiKey = options.apiKey, cwd = process.cwd(), fs: fsModule = createFsAdapter(fs), log = console.log, write = (text) => process.stdout.write(text), now = () => performance.now(), clientFactory = createDefaultClientFactory(), client, wait = defaultWait, } = deps;
+    const baseUrl = options.baseUrl?.trim() || process.env.OPENAI_BASE_URL?.trim();
     const logVerbose = (message) => {
         if (options.verbose) {
             log(dim(`[verbose] ${message}`));
@@ -43,15 +40,22 @@ export async function runOracle(options, deps = {}) {
     };
     const previewMode = resolvePreviewMode(options.previewMode ?? options.preview);
     const isPreview = Boolean(previewMode);
+    const getApiKeyForModel = (model) => {
+        if (model.startsWith('gpt')) {
+            return optionsApiKey ?? process.env.OPENAI_API_KEY;
+        }
+        if (model.startsWith('gemini')) {
+            return optionsApiKey ?? process.env.GEMINI_API_KEY;
+        }
+        return undefined;
+    };
+    const envVar = options.model.startsWith('gpt') ? 'OPENAI_API_KEY' : 'GEMINI_API_KEY';
+    const apiKey = getApiKeyForModel(options.model);
     if (!apiKey) {
-        throw new PromptValidationError('Missing OPENAI_API_KEY. Set it via the environment or a .env file.', {
-            env: 'OPENAI_API_KEY',
+        throw new PromptValidationError(`Missing ${envVar}. Set it via the environment or a .env file.`, {
+            env: envVar,
         });
     }
-    const maskedKey = maskApiKey(apiKey);
-    if (maskedKey) {
-        log(dim(`Using OPENAI_API_KEY=${maskedKey}`));
-    }
     const modelConfig = MODEL_CONFIGS[options.model];
     if (!modelConfig) {
         throw new PromptValidationError(`Unsupported model "${options.model}". Choose one of: ${Object.keys(MODEL_CONFIGS).join(', ')}`, { model: options.model });
@@ -61,6 +65,8 @@ export async function runOracle(options, deps = {}) {
     const files = await readFiles(options.file ?? [], { cwd, fsModule });
     const searchEnabled = options.search !== false;
     logVerbose(`cwd: ${cwd}`);
+    let pendingNoFilesTip = null;
+    let pendingShortPromptTip = null;
     if (files.length > 0) {
         const displayPaths = files
             .map((file) => path.relative(cwd, file.path) || file.path)
@@ -72,9 +78,15 @@ export async function runOracle(options, deps = {}) {
     else {
         logVerbose('No files attached.');
         if (!isPreview) {
-            log(dim('Tip: no files attached — Oracle works best with project context. Add files via --file path/to/code or docs.'));
+            pendingNoFilesTip =
+                'Tip: no files attached — Oracle works best with project context. Add files via --file path/to/code or docs.';
         }
     }
+    const shortPrompt = (options.prompt?.trim().length ?? 0) < 80;
+    if (!isPreview && shortPrompt) {
+        pendingShortPromptTip =
+            'Tip: brief prompts often yield generic answers — aim for 6–30 sentences and attach key files.';
+    }
     const fileTokenInfo = getFileTokenStats(files, {
         cwd,
         tokenizer: modelConfig.tokenizer,
@@ -85,22 +97,50 @@ export async function runOracle(options, deps = {}) {
     logVerbose(`Attached files use ${totalFileTokens.toLocaleString()} tokens`);
     const systemPrompt = options.system?.trim() || DEFAULT_SYSTEM_PROMPT;
     const promptWithFiles = buildPrompt(options.prompt, files, cwd);
-    const tokenizerInput = [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: promptWithFiles },
-    ];
-    const estimatedInputTokens = modelConfig.tokenizer(tokenizerInput, TOKENIZER_OPTIONS);
-    logVerbose(`Estimated tokens (prompt + files): ${estimatedInputTokens.toLocaleString()}`);
     const fileCount = files.length;
     const cliVersion = getCliVersion();
     const richTty = process.stdout.isTTY && chalk.level > 0;
+    const timeoutSeconds = options.timeoutSeconds === undefined || options.timeoutSeconds === 'auto'
+        ? options.model === 'gpt-5-pro'
+            ? DEFAULT_TIMEOUT_PRO_MS / 1000
+            : DEFAULT_TIMEOUT_NON_PRO_MS / 1000
+        : options.timeoutSeconds;
+    const timeoutMs = timeoutSeconds * 1000;
+    // Track the concrete model id we dispatch to (especially for Gemini preview aliases)
+    const effectiveModelId = options.effectiveModelId ??
+        (options.model.startsWith('gemini') ? resolveGeminiModelId(options.model) : modelConfig.model);
     const headerModelLabel = richTty ? chalk.cyan(modelConfig.model) : modelConfig.model;
+    const requestBody = buildRequestBody({
+        modelConfig,
+        systemPrompt,
+        userPrompt: promptWithFiles,
+        searchEnabled,
+        maxOutputTokens: options.maxOutput,
+        background: useBackground,
+        storeResponse: useBackground,
+    });
+    const estimatedInputTokens = estimateRequestTokens(requestBody, modelConfig);
     const tokenLabel = richTty ? chalk.green(estimatedInputTokens.toLocaleString()) : estimatedInputTokens.toLocaleString();
     const fileLabel = richTty ? chalk.magenta(fileCount.toString()) : fileCount.toString();
-    const headerLine = `Oracle (${cliVersion}) consulting ${headerModelLabel}'s crystal ball with ${tokenLabel} tokens and ${fileLabel} files...`;
+    const filesPhrase = fileCount === 0 ? 'no files' : `${fileLabel} files`;
+    const headerLine = `🧿 oracle (${cliVersion}) summons ${headerModelLabel} — ${tokenLabel} tokens, ${filesPhrase}`;
     const shouldReportFiles = (options.filesReport || fileTokenInfo.totalTokens > inputTokenBudget) && fileTokenInfo.stats.length > 0;
     if (!isPreview) {
         log(headerLine);
+        const maskedKey = maskApiKey(apiKey);
+        if (maskedKey) {
+            const resolvedSuffix = options.model.startsWith('gemini') && effectiveModelId !== modelConfig.model ? ` (resolved: ${effectiveModelId})` : '';
+            log(dim(`Using ${envVar}=${maskedKey} for model ${modelConfig.model}${resolvedSuffix}`));
+        }
+        if (baseUrl) {
+            log(dim(`Base URL: ${formatBaseUrlForLog(baseUrl)}`));
+        }
+        if (pendingNoFilesTip) {
+            log(dim(pendingNoFilesTip));
+        }
+        if (pendingShortPromptTip) {
+            log(dim(pendingShortPromptTip));
+        }
         if (options.model === 'gpt-5-pro') {
             log(dim('Pro is thinking, this can take up to 30 minutes...'));
         }
@@ -112,15 +152,7 @@ export async function runOracle(options, deps = {}) {
     if (estimatedInputTokens > inputTokenBudget) {
         throw new PromptValidationError(`Input too large (${estimatedInputTokens.toLocaleString()} tokens). Limit is ${inputTokenBudget.toLocaleString()} tokens.`, { estimatedInputTokens, inputTokenBudget });
     }
-    const requestBody = buildRequestBody({
-        modelConfig,
-        systemPrompt,
-        userPrompt: promptWithFiles,
-        searchEnabled,
-        maxOutputTokens: options.maxOutput,
-        background: useBackground,
-        storeResponse: useBackground,
-    });
+    logVerbose(`Estimated tokens (request body): ${estimatedInputTokens.toLocaleString()}`);
     if (isPreview && previewMode) {
         if (previewMode === 'json' || previewMode === 'full') {
             log('Request JSON');
@@ -141,11 +173,22 @@ export async function runOracle(options, deps = {}) {
             inputTokenBudget,
         };
     }
-    const openAiClient = client ?? clientFactory(apiKey);
-    logVerbose('Dispatching request to OpenAI Responses API...');
+    const apiEndpoint = modelConfig.model.startsWith('gemini') ? undefined : baseUrl;
+    const clientInstance = client ??
+        clientFactory(apiKey, {
+            baseUrl: apiEndpoint,
+            azure: options.azure,
+            model: options.model,
+            resolvedModelId: effectiveModelId,
+        });
+    logVerbose('Dispatching request to API...');
+    if (options.verbose) {
+        log(''); // ensure verbose section is separated from Answer stream
+    }
     const stopOscProgress = startOscProgress({
-        label: useBackground ? 'Waiting for OpenAI (background)' : 'Waiting for OpenAI',
-        targetMs: useBackground ? BACKGROUND_MAX_WAIT_MS : 10 * 60_000,
+        label: useBackground ? 'Waiting for API (background)' : 'Waiting for API',
+        targetMs: useBackground ? timeoutMs : Math.min(timeoutMs, 10 * 60_000),
+        indeterminate: true,
         write,
     });
     const runStart = now();
@@ -153,6 +196,12 @@ export async function runOracle(options, deps = {}) {
     let elapsedMs = 0;
     let sawTextDelta = false;
     let answerHeaderPrinted = false;
+    const timeoutExceeded = () => now() - runStart >= timeoutMs;
+    const throwIfTimedOut = () => {
+        if (timeoutExceeded()) {
+            throw new OracleTransportError('client-timeout', `Timed out waiting for API response after ${formatElapsed(timeoutMs)}.`);
+        }
+    };
     const ensureAnswerHeader = () => {
         if (!options.silent && !answerHeaderPrinted) {
             log('');
@@ -163,17 +212,18 @@ export async function runOracle(options, deps = {}) {
     try {
         if (useBackground) {
             response = await executeBackgroundResponse({
-                client: openAiClient,
+                client: clientInstance,
                 requestBody,
                 log,
                 wait,
                 heartbeatIntervalMs: options.heartbeatIntervalMs,
                 now,
+                maxWaitMs: timeoutMs,
             });
             elapsedMs = now() - runStart;
         }
         else {
-            const stream = await openAiClient.responses.stream(requestBody);
+            const stream = await clientInstance.responses.stream(requestBody);
             let heartbeatActive = false;
             let stopHeartbeat = null;
             const stopHeartbeatNow = () => {
@@ -192,13 +242,16 @@ export async function runOracle(options, deps = {}) {
                     isActive: () => heartbeatActive,
                     makeMessage: (elapsedMs) => {
                         const elapsedText = formatElapsed(elapsedMs);
-                        return `API connection active — ${elapsedText} elapsed. Expect up to ~10 min before GPT-5 responds.`;
+                        const timeoutLabel = Math.round(timeoutMs / 60000);
+                        return `API connection active — ${elapsedText} elapsed. Timeout in ~${timeoutLabel} min if no response.`;
                     },
                 });
             }
             try {
                 for await (const event of stream) {
-                    if (event.type === 'response.output_text.delta') {
+                    throwIfTimedOut();
+                    const isTextDelta = event.type === 'chunk' || event.type === 'response.output_text.delta';
+                    if (isTextDelta) {
                         stopOscProgress();
                         stopHeartbeatNow();
                         sawTextDelta = true;
@@ -208,17 +261,17 @@ export async function runOracle(options, deps = {}) {
                         }
                     }
                 }
+                throwIfTimedOut();
             }
             catch (streamError) {
-                if (typeof stream.abort === 'function') {
-                    stream.abort();
-                }
+                // stream.abort() is not available on the interface
                 stopHeartbeatNow();
                 const transportError = toTransportError(streamError);
                 log(chalk.yellow(describeTransportError(transportError)));
                 throw transportError;
             }
             response = await stream.finalResponse();
+            throwIfTimedOut();
             stopHeartbeatNow();
             elapsedMs = now() - runStart;
         }
@@ -227,19 +280,42 @@ export async function runOracle(options, deps = {}) {
         stopOscProgress();
     }
     if (!response) {
-        throw new Error('OpenAI did not return a response.');
+        throw new Error('API did not return a response.');
+    }
+    // biome-ignore lint/nursery/noUnnecessaryConditions: we only add spacing when any streamed text was printed
+    if (sawTextDelta && !options.silent) {
+        write('\n');
+        log('');
     }
     logVerbose(`Response status: ${response.status ?? 'completed'}`);
     if (response.status && response.status !== 'completed') {
-        const detail = response.error?.message || response.incomplete_details?.reason || response.status;
-        log(chalk.yellow(`OpenAI ended the run early (status=${response.status}${response.incomplete_details?.reason ? `, reason=${response.incomplete_details.reason}` : ''}).`));
-        throw new OracleResponseError(`Response did not complete: ${detail}`, response);
+        // API can reply `in_progress` even after the stream closes; give it a brief grace poll.
+        if (response.id && response.status === 'in_progress') {
+            const polishingStart = now();
+            const pollIntervalMs = 2_000;
+            const maxWaitMs = 60_000;
+            log(chalk.dim('Response still in_progress; polling until completion...'));
+            // Short polling loop — we don't want to hang forever, just catch late finalization.
+            while (now() - polishingStart < maxWaitMs) {
+                await wait(pollIntervalMs);
+                const refreshed = await clientInstance.responses.retrieve(response.id);
+                if (refreshed.status === 'completed') {
+                    response = refreshed;
+                    break;
+                }
+            }
+        }
+        if (response.status !== 'completed') {
+            const detail = response.error?.message || response.incomplete_details?.reason || response.status;
+            log(chalk.yellow(`API ended the run early (status=${response.status}${response.incomplete_details?.reason ? `, reason=${response.incomplete_details.reason}` : ''}).`));
+            throw new OracleResponseError(`Response did not complete: ${detail}`, response);
+        }
     }
     const answerText = extractTextOutput(response);
     if (!options.silent) {
         // biome-ignore lint/nursery/noUnnecessaryConditions: flips true when streaming events arrive
         if (sawTextDelta) {
-            write('\n\n');
+            write('\n');
         }
         else {
             ensureAnswerHeader();
@@ -261,18 +337,26 @@ export async function runOracle(options, deps = {}) {
     const tokensDisplay = [inputTokens, outputTokens, reasoningTokens, totalTokens]
         .map((value, index) => formatTokenValue(value, usage, index))
         .join('/');
-    statsParts.push(`tok(i/o/r/t)=${tokensDisplay}`);
+    const tokensLabel = options.verbose ? 'tokens (input/output/reasoning/total)' : 'tok(i/o/r/t)';
+    statsParts.push(`${tokensLabel}=${tokensDisplay}`);
+    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}`);
     }
-    log(chalk.blue(`Finished in ${elapsedDisplay} (${statsParts.join(' | ')})`));
+    const sessionPrefix = options.sessionId ? `${options.sessionId} ` : '';
+    log(chalk.blue(`Finished ${sessionPrefix}in ${elapsedDisplay} (${statsParts.join(' | ')})`));
     return {
         mode: 'live',
         response,
-        usage: { inputTokens, outputTokens, reasoningTokens, totalTokens },
+        usage: { inputTokens, outputTokens, reasoningTokens, totalTokens, cost },
         elapsedMs,
     };
 }
@@ -317,13 +401,13 @@ export function extractTextOutput(response) {
     return '';
 }
 async function executeBackgroundResponse(params) {
-    const { client, requestBody, log, wait, heartbeatIntervalMs, now } = params;
+    const { client, requestBody, log, wait, heartbeatIntervalMs, now, maxWaitMs } = params;
     const initialResponse = await client.responses.create(requestBody);
     if (!initialResponse || !initialResponse.id) {
-        throw new OracleResponseError('OpenAI did not return a response ID for the background run.', initialResponse);
+        throw new OracleResponseError('API did not return a response ID for the background run.', initialResponse);
     }
     const responseId = initialResponse.id;
-    log(dim(`OpenAI scheduled background response ${responseId} (status=${initialResponse.status ?? 'unknown'}). Monitoring up to ${Math.round(BACKGROUND_MAX_WAIT_MS / 60000)} minutes for completion...`));
+    log(dim(`API scheduled background response ${responseId} (status=${initialResponse.status ?? 'unknown'}). Monitoring up to ${Math.round(BACKGROUND_MAX_WAIT_MS / 60000)} minutes for completion...`));
     let heartbeatActive = false;
     let stopHeartbeat = null;
     const stopHeartbeatNow = () => {
@@ -342,7 +426,7 @@ async function executeBackgroundResponse(params) {
             isActive: () => heartbeatActive,
             makeMessage: (elapsedMs) => {
                 const elapsedText = formatElapsed(elapsedMs);
-                return `OpenAI background run still in progress — ${elapsedText} elapsed.`;
+                return `API background run still in progress — ${elapsedText} elapsed.`;
             },
         });
     }
@@ -354,7 +438,7 @@ async function executeBackgroundResponse(params) {
             log,
             wait,
             now,
-            maxWaitMs: BACKGROUND_MAX_WAIT_MS,
+            maxWaitMs,
         });
     }
     finally {
@@ -373,10 +457,10 @@ async function pollBackgroundResponse(params) {
         // biome-ignore lint/nursery/noUnnecessaryConditions: guard only for first iteration
         if (firstCycle) {
             firstCycle = false;
-            log(dim(`OpenAI background response status=${status}. We'll keep retrying automatically.`));
+            log(dim(`API background response status=${status}. We'll keep retrying automatically.`));
         }
         else if (status !== lastStatus && status !== 'completed') {
-            log(dim(`OpenAI background response status=${status}.`));
+            log(dim(`API background response status=${status}.`));
         }
         lastStatus = status;
         if (status === 'completed') {
@@ -387,11 +471,11 @@ async function pollBackgroundResponse(params) {
             throw new OracleResponseError(`Response did not complete: ${detail}`, response);
         }
         if (now() - startMark >= maxWaitMs) {
-            throw new OracleTransportError('client-timeout', 'Timed out waiting for OpenAI background response to finish.');
+            throw new OracleTransportError('client-timeout', 'Timed out waiting for API background response to finish.');
         }
         await wait(BACKGROUND_POLL_INTERVAL_MS);
         if (now() - startMark >= maxWaitMs) {
-            throw new OracleTransportError('client-timeout', 'Timed out waiting for OpenAI background response to finish.');
+            throw new OracleTransportError('client-timeout', 'Timed out waiting for API background response to finish.');
         }
         const { response: nextResponse, reconnected } = await retrieveBackgroundResponseWithRetry({
             client,
@@ -404,7 +488,7 @@ async function pollBackgroundResponse(params) {
         });
         if (reconnected) {
             const nextStatus = nextResponse.status ?? 'in_progress';
-            log(dim(`Reconnected to OpenAI background response (status=${nextStatus}). OpenAI is still working...`));
+            log(dim(`Reconnected to API background response (status=${nextStatus}). API is still working...`));
         }
         response = nextResponse;
     }
@@ -428,7 +512,7 @@ async function retrieveBackgroundResponseWithRetry(params) {
             log(chalk.yellow(`${describeTransportError(transportError)} Retrying in ${formatElapsed(delay)}...`));
             await wait(delay);
             if (now() - startMark >= maxWaitMs) {
-                throw new OracleTransportError('client-timeout', 'Timed out waiting for OpenAI background response to finish.');
+                throw new OracleTransportError('client-timeout', 'Timed out waiting for API background response to finish.');
             }
         }
     }

package/dist/src/oracle/tokenEstimate.js

@@ -0,0 +1,34 @@
+import { TOKENIZER_OPTIONS } from './config.js';
+/**
+ * Estimate input tokens from the full request body instead of just system/user text.
+ * This is a conservative approximation: we tokenize the key textual fields and add a fixed buffer
+ * to cover structural JSON overhead and server-side wrappers (tools/reasoning/background/store).
+ */
+export function estimateRequestTokens(requestBody, modelConfig, bufferTokens = 200) {
+    const parts = [];
+    if (requestBody.instructions) {
+        parts.push(requestBody.instructions);
+    }
+    for (const turn of requestBody.input ?? []) {
+        for (const content of turn.content ?? []) {
+            if (typeof content.text === 'string') {
+                parts.push(content.text);
+            }
+        }
+    }
+    if (requestBody.tools && requestBody.tools.length > 0) {
+        parts.push(JSON.stringify(requestBody.tools));
+    }
+    if (requestBody.reasoning) {
+        parts.push(JSON.stringify(requestBody.reasoning));
+    }
+    if (requestBody.background) {
+        parts.push('background:true');
+    }
+    if (requestBody.store) {
+        parts.push('store:true');
+    }
+    const concatenated = parts.join('\n');
+    const baseEstimate = modelConfig.tokenizer(concatenated, TOKENIZER_OPTIONS);
+    return baseEstimate + bufferTokens;
+}

package/dist/src/oracle.js

@@ -7,3 +7,4 @@ export { getFileTokenStats, printFileTokenStats } from './oracle/tokenStats.js';
 export { OracleResponseError, OracleTransportError, OracleUserError, FileValidationError, BrowserAutomationError, PromptValidationError, describeTransportError, extractResponseMetadata, asOracleUserError, toTransportError, } from './oracle/errors.js';
 export { createDefaultClientFactory } from './oracle/client.js';
 export { runOracle, extractTextOutput } from './oracle/run.js';
+export { resolveGeminiModelId } from './oracle/gemini.js';

package/dist/src/sessionManager.js

@@ -5,6 +5,7 @@ import { createWriteStream } from 'node:fs';
 const ORACLE_HOME = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
 const SESSIONS_DIR = path.join(ORACLE_HOME, 'sessions');
 const MAX_STATUS_LIMIT = 1000;
+const ZOMBIE_MAX_AGE_MS = 30 * 60 * 1000; // 30 minutes
 const DEFAULT_SLUG = 'session';
 const MAX_SLUG_WORDS = 5;
 const MIN_CUSTOM_SLUG_WORDS = 3;
@@ -67,7 +68,7 @@ async function ensureUniqueSessionId(baseSlug) {
     }
     return candidate;
 }
-export async function initializeSession(options, cwd) {
+export async function initializeSession(options, cwd, notifications) {
     await ensureSessionStorage();
     const baseSlug = createSessionId(options.prompt || DEFAULT_SLUG, options.slug);
     const sessionId = await ensureUniqueSessionId(baseSlug);
@@ -84,6 +85,7 @@ export async function initializeSession(options, cwd) {
         cwd,
         mode,
         browser: browserConfig ? { config: browserConfig } : undefined,
+        notifications,
         options: {
             prompt: options.prompt,
             file: options.file ?? [],
@@ -99,7 +101,11 @@ export async function initializeSession(options, cwd) {
             verbose: options.verbose,
             heartbeatIntervalMs: options.heartbeatIntervalMs,
             browserInlineFiles: options.browserInlineFiles,
+            browserBundleFiles: options.browserBundleFiles,
             background: options.background,
+            search: options.search,
+            baseUrl: options.baseUrl,
+            azure: options.azure,
         },
     };
     await fs.writeFile(metaPath(sessionId), JSON.stringify(metadata, null, 2), 'utf8');
@@ -110,7 +116,8 @@ export async function initializeSession(options, cwd) {
 export async function readSessionMetadata(sessionId) {
     try {
         const raw = await fs.readFile(metaPath(sessionId), 'utf8');
-        return JSON.parse(raw);
+        const parsed = JSON.parse(raw);
+        return await markZombie(parsed, { persist: false }); // transient check; do not touch disk on single read
     }
     catch {
         return null;
@@ -138,8 +145,9 @@ export async function listSessionsMetadata() {
     const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
     const metas = [];
     for (const entry of entries) {
-        const meta = await readSessionMetadata(entry);
+        let meta = await readSessionMetadata(entry);
         if (meta) {
+            meta = await markZombie(meta, { persist: true }); // keep stored metadata consistent with zombie detection
             metas.push(meta);
         }
     }
@@ -164,6 +172,15 @@ export async function readSessionLog(sessionId) {
         return '';
     }
 }
+export async function readSessionRequest(sessionId) {
+    try {
+        const raw = await fs.readFile(requestPath(sessionId), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
 export async function deleteSessionsOlderThan({ hours = 24, includeAll = false, } = {}) {
     await ensureSessionStorage();
     const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
@@ -203,6 +220,7 @@ export async function wait(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export { ORACLE_HOME, SESSIONS_DIR, MAX_STATUS_LIMIT };
+export { ZOMBIE_MAX_AGE_MS };
 export async function getSessionPaths(sessionId) {
     const dir = sessionDir(sessionId);
     const metadata = metaPath(sessionId);
@@ -220,3 +238,32 @@ export async function getSessionPaths(sessionId) {
     }
     return { dir, metadata, log, request };
 }
+async function markZombie(meta, { persist }) {
+    if (!isZombie(meta)) {
+        return meta;
+    }
+    const updated = {
+        ...meta,
+        status: 'error',
+        errorMessage: 'Session marked as zombie (>30m stale)',
+        completedAt: new Date().toISOString(),
+    };
+    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;
+    }
+    const reference = meta.startedAt ?? meta.createdAt;
+    if (!reference) {
+        return false;
+    }
+    const startedMs = Date.parse(reference);
+    if (Number.isNaN(startedMs)) {
+        return false;
+    }
+    return Date.now() - startedMs > ZOMBIE_MAX_AGE_MS;
+}

package/dist/vendor/oracle-notifier/OracleNotifier.app/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleIdentifier</key>
+  <string>com.steipete.oracle.notifier</string>
+  <key>CFBundleName</key>
+  <string>OracleNotifier</string>
+  <key>CFBundleDisplayName</key>
+  <string>Oracle Notifier</string>
+  <key>CFBundleExecutable</key>
+  <string>OracleNotifier</string>
+  <key>CFBundleIconFile</key>
+  <string>OracleIcon</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>LSMinimumSystemVersion</key>
+  <string>13.0</string>
+</dict>
+</plist>