@steipete/oracle 0.8.4 → 0.8.6

package/README.md

@@ -42,6 +42,7 @@ npx -y @steipete/oracle --engine browser --model gemini-3-pro --prompt "a cute r
 # Sessions (list and replay)
 npx -y @steipete/oracle status --hours 72
 npx -y @steipete/oracle session <id> --render
+npx -y @steipete/oracle restart <id>
 
 # TUI (interactive, only for humans)
 npx -y @steipete/oracle tui
@@ -100,6 +101,24 @@ npx -y @steipete/oracle oracle-mcp
 - Sessions you can replay (`oracle status`, `oracle session <id> --render`).
 - Session logs and bundles live in `~/.oracle/sessions` (override with `ORACLE_HOME_DIR`).
 
+## Browser auto-reattach (long Pro runs)
+
+When browser runs time out (common with long GPT‑5.x Pro responses), Oracle can keep polling the existing ChatGPT tab and capture the final answer without manual `oracle session <id>` commands.
+
+Enable auto-reattach by setting a non-zero interval:
+- `--browser-auto-reattach-delay` — wait before the first retry (e.g. `30s`)
+- `--browser-auto-reattach-interval` — how often to retry (e.g. `2m`)
+- `--browser-auto-reattach-timeout` — per-attempt budget (default `2m`)
+
+```bash
+oracle --engine browser \
+  --browser-timeout 6m \
+  --browser-auto-reattach-delay 30s \
+  --browser-auto-reattach-interval 2m \
+  --browser-auto-reattach-timeout 2m \
+  -p "Run the long UI audit" --file "src/**/*.ts"
+```
+
 ## Flags you’ll actually use
 
 | Flag | Purpose |
@@ -117,8 +136,16 @@ npx -y @steipete/oracle oracle-mcp
 | `--browser-port <port>` | Pin the Chrome DevTools port (WSL/Windows firewall helper). |
 | `--browser-inline-cookies[(-file)] <payload|path>` | Supply cookies without Chrome/Keychain (browser). |
 | `--browser-timeout`, `--browser-input-timeout` | Control overall/browser input timeouts (supports h/m/s/ms). |
+| `--browser-recheck-delay`, `--browser-recheck-timeout` | Delayed recheck for long Pro runs: wait then retry capture after timeout (supports h/m/s/ms). |
+| `--browser-reuse-wait` | Wait for a shared Chrome profile before launching (parallel browser runs). |
+| `--browser-profile-lock-timeout` | Wait for the shared manual-login profile lock before sending (serializes parallel runs). |
 | `--render`, `--copy` | Print and/or copy the assembled markdown bundle. |
 | `--wait` | Block for background API runs (e.g., GPT‑5.1 Pro) instead of detaching. |
+| `--timeout <seconds\|auto>` | Overall API deadline (auto = 60m for pro, 120s otherwise). |
+| `--background`, `--no-background` | Force Responses API background mode (create + retrieve) for API runs. |
+| `--http-timeout <ms\|s\|m\|h>` | HTTP client timeout (default 20m). |
+| `--zombie-timeout <ms\|s\|m\|h>` | Override stale-session cutoff used by `oracle status`. |
+| `--zombie-last-activity` | Use last log activity to detect stale sessions. |
 | `--write-output <path>` | Save only the final answer (multi-model adds `.<model>`). |
 | `--files-report` | Print per-file token usage. |
 | `--dry-run [summary\|json\|full]` | Preview without sending. |
@@ -149,7 +176,8 @@ Advanced flags
 
 | Area | Flags |
 | --- | --- |
-| Browser | `--browser-manual-login`, `--browser-thinking-time`, `--browser-timeout`, `--browser-input-timeout`, `--browser-cookie-wait`, `--browser-inline-cookies[(-file)]`, `--browser-attachments`, `--browser-inline-files`, `--browser-bundle-files`, `--browser-keep-browser`, `--browser-headless`, `--browser-hide-window`, `--browser-no-cookie-sync`, `--browser-allow-cookie-errors`, `--browser-chrome-path`, `--browser-cookie-path`, `--chatgpt-url` |
+| Browser | `--browser-manual-login`, `--browser-thinking-time`, `--browser-timeout`, `--browser-input-timeout`, `--browser-recheck-delay`, `--browser-recheck-timeout`, `--browser-reuse-wait`, `--browser-profile-lock-timeout`, `--browser-auto-reattach-delay`, `--browser-auto-reattach-interval`, `--browser-auto-reattach-timeout`, `--browser-cookie-wait`, `--browser-inline-cookies[(-file)]`, `--browser-attachments`, `--browser-inline-files`, `--browser-bundle-files`, `--browser-keep-browser`, `--browser-headless`, `--browser-hide-window`, `--browser-no-cookie-sync`, `--browser-allow-cookie-errors`, `--browser-chrome-path`, `--browser-cookie-path`, `--chatgpt-url` |
+| Run control | `--background`, `--no-background`, `--http-timeout`, `--zombie-timeout`, `--zombie-last-activity` |
 | Azure/OpenAI | `--azure-endpoint`, `--azure-deployment`, `--azure-api-version`, `--base-url` |
 
 Remote browser example
@@ -171,6 +199,7 @@ oracle status --clear --hours 168
 ```
 
 ## More docs
+- Bridge (Windows host → Linux client): [docs/bridge.md](docs/bridge.md)
 - Browser mode & forks: [docs/browser-mode.md](docs/browser-mode.md) (includes `oracle serve` remote service), [docs/chromium-forks.md](docs/chromium-forks.md), [docs/linux.md](docs/linux.md)
 - MCP: [docs/mcp.md](docs/mcp.md)
 - OpenAI/Azure/OpenRouter endpoints: [docs/openai-endpoints.md](docs/openai-endpoints.md), [docs/openrouter.md](docs/openrouter.md)

package/dist/bin/oracle-cli.js

@@ -20,7 +20,7 @@ import { CHATGPT_URL } from '../src/browserMode.js';
 import { createRemoteBrowserExecutor } from '../src/remote/client.js';
 import { createGeminiWebExecutor } from '../src/gemini-web/index.js';
 import { applyHelpStyling } from '../src/cli/help.js';
-import { collectPaths, collectModelList, parseFloatOption, parseIntOption, parseSearchOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, normalizeBaseUrl, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, parseTimeoutOption, mergePathLikeOptions, dedupePathInputs, } from '../src/cli/options.js';
+import { collectPaths, collectModelList, parseFloatOption, parseIntOption, parseSearchOption, usesDefaultStatusFilters, resolvePreviewMode, normalizeModelOption, normalizeBaseUrl, resolveApiModel, inferModelFromLabel, parseHeartbeatOption, parseTimeoutOption, parseDurationOption, mergePathLikeOptions, dedupePathInputs, } from '../src/cli/options.js';
 import { copyToClipboard } from '../src/cli/clipboard.js';
 import { buildMarkdownBundle } from '../src/cli/markdownBundle.js';
 import { shouldDetachSession } from '../src/cli/detach.js';
@@ -46,9 +46,20 @@ import { resolveNotificationSettings, deriveNotificationSettingsFromMetadata, }
 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';
 const VERSION = getCliVersion();
 const CLI_ENTRYPOINT = fileURLToPath(import.meta.url);
-const rawCliArgs = process.argv.slice(2);
+const LEGACY_FLAG_ALIASES = new Map([
+    ['--[no-]notify', '--notify'],
+    ['--[no-]notify-sound', '--notify-sound'],
+    ['--[no-]background', '--background'],
+]);
+const normalizedArgv = process.argv.map((arg, index) => {
+    if (index < 2)
+        return arg;
+    return LEGACY_FLAG_ALIASES.get(arg) ?? arg;
+});
+const rawCliArgs = normalizedArgv.slice(2);
 const userCliArgs = rawCliArgs[0] === CLI_ENTRYPOINT ? rawCliArgs.slice(1) : rawCliArgs;
 const isTty = process.stdout.isTTY;
 const program = new Command();
@@ -120,12 +131,22 @@ program
     .addOption(new Option('--mode <mode>', 'Alias for --engine (api | browser).').choices(['api', 'browser']).hideHelp())
     .option('--files-report', 'Show token usage per attached file (also prints automatically when files exceed the token budget).', false)
     .option('-v, --verbose', 'Enable verbose logging for all operations.', false)
-    .addOption(new Option('--[no-]notify', 'Desktop notification when a session finishes (default on unless CI/SSH).')
-    .default(undefined))
-    .addOption(new Option('--[no-]notify-sound', 'Play a notification sound on completion (default off).').default(undefined))
+    .addOption(new Option('--notify', 'Desktop notification when a session finishes (default on unless CI/SSH).').default(undefined))
+    .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).')
     .argParser(parseTimeoutOption)
     .default('auto'))
+    .addOption(new Option('--background', 'Use Responses API background mode (create + retrieve) for API runs.').default(undefined))
+    .addOption(new Option('--no-background', 'Disable Responses API background mode.').default(undefined))
+    .addOption(new Option('--http-timeout <ms|s|m|h>', 'HTTP client timeout for API requests (default 20m).')
+    .argParser((value) => parseDurationOption(value, 'HTTP timeout'))
+    .default(undefined))
+    .addOption(new Option('--zombie-timeout <ms|s|m|h>', 'Override stale-session cutoff used by `oracle status` (default 60m).')
+    .argParser((value) => parseDurationOption(value, 'Zombie timeout'))
+    .default(undefined))
+    .option('--zombie-last-activity', 'Base stale-session detection on last log activity instead of start time.', false)
     .addOption(new Option('--preview [mode]', '(alias) Preview the request without calling the model (summary | json | full). Deprecated: use --dry-run instead.')
     .hideHelp()
     .choices(['summary', 'json', 'full'])
@@ -162,7 +183,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))
@@ -219,14 +247,73 @@ program
     .option('--host <address>', 'Interface to bind (default 0.0.0.0).')
     .option('--port <number>', 'Port to listen on (default random).', parseIntOption)
     .option('--token <value>', 'Access token clients must provide (random if omitted).')
+    .option('--manual-login', 'Use a dedicated Chrome profile for manual login (recommended when cookie sync is unavailable).', false)
+    .option('--manual-login-profile-dir <path>', 'Chrome profile directory for manual login (default ~/.oracle/browser-profile).')
     .action(async (commandOptions) => {
     const { serveRemote } = await import('../src/remote/server.js');
     await serveRemote({
         host: commandOptions.host,
         port: commandOptions.port,
         token: commandOptions.token,
+        manualLoginDefault: commandOptions.manualLogin,
+        manualLoginProfileDir: commandOptions.manualLoginProfileDir,
     });
 });
+const bridgeCommand = program.command('bridge').description('Bridge a Windows-hosted ChatGPT session to Linux clients.');
+bridgeCommand
+    .command('host')
+    .description('Start a secure oracle serve host (optionally with an SSH reverse tunnel).')
+    .option('--bind <host:port>', 'Local bind address for the host service (default 127.0.0.1:9473).')
+    .option('--token <token|auto>', 'Service access token (default auto).', 'auto')
+    .option('--write-connection <path>', 'Write a connection artifact JSON (default ~/.oracle/bridge-connection.json).')
+    .option('--ssh <user@host>', 'Maintain an SSH reverse tunnel to the Linux host (ssh -N -R ...).')
+    .option('--ssh-remote-port <port>', 'Remote port to bind on the Linux host (default matches --bind port).', parseIntOption)
+    .option('--ssh-identity <path>', 'SSH identity file (ssh -i).')
+    .option('--ssh-extra-args <args>', 'Extra args passed to ssh (quoted string).')
+    .option('--background', 'Run the host in the background and write pid/log files.', false)
+    .option('--foreground', 'Run the host in the foreground (default).', false)
+    .option('--print', 'Print the client connection string (includes token).', false)
+    .option('--print-token', 'Print only the token.', false)
+    .action(async (commandOptions) => {
+    const { runBridgeHost } = await import('../src/cli/bridge/host.js');
+    await runBridgeHost(commandOptions);
+});
+bridgeCommand
+    .command('client')
+    .description('Configure this machine to use a remote oracle serve host.')
+    .requiredOption('--connect <connection>', 'Connection string or path to bridge-connection.json.')
+    .option('--config <path>', 'Override the oracle config file location (default ~/.oracle/config.json).')
+    .option('--no-write-config', 'Do not write ~/.oracle/config.json (just validate).')
+    .option('--no-test', 'Skip remote /health check.')
+    .option('--print-env', 'Print env var exports (includes token).', false)
+    .action(async (commandOptions) => {
+    const { runBridgeClient } = await import('../src/cli/bridge/client.js');
+    await runBridgeClient(commandOptions);
+});
+bridgeCommand
+    .command('doctor')
+    .description('Diagnose bridge connectivity and browser engine prerequisites.')
+    .option('--verbose', 'Show extra diagnostics.', false)
+    .action(async (commandOptions) => {
+    const { runBridgeDoctor } = await import('../src/cli/bridge/doctor.js');
+    await runBridgeDoctor(commandOptions);
+});
+bridgeCommand
+    .command('codex-config')
+    .description('Print a Codex CLI MCP server config snippet for oracle-mcp.')
+    .option('--print-token', 'Include ORACLE_REMOTE_TOKEN in the snippet.', false)
+    .action(async (commandOptions) => {
+    const { runBridgeCodexConfig } = await import('../src/cli/bridge/codexConfig.js');
+    await runBridgeCodexConfig(commandOptions);
+});
+bridgeCommand
+    .command('claude-config')
+    .description('Print a Claude Code MCP config snippet (.mcp.json) for oracle-mcp.')
+    .option('--print-token', 'Include ORACLE_REMOTE_TOKEN in the snippet.', false)
+    .action(async (commandOptions) => {
+    const { runBridgeClaudeConfig } = await import('../src/cli/bridge/claudeConfig.js');
+    await runBridgeClaudeConfig(commandOptions);
+});
 program
     .command('tui')
     .description('Launch the interactive terminal UI for humans (no automation).')
@@ -299,6 +386,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.');
@@ -323,6 +421,9 @@ function buildRunOptions(options, overrides = {}) {
         maxOutput: overrides.maxOutput ?? options.maxOutput,
         system: overrides.system ?? options.system,
         timeoutSeconds: overrides.timeoutSeconds ?? options.timeout,
+        httpTimeoutMs: overrides.httpTimeoutMs ?? options.httpTimeout,
+        zombieTimeoutMs: overrides.zombieTimeoutMs ?? options.zombieTimeout,
+        zombieUseLastActivity: overrides.zombieUseLastActivity ?? options.zombieLastActivity,
         silent: overrides.silent ?? options.silent,
         search: overrides.search ?? options.search,
         preview: overrides.preview ?? undefined,
@@ -373,6 +474,10 @@ function buildRunOptionsFromMetadata(metadata) {
         apiKey: undefined,
         baseUrl: normalizeBaseUrl(stored.baseUrl),
         azure: stored.azure,
+        timeoutSeconds: stored.timeoutSeconds,
+        httpTimeoutMs: stored.httpTimeoutMs,
+        zombieTimeoutMs: stored.zombieTimeoutMs,
+        zombieUseLastActivity: stored.zombieUseLastActivity,
         sessionId: metadata.id,
         verbose: stored.verbose,
         heartbeatIntervalMs: stored.heartbeatIntervalMs,
@@ -446,8 +551,14 @@ async function runRootCommand(options) {
         }
     };
     applyRetentionOption();
-    const remoteHost = options.remoteHost ?? userConfig.remoteHost ?? userConfig.remote?.host ?? process.env.ORACLE_REMOTE_HOST;
-    const remoteToken = options.remoteToken ?? userConfig.remoteToken ?? userConfig.remote?.token ?? process.env.ORACLE_REMOTE_TOKEN;
+    const remoteConfig = resolveRemoteServiceConfig({
+        cliHost: options.remoteHost,
+        cliToken: options.remoteToken,
+        userConfig,
+        env: process.env,
+    });
+    const remoteHost = remoteConfig.host;
+    const remoteToken = remoteConfig.token;
     if (remoteHost) {
         console.log(chalk.dim(`Remote browser host detected: ${remoteHost}`));
     }
@@ -572,11 +683,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;
     }
@@ -752,7 +862,7 @@ async function runRootCommand(options) {
     const baseRunOptions = buildRunOptions(resolvedOptions, {
         preview: false,
         previewMode: undefined,
-        background: userConfig.background ?? resolvedOptions.background,
+        background: resolvedOptions.background ?? userConfig.background,
         baseUrl: resolvedBaseUrl,
     });
     enforceBrowserSearchFlag(baseRunOptions, sessionMode, console.log);
@@ -764,6 +874,13 @@ async function runRootCommand(options) {
         ...baseRunOptions,
         mode: sessionMode,
         browserConfig,
+        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,
@@ -805,7 +922,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 = '') => {
@@ -834,7 +951,7 @@ async function runInteractiveSession(sessionMeta, runOptions, mode, browserConfi
             runOptions,
             mode,
             browserConfig,
-            cwd: process.cwd(),
+            cwd,
             log: combinedLog,
             write: combinedWrite,
             version: VERSION,
@@ -877,6 +994,140 @@ 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 });
+        }
+    }
+    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,
+        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) {
@@ -927,6 +1178,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.'],
@@ -944,19 +1202,36 @@ 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);
 });
 async function main() {
-    const parsePromise = program.parseAsync(process.argv);
+    const parsePromise = program.parseAsync(normalizedArgv);
     const sigintPromise = once(process, 'SIGINT').then(() => 'sigint');
     const result = await Promise.race([parsePromise.then(() => 'parsed'), sigintPromise]);
     if (result === 'sigint') {

package/dist/scripts/debug/extract-chatgpt-response.js

@@ -0,0 +1,53 @@
+import puppeteer from 'puppeteer-core';
+const port = parseInt(process.argv[2] || '52990', 10);
+async function main() {
+    const browser = await puppeteer.connect({
+        browserURL: `http://127.0.0.1:${port}`,
+        defaultViewport: null,
+    });
+    const pages = await browser.pages();
+    let targetPage = null;
+    for (const page of pages) {
+        const url = page.url();
+        if (url.includes('chatgpt.com/c/')) {
+            targetPage = page;
+            break;
+        }
+    }
+    if (!targetPage) {
+        console.error('ChatGPT conversation page not found');
+        process.exit(1);
+    }
+    console.error('Found page:', await targetPage.url());
+    // Extract the last assistant message
+    const content = (await targetPage.evaluate(() => {
+        // Try multiple selectors for ChatGPT's assistant messages
+        const selectors = [
+            '[data-message-author-role="assistant"] .markdown',
+            '[data-message-author-role="assistant"]',
+            '.agent-turn .markdown',
+            '.agent-turn',
+        ];
+        for (const selector of selectors) {
+            const elements = document.querySelectorAll(selector);
+            if (elements.length > 0) {
+                const lastEl = elements[elements.length - 1];
+                return {
+                    selector,
+                    count: elements.length,
+                    text: lastEl.innerText,
+                };
+            }
+        }
+        // Debug: show what's on the page
+        const body = document.body.innerHTML;
+        return { error: 'No messages found', bodyLength: body.length, sample: body.slice(0, 2000) };
+    }));
+    if ('error' in content) {
+        console.error('Error:', JSON.stringify(content, null, 2));
+        process.exit(1);
+    }
+    console.log(content.text);
+    browser.disconnect();
+}
+main().catch(console.error);