@steipete/oracle 0.8.5 → 0.9.0

package/dist/bin/oracle-cli.js

@@ -47,6 +47,7 @@ import { loadUserConfig } from '../src/config.js';
 import { applyBrowserDefaultsFromConfig } from '../src/cli/browserDefaults.js';
 import { shouldBlockDuplicatePrompt } from '../src/cli/duplicatePromptGuard.js';
 import { resolveRemoteServiceConfig } from '../src/remote/remoteServiceConfig.js';
+import { resolveConfiguredMaxFileSizeBytes } from '../src/cli/fileSize.js';
 const VERSION = getCliVersion();
 const CLI_ENTRYPOINT = fileURLToPath(import.meta.url);
 const LEGACY_FLAG_ALIASES = new Map([
@@ -98,12 +99,14 @@ program.hook('preAction', (thisCommand) => {
 });
 program
     .name('oracle')
-    .description('One-shot GPT-5.2 Pro / GPT-5.2 / GPT-5.1 Codex tool for hard questions that benefit from large file context and server-side search.')
+    .description('One-shot GPT-5.4 Pro / GPT-5.4 / GPT-5.1 Codex tool for hard questions that benefit from large file context and server-side search.')
     .version(VERSION)
     .argument('[prompt]', 'Prompt text (shorthand for --prompt).')
     .option('-p, --prompt <text>', 'User prompt to send to the model.')
     .addOption(new Option('--message <text>', 'Alias for --prompt.').hideHelp())
-    .option('-f, --file <paths...>', 'Files/directories or glob patterns to attach (prefix with !pattern to exclude). Files larger than 1 MB are rejected automatically.', collectPaths, [])
+    .option('--followup <sessionId|responseId>', 'Continue an OpenAI/Azure Responses API run from a stored response id (resp_...) or from a stored oracle session id.')
+    .option('--followup-model <model>', 'When following up a multi-model session, choose which model response to continue from.')
+    .option('-f, --file <paths...>', 'Files/directories or glob patterns to attach (prefix with !pattern to exclude). Oversized files are rejected automatically (default cap: 1 MB; configurable via ORACLE_MAX_FILE_SIZE_BYTES or config.maxFileSizeBytes).', collectPaths, [])
     .addOption(new Option('--include <paths...>', 'Alias for --file.')
     .argParser(collectPaths)
     .default([])
@@ -123,8 +126,8 @@ program
     .addOption(new Option('--copy-markdown', 'Copy the assembled markdown bundle to the clipboard; pair with --render to print it too.').default(false))
     .addOption(new Option('--copy').hideHelp().default(false))
     .option('-s, --slug <words>', 'Custom session slug (3-5 words).')
-    .option('-m, --model <model>', 'Model to target (gpt-5.2-pro default; also supports gpt-5.1-pro alias). Also gpt-5-pro, gpt-5.1, gpt-5.1-codex API-only, gpt-5.2, gpt-5.2-instant, gpt-5.2-pro, gemini-3-pro, claude-4.5-sonnet, claude-4.1-opus, or ChatGPT labels like "5.2 Thinking" for browser runs).', normalizeModelOption)
-    .addOption(new Option('--models <models>', 'Comma-separated API model list to query in parallel (e.g., "gpt-5.2-pro,gemini-3-pro").')
+    .option('-m, --model <model>', 'Model to target (gpt-5.4-pro default). Also gpt-5.4, gpt-5.1-pro, gpt-5-pro, gpt-5.1, gpt-5.1-codex API-only, gpt-5.2, gpt-5.2-instant, gpt-5.2-pro, gemini-3.1-pro API-only, gemini-3-pro, claude-4.5-sonnet, claude-4.1-opus, or ChatGPT labels like "5.2 Thinking" for browser runs).', normalizeModelOption)
+    .addOption(new Option('--models <models>', 'Comma-separated API model list to query in parallel (e.g., "gpt-5.4-pro,gemini-3-pro").')
     .argParser(collectModelList)
     .default([]))
     .addOption(new Option('-e, --engine <mode>', 'Execution engine (api | browser). Browser engine: GPT models automate ChatGPT; Gemini models use a cookie-based client for gemini.google.com. If omitted, oracle picks api when OPENAI_API_KEY is set, otherwise browser.').choices(['api', 'browser']))
@@ -135,7 +138,7 @@ program
     .addOption(new Option('--no-notify', 'Disable desktop notifications.').default(undefined))
     .addOption(new Option('--notify-sound', 'Play a notification sound on completion (default off).').default(undefined))
     .addOption(new Option('--no-notify-sound', 'Disable notification sounds.').default(undefined))
-    .addOption(new Option('--timeout <seconds|auto>', 'Overall timeout before aborting the API call (auto = 60m for gpt-5.2-pro, 120s otherwise).')
+    .addOption(new Option('--timeout <seconds|auto>', 'Overall timeout before aborting the API call (auto = 60m for gpt-5.4-pro, 120s otherwise).')
     .argParser(parseTimeoutOption)
     .default('auto'))
     .addOption(new Option('--background', 'Use Responses API background mode (create + retrieve) for API runs.').default(undefined))
@@ -183,7 +186,14 @@ program
     .addOption(new Option('--chatgpt-url <url>', `Override the ChatGPT web URL (e.g., workspace/folder like https://chatgpt.com/g/.../project; default ${CHATGPT_URL}).`))
     .addOption(new Option('--browser-url <url>', `Alias for --chatgpt-url (default ${CHATGPT_URL}).`).hideHelp())
     .addOption(new Option('--browser-timeout <ms|s|m>', 'Maximum time to wait for an answer (default 1200s / 20m).').hideHelp())
-    .addOption(new Option('--browser-input-timeout <ms|s|m>', 'Maximum time to wait for the prompt textarea (default 30s).').hideHelp())
+    .addOption(new Option('--browser-input-timeout <ms|s|m>', 'Maximum time to wait for the prompt textarea (default 60s).').hideHelp())
+    .addOption(new Option('--browser-recheck-delay <ms|s|m|h>', 'After an assistant timeout, wait this long then revisit the conversation to retry capture.').hideHelp())
+    .addOption(new Option('--browser-recheck-timeout <ms|s|m|h>', 'Time budget for the delayed recheck attempt (default 120s).').hideHelp())
+    .addOption(new Option('--browser-reuse-wait <ms|s|m|h>', 'Wait for a shared Chrome profile to appear before launching a new one (helps parallel runs).').hideHelp())
+    .addOption(new Option('--browser-profile-lock-timeout <ms|s|m|h>', 'Wait for the shared manual-login profile lock before sending (serializes parallel runs).').hideHelp())
+    .addOption(new Option('--browser-auto-reattach-delay <ms|s|m|h>', 'Delay before starting periodic auto-reattach attempts after a timeout.').hideHelp())
+    .addOption(new Option('--browser-auto-reattach-interval <ms|s|m|h>', 'Interval between auto-reattach attempts (0 disables).').hideHelp())
+    .addOption(new Option('--browser-auto-reattach-timeout <ms|s|m|h>', 'Time budget for each auto-reattach attempt (default 120s).').hideHelp())
     .addOption(new Option('--browser-cookie-wait <ms|s|m>', 'Wait before retrying cookie sync when Chrome cookies are empty or locked.').hideHelp())
     .addOption(new Option('--browser-port <port>', 'Use a fixed Chrome DevTools port (helpful on WSL firewalls).')
     .argParser(parseIntOption))
@@ -379,6 +389,17 @@ const statusCommand = program
         showExamples,
     });
 });
+program
+    .command('restart <id>')
+    .description('Re-run a stored session as a new session (clones options).')
+    .addOption(new Option('--wait').default(undefined))
+    .addOption(new Option('--no-wait').default(undefined).hideHelp())
+    .option('--remote-host <host:port>', 'Delegate browser runs to a remote `oracle serve` instance.')
+    .option('--remote-token <token>', 'Access token for the remote `oracle serve` instance.')
+    .action(async (sessionId, _options, cmd) => {
+    const restartOptions = cmd.opts();
+    await restartSession(sessionId, restartOptions);
+});
 function buildRunOptions(options, overrides = {}) {
     if (!options.prompt) {
         throw new Error('Prompt is required.');
@@ -395,8 +416,10 @@ function buildRunOptions(options, overrides = {}) {
         prompt: options.prompt,
         model: options.model,
         models: overrides.models ?? options.models,
+        previousResponseId: overrides.previousResponseId ?? options.previousResponseId,
         effectiveModelId: overrides.effectiveModelId ?? options.effectiveModelId ?? options.model,
         file: overrides.file ?? options.file ?? [],
+        maxFileSizeBytes: overrides.maxFileSizeBytes ?? options.maxFileSizeBytes,
         slug: overrides.slug ?? options.slug,
         filesReport: overrides.filesReport ?? options.filesReport,
         maxInput: overrides.maxInput ?? options.maxInput,
@@ -436,14 +459,141 @@ function resolveHeartbeatIntervalMs(seconds) {
     }
     return Math.round(seconds * 1000);
 }
+function assertFollowupSupported({ engine, model, baseUrl, azureEndpoint, }) {
+    if (engine !== 'api') {
+        throw new Error('--followup requires --engine api.');
+    }
+    if (model.startsWith('gemini') || model.startsWith('claude')) {
+        throw new Error(`--followup is only supported for OpenAI Responses API runs. Model ${model} uses a provider client without previous_response_id support.`);
+    }
+    if (baseUrl && !azureEndpoint) {
+        throw new Error('--followup is only supported for the default OpenAI Responses API or Azure OpenAI Responses. Custom --base-url providers are not supported.');
+    }
+}
+function levenshteinDistance(a, b) {
+    if (a === b)
+        return 0;
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    const previous = new Array(b.length + 1);
+    const current = new Array(b.length + 1);
+    for (let j = 0; j <= b.length; j += 1) {
+        previous[j] = j;
+    }
+    for (let i = 1; i <= a.length; i += 1) {
+        current[0] = i;
+        for (let j = 1; j <= b.length; j += 1) {
+            const substitutionCost = a[i - 1] === b[j - 1] ? 0 : 1;
+            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + substitutionCost);
+        }
+        for (let j = 0; j <= b.length; j += 1) {
+            previous[j] = current[j];
+        }
+    }
+    return previous[b.length];
+}
+function scoreSessionSimilarity(input, candidate) {
+    if (input === candidate)
+        return 1;
+    if (candidate.startsWith(input) || input.startsWith(candidate))
+        return 0.95;
+    if (candidate.includes(input) || input.includes(candidate))
+        return 0.8;
+    const distance = levenshteinDistance(input, candidate);
+    const maxLength = Math.max(input.length, candidate.length);
+    if (maxLength === 0)
+        return 0;
+    return Math.max(0, 1 - distance / maxLength);
+}
+async function suggestFollowupSessionIds(input, limit = 3) {
+    const normalizedInput = input.trim().toLowerCase();
+    if (!normalizedInput)
+        return [];
+    const sessions = await sessionStore.listSessions().catch(() => []);
+    const seen = new Set();
+    const ranked = sessions
+        .map((meta) => meta.id)
+        .filter((id) => typeof id === 'string' && id.length > 0)
+        .filter((id) => {
+        if (seen.has(id))
+            return false;
+        seen.add(id);
+        return true;
+    })
+        .map((id) => ({ id, score: scoreSessionSimilarity(normalizedInput, id.toLowerCase()) }))
+        .filter((entry) => entry.score >= 0.45)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    return ranked.map((entry) => entry.id);
+}
+async function resolveFollowupReference(value, followupModel) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error('--followup requires a session id or response id.');
+    }
+    if (trimmed.startsWith('resp_')) {
+        return { responseId: trimmed };
+    }
+    // Treat as oracle session id (slug).
+    const meta = await sessionStore.readSession(trimmed);
+    if (!meta) {
+        const suggestions = await suggestFollowupSessionIds(trimmed);
+        const suggestionText = suggestions.length > 0 ? ` Did you mean: ${suggestions.map((id) => `"${id}"`).join(', ')}?` : '';
+        throw new Error(`No session found with ID ${trimmed}.${suggestionText} Run "oracle status --hours 72 --limit 20" to list recent sessions.`);
+    }
+    const fromMetadata = extractResponseIdFromSession(meta, followupModel);
+    if (fromMetadata) {
+        return { responseId: fromMetadata, sessionId: meta.id };
+    }
+    // Fallback: scrape the log for a response id (covers older sessions / edge cases).
+    const logText = await sessionStore.readLog(trimmed).catch(() => '');
+    const matches = logText.match(/resp_[A-Za-z0-9]+/g) ?? [];
+    const last = matches.length > 0 ? matches[matches.length - 1] : null;
+    if (last) {
+        return { responseId: last, sessionId: meta.id };
+    }
+    throw new Error(`Session ${trimmed} does not contain a stored response id. Ensure the original run produced a Responses API response id (background/store helps).`);
+}
+function extractResponseIdFromSession(meta, followupModel) {
+    // Single-model sessions store response metadata at the session root.
+    const rootResponse = meta.response ?? null;
+    const rootResponseId = rootResponse?.responseId ?? rootResponse?.id;
+    if (rootResponseId && rootResponseId.startsWith('resp_')) {
+        return rootResponseId;
+    }
+    const runs = Array.isArray(meta.models) ? meta.models : [];
+    if (runs.length === 0) {
+        return null;
+    }
+    const pickRun = () => {
+        if (followupModel) {
+            return runs.find((r) => r.model === followupModel) ?? null;
+        }
+        return runs.length === 1 ? runs[0] : null;
+    };
+    const chosen = pickRun();
+    if (!chosen) {
+        const models = runs.map((r) => r.model).join(', ');
+        throw new Error(followupModel
+            ? `Session ${meta.id} has no model named ${followupModel}. Available: ${models}`
+            : `Session ${meta.id} has multiple model runs. Re-run with --followup-model. Available: ${models}`);
+    }
+    const runResponse = chosen.response ?? null;
+    const runResponseId = runResponse?.responseId ?? runResponse?.id;
+    return runResponseId && runResponseId.startsWith('resp_') ? runResponseId : null;
+}
 function buildRunOptionsFromMetadata(metadata) {
     const stored = metadata.options ?? {};
     return {
         prompt: stored.prompt ?? '',
         model: stored.model ?? DEFAULT_MODEL,
         models: stored.models,
+        previousResponseId: stored.previousResponseId,
         effectiveModelId: stored.effectiveModelId ?? stored.model,
         file: stored.file ?? [],
+        maxFileSizeBytes: stored.maxFileSizeBytes,
         slug: stored.slug,
         filesReport: stored.filesReport,
         maxInput: stored.maxInput,
@@ -646,6 +796,14 @@ async function runRootCommand(options) {
         throw new Error('--remote-host does not support --models yet. Use API engine locally instead.');
     }
     const resolvedModel = normalizedMultiModels[0] ?? (isGemini ? resolveApiModel(cliModelArg) : resolvedModelCandidate);
+    const includesGeminiApiOnly = (normalizedMultiModels.length > 0 ? normalizedMultiModels : [resolvedModel]).some((model) => model === 'gemini-3.1-pro');
+    if ((userForcedBrowser || userConfig.engine === 'browser') && includesGeminiApiOnly) {
+        throw new Error('gemini-3.1-pro is API-only today. Use --engine api or switch to gemini-3-pro for Gemini web.');
+    }
+    if (engine === 'browser' && includesGeminiApiOnly) {
+        console.log(chalk.dim('gemini-3.1-pro is API-only today; switching to API.'));
+        engine = 'api';
+    }
     const effectiveModelId = resolvedModel.startsWith('gemini')
         ? resolveGeminiModelId(resolvedModel)
         : isKnownModel(resolvedModel)
@@ -654,6 +812,7 @@ async function runRootCommand(options) {
     const resolvedBaseUrl = normalizeBaseUrl(options.baseUrl ?? (isClaude ? process.env.ANTHROPIC_BASE_URL : process.env.OPENAI_BASE_URL));
     const { models: _rawModels, ...optionsWithoutModels } = options;
     const resolvedOptions = { ...optionsWithoutModels, model: resolvedModel };
+    resolvedOptions.maxFileSizeBytes = resolveConfiguredMaxFileSizeBytes(userConfig, process.env);
     if (normalizedMultiModels.length > 0) {
         resolvedOptions.models = normalizedMultiModels;
     }
@@ -665,11 +824,10 @@ async function runRootCommand(options) {
     // - otherwise block for fast models (gpt-5.1, browser) and detach by default for pro API runs
     let waitPreference = resolveWaitFlag({
         waitFlag: options.wait,
-        noWaitFlag: options.noWait,
         model: resolvedModel,
         engine,
     });
-    if (remoteHost && !waitPreference) {
+    if (remoteHost && waitPreference === false) {
         console.log(chalk.dim('Remote browser runs require --wait; ignoring --no-wait.'));
         waitPreference = true;
     }
@@ -729,6 +887,21 @@ async function runRootCommand(options) {
             options.prompt = `${options.prompt.trim()}\n${userConfig.promptSuffix}`;
         }
         resolvedOptions.prompt = options.prompt;
+        if (options.followup) {
+            assertFollowupSupported({
+                engine,
+                model: resolvedModel,
+                baseUrl: resolvedBaseUrl,
+                azureEndpoint: resolvedOptions.azure?.endpoint,
+            });
+            if (normalizedMultiModels.length > 0) {
+                throw new Error('--followup cannot be combined with --models.');
+            }
+            const followup = await resolveFollowupReference(options.followup, options.followupModel);
+            resolvedOptions.previousResponseId = followup.responseId;
+            resolvedOptions.followupSessionId = followup.sessionId;
+            resolvedOptions.followupModel = options.followupModel;
+        }
         const runOptions = buildRunOptions(resolvedOptions, { preview: true, previewMode, baseUrl: resolvedBaseUrl });
         if (engine === 'browser') {
             await runBrowserPreview({
@@ -767,6 +940,21 @@ async function runRootCommand(options) {
         options.prompt = `${options.prompt.trim()}\n${userConfig.promptSuffix}`;
     }
     resolvedOptions.prompt = options.prompt;
+    if (options.followup) {
+        assertFollowupSupported({
+            engine,
+            model: resolvedModel,
+            baseUrl: resolvedBaseUrl,
+            azureEndpoint: resolvedOptions.azure?.endpoint,
+        });
+        if (normalizedMultiModels.length > 0) {
+            throw new Error('--followup cannot be combined with --models.');
+        }
+        const followup = await resolveFollowupReference(options.followup, options.followupModel);
+        resolvedOptions.previousResponseId = followup.responseId;
+        resolvedOptions.followupSessionId = followup.sessionId;
+        resolvedOptions.followupModel = options.followupModel;
+    }
     const duplicateBlocked = await shouldBlockDuplicatePrompt({
         prompt: resolvedOptions.prompt,
         force: options.force,
@@ -781,7 +969,10 @@ async function runRootCommand(options) {
         const isBrowserMode = engine === 'browser' || userForcedBrowser;
         const filesToValidate = isBrowserMode ? options.file.filter((f) => !isMediaFile(f)) : options.file;
         if (filesToValidate.length > 0) {
-            await readFiles(filesToValidate, { cwd: process.cwd() });
+            await readFiles(filesToValidate, {
+                cwd: process.cwd(),
+                maxFileSizeBytes: resolvedOptions.maxFileSizeBytes,
+            });
         }
     }
     const getSource = (key) => program.getOptionValueSource?.(key) ?? undefined;
@@ -857,6 +1048,15 @@ async function runRootCommand(options) {
         ...baseRunOptions,
         mode: sessionMode,
         browserConfig,
+        followupSessionId: resolvedOptions.followupSessionId,
+        followupModel: resolvedOptions.followupModel,
+        waitPreference,
+        youtube: options.youtube,
+        generateImage: options.generateImage,
+        editImage: options.editImage,
+        outputPath: options.output,
+        aspectRatio: options.aspect,
+        geminiShowThoughts: options.geminiShowThoughts,
     }, process.cwd(), notifications);
     const liveRunOptions = {
         ...baseRunOptions,
@@ -898,7 +1098,7 @@ async function runRootCommand(options) {
         await attachSession(sessionMeta.id, { suppressMetadata: true });
     }
 }
-async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfig, showReattachHint = true, notifications, userConfig, suppressSummary = false, browserDeps) {
+async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfig, showReattachHint = true, notifications, userConfig, suppressSummary = false, browserDeps, cwd = process.cwd()) {
     const { logLine, writeChunk, stream } = sessionStore.createLogWriter(sessionMeta.id);
     let headerAugmented = false;
     const combinedLog = (message = '') => {
@@ -927,7 +1127,7 @@ async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfi
             runOptions,
             mode,
             browserConfig,
-            cwd: process.cwd(),
+            cwd,
             log: combinedLog,
             write: combinedWrite,
             version: VERSION,
@@ -970,6 +1170,145 @@ async function launchDetachedSession(sessionId) {
         }
     });
 }
+async function restartSession(sessionId, options) {
+    const metadata = await sessionStore.readSession(sessionId);
+    if (!metadata) {
+        console.error(chalk.red(`No session found with ID ${sessionId}`));
+        process.exitCode = 1;
+        return;
+    }
+    const runOptions = buildRunOptionsFromMetadata(metadata);
+    if (!runOptions.prompt) {
+        console.error(chalk.red(`Session ${sessionId} has no stored prompt; cannot restart.`));
+        process.exitCode = 1;
+        return;
+    }
+    const sessionMode = getSessionMode(metadata);
+    const engine = sessionMode === 'browser' ? 'browser' : 'api';
+    const browserConfig = getBrowserConfigFromMetadata(metadata);
+    if (sessionMode === 'browser' && !browserConfig) {
+        console.error(chalk.red(`Session ${sessionId} is missing browser config; cannot restart.`));
+        process.exitCode = 1;
+        return;
+    }
+    const userConfig = (await loadUserConfig()).config;
+    const cwd = metadata.cwd ?? process.cwd();
+    const storedOptions = metadata.options ?? {};
+    if (runOptions.file && runOptions.file.length > 0) {
+        const isBrowserMode = engine === 'browser';
+        const filesToValidate = isBrowserMode ? runOptions.file.filter((f) => !isMediaFile(f)) : runOptions.file;
+        if (filesToValidate.length > 0) {
+            await readFiles(filesToValidate, {
+                cwd,
+                maxFileSizeBytes: runOptions.maxFileSizeBytes,
+            });
+        }
+    }
+    enforceBrowserSearchFlag(runOptions, sessionMode, console.log);
+    let waitPreference = resolveRestartWaitPreference({
+        waitFlag: options.wait,
+        storedPreference: storedOptions.waitPreference,
+        model: runOptions.model,
+        engine,
+    });
+    const remoteConfig = resolveRemoteServiceConfig({
+        cliHost: options.remoteHost,
+        cliToken: options.remoteToken,
+        userConfig,
+        env: process.env,
+    });
+    const remoteHost = remoteConfig.host;
+    const remoteToken = remoteConfig.token;
+    if (remoteHost && engine !== 'browser') {
+        throw new Error('--remote-host requires a browser session.');
+    }
+    if (remoteHost) {
+        console.log(chalk.dim(`Remote browser host detected: ${remoteHost}`));
+    }
+    if (remoteHost && waitPreference === false) {
+        console.log(chalk.dim('Remote browser runs require --wait; ignoring --no-wait.'));
+        waitPreference = true;
+    }
+    let browserDeps;
+    if (browserConfig && remoteHost) {
+        browserDeps = {
+            executeBrowser: createRemoteBrowserExecutor({ host: remoteHost, token: remoteToken }),
+        };
+        console.log(chalk.dim(`Routing browser automation to remote host ${remoteHost}`));
+    }
+    else if (browserConfig && runOptions.model.startsWith('gemini')) {
+        browserDeps = {
+            executeBrowser: createGeminiWebExecutor({
+                youtube: storedOptions.youtube,
+                generateImage: storedOptions.generateImage,
+                editImage: storedOptions.editImage,
+                outputPath: storedOptions.outputPath,
+                aspectRatio: storedOptions.aspectRatio,
+                showThoughts: storedOptions.geminiShowThoughts,
+            }),
+        };
+        console.log(chalk.dim('Using Gemini web client for browser automation'));
+        if (browserConfig.modelStrategy && browserConfig.modelStrategy !== 'select') {
+            console.log(chalk.dim('Browser model strategy is ignored for Gemini web runs.'));
+        }
+    }
+    const remoteExecutionActive = Boolean(browserDeps);
+    await sessionStore.ensureStorage();
+    const notifications = deriveNotificationSettingsFromMetadata(metadata, process.env, userConfig.notify);
+    const sessionMeta = await sessionStore.createSession({
+        ...runOptions,
+        mode: sessionMode,
+        browserConfig,
+        followupSessionId: storedOptions.followupSessionId,
+        followupModel: storedOptions.followupModel,
+        waitPreference,
+        youtube: storedOptions.youtube,
+        generateImage: storedOptions.generateImage,
+        editImage: storedOptions.editImage,
+        outputPath: storedOptions.outputPath,
+        aspectRatio: storedOptions.aspectRatio,
+        geminiShowThoughts: storedOptions.geminiShowThoughts,
+    }, cwd, notifications, sessionId);
+    const liveRunOptions = {
+        ...runOptions,
+        sessionId: sessionMeta.id,
+        effectiveModelId: resolveEffectiveModelIdForRun(runOptions.model, runOptions.effectiveModelId),
+    };
+    const disableDetachEnv = process.env.ORACLE_NO_DETACH === '1';
+    const detachAllowed = remoteExecutionActive
+        ? false
+        : shouldDetachSession({
+            engine,
+            model: runOptions.model,
+            waitPreference,
+            disableDetachEnv,
+        });
+    const detached = !detachAllowed
+        ? false
+        : await launchDetachedSession(sessionMeta.id).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log(chalk.yellow(`Unable to detach session runner (${message}). Running inline...`));
+            return false;
+        });
+    if (!waitPreference) {
+        if (!detached) {
+            console.log(chalk.red('Unable to start in background; use --wait to run inline.'));
+            process.exitCode = 1;
+            return;
+        }
+        console.log(chalk.blue(`Session running in background. Reattach via: oracle session ${sessionMeta.id}`));
+        console.log(chalk.dim('Pro runs can take up to 60 minutes (usually 10-15). Add --wait to stay attached.'));
+        return;
+    }
+    if (detached === false) {
+        await runInteractiveSession(sessionMeta, liveRunOptions, sessionMode, browserConfig, false, notifications, userConfig, true, browserDeps, cwd);
+        return;
+    }
+    if (detached) {
+        console.log(chalk.blue(`Reattach via: oracle session ${sessionMeta.id}`));
+        await attachSession(sessionMeta.id, { suppressMetadata: true });
+    }
+}
 async function executeSession(sessionId) {
     const metadata = await sessionStore.readSession(sessionId);
     if (!metadata) {
@@ -1020,6 +1359,13 @@ function printDebugHelp(cliName) {
         ['--browser-url <url>', 'Alias for --chatgpt-url.'],
         ['--browser-timeout <ms|s|m>', 'Cap total wait time for the assistant response.'],
         ['--browser-input-timeout <ms|s|m>', 'Cap how long we wait for the composer textarea.'],
+        ['--browser-recheck-delay <ms|s|m|h>', 'After timeout, wait then revisit the conversation to retry capture.'],
+        ['--browser-recheck-timeout <ms|s|m|h>', 'Time budget for the delayed recheck attempt.'],
+        ['--browser-reuse-wait <ms|s|m|h>', 'Wait for a shared Chrome profile before launching (parallel runs).'],
+        ['--browser-profile-lock-timeout <ms|s|m|h>', 'Wait for the manual-login profile lock before sending.'],
+        ['--browser-auto-reattach-delay <ms|s|m|h>', 'Delay before periodic auto-reattach attempts after a timeout.'],
+        ['--browser-auto-reattach-interval <ms|s|m|h>', 'Interval between auto-reattach attempts (0 disables).'],
+        ['--browser-auto-reattach-timeout <ms|s|m|h>', 'Time budget for each auto-reattach attempt.'],
         ['--browser-cookie-wait <ms|s|m>', 'Wait before retrying cookie sync when Chrome cookies are empty or locked.'],
         ['--browser-no-cookie-sync', 'Skip copying cookies from your main profile.'],
         ['--browser-manual-login', 'Skip cookie copy; reuse a persistent automation profile and log in manually.'],
@@ -1037,13 +1383,30 @@ function printDebugOptionGroup(entries) {
         console.log(`  ${label}${description}`);
     });
 }
-function resolveWaitFlag({ waitFlag, noWaitFlag, model, engine, }) {
+function resolveWaitFlag({ waitFlag, model, engine, }) {
     if (waitFlag === true)
         return true;
-    if (noWaitFlag === true)
+    if (waitFlag === false)
         return false;
     return defaultWaitPreference(model, engine);
 }
+function resolveRestartWaitPreference({ waitFlag, storedPreference, model, engine, }) {
+    if (waitFlag === true)
+        return true;
+    if (waitFlag === false)
+        return false;
+    if (typeof storedPreference === 'boolean')
+        return storedPreference;
+    return defaultWaitPreference(model, engine);
+}
+function resolveEffectiveModelIdForRun(model, stored) {
+    if (stored)
+        return stored;
+    if (model.startsWith('gemini')) {
+        return resolveGeminiModelId(model);
+    }
+    return isKnownModel(model) ? MODEL_CONFIGS[model].apiModel ?? model : model;
+}
 program.action(async function () {
     const options = this.optsWithGlobals();
     await runRootCommand(options);