@steipete/oracle 0.8.3 → 0.8.5

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Peter Steinberger
+\g<1>2026 Peter Steinberger
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -119,6 +119,11 @@ npx -y @steipete/oracle oracle-mcp
 | `--browser-timeout`, `--browser-input-timeout` | Control overall/browser input timeouts (supports h/m/s/ms). |
 | `--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. |
@@ -150,6 +155,7 @@ 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` |
+| 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 +177,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'])
@@ -219,14 +240,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).')
@@ -323,6 +403,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 +456,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 +533,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}`));
     }
@@ -752,7 +845,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);
@@ -956,7 +1049,7 @@ program.action(async function () {
     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);

package/dist/src/bridge/connection.js

@@ -0,0 +1,103 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export function normalizeHostPort(hostname, port) {
+    const trimmed = hostname.trim();
+    const unwrapped = trimmed.startsWith('[') && trimmed.endsWith(']') ? trimmed.slice(1, -1) : trimmed;
+    if (unwrapped.includes(':')) {
+        return `[${unwrapped}]:${port}`;
+    }
+    return `${unwrapped}:${port}`;
+}
+export function parseHostPort(raw) {
+    const target = raw.trim();
+    if (!target) {
+        throw new Error('Expected host:port but received an empty value.');
+    }
+    const ipv6Match = target.match(/^\[(.+)]:(\d+)$/);
+    let hostname;
+    let portSegment;
+    if (ipv6Match) {
+        hostname = ipv6Match[1]?.trim();
+        portSegment = ipv6Match[2]?.trim();
+    }
+    else {
+        const lastColon = target.lastIndexOf(':');
+        if (lastColon === -1) {
+            throw new Error(`Invalid host:port format: ${target}. Expected host:port (IPv6 must use [host]:port notation).`);
+        }
+        hostname = target.slice(0, lastColon).trim();
+        portSegment = target.slice(lastColon + 1).trim();
+        if (hostname.includes(':')) {
+            throw new Error(`Invalid host:port format: ${target}. Wrap IPv6 addresses in brackets, e.g. "[2001:db8::1]:9473".`);
+        }
+    }
+    if (!hostname) {
+        throw new Error(`Invalid host:port format: ${target}. Host portion is missing.`);
+    }
+    const port = Number.parseInt(portSegment ?? '', 10);
+    if (!Number.isFinite(port) || port <= 0 || port > 65_535) {
+        throw new Error(`Invalid port: "${portSegment ?? ''}". Expected a number between 1 and 65535.`);
+    }
+    return { hostname, port };
+}
+export function parseBridgeConnectionString(input) {
+    const raw = input.trim();
+    if (!raw) {
+        throw new Error('Missing connection string.');
+    }
+    let url;
+    try {
+        url = raw.includes('://') ? new URL(raw) : new URL(`oracle+tcp://${raw}`);
+    }
+    catch (error) {
+        throw new Error(`Invalid connection string: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const hostname = url.hostname?.trim();
+    const port = Number.parseInt(url.port ?? '', 10);
+    if (!hostname || !Number.isFinite(port) || port <= 0 || port > 65_535) {
+        throw new Error(`Invalid connection string host: ${raw}. Expected host:port.`);
+    }
+    const token = url.searchParams.get('token')?.trim() ?? '';
+    if (!token) {
+        throw new Error('Connection string is missing token. Expected "?token=...".');
+    }
+    const remoteHost = normalizeHostPort(hostname, port);
+    return { remoteHost, remoteToken: token };
+}
+export function formatBridgeConnectionString(connection, options = {}) {
+    const { hostname, port } = parseHostPort(connection.remoteHost);
+    const base = `oracle+tcp://${normalizeHostPort(hostname, port)}`;
+    if (!options.includeToken) {
+        return base;
+    }
+    const params = new URLSearchParams({ token: connection.remoteToken });
+    return `${base}?${params.toString()}`;
+}
+export function looksLikePath(value) {
+    return value.includes('/') || value.includes('\\') || value.endsWith('.json');
+}
+export async function readBridgeConnectionArtifact(filePath) {
+    const resolved = path.resolve(process.cwd(), filePath);
+    const raw = await fs.readFile(resolved, 'utf8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse connection artifact JSON at ${resolved}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        throw new Error(`Invalid connection artifact at ${resolved}: expected an object.`);
+    }
+    const remoteHost = parsed.remoteHost;
+    const remoteToken = parsed.remoteToken;
+    if (typeof remoteHost !== 'string' || remoteHost.trim().length === 0) {
+        throw new Error(`Invalid connection artifact at ${resolved}: remoteHost is missing.`);
+    }
+    if (typeof remoteToken !== 'string' || remoteToken.trim().length === 0) {
+        throw new Error(`Invalid connection artifact at ${resolved}: remoteToken is missing.`);
+    }
+    // Validate host formatting early so downstream checks don't crash.
+    parseHostPort(remoteHost);
+    return parsed;
+}

package/dist/src/bridge/userConfigFile.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import JSON5 from 'json5';
+export async function readUserConfigFile(configPath) {
+    try {
+        const raw = await fs.readFile(configPath, 'utf8');
+        const parsed = JSON5.parse(raw);
+        return { config: parsed ?? {}, loaded: true };
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT') {
+            return { config: {}, loaded: false };
+        }
+        throw new Error(`Failed to read ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function writeUserConfigFile(configPath, config) {
+    const dir = path.dirname(configPath);
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    const contents = `${JSON.stringify(config, null, 2)}\n`;
+    const tempPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.writeFile(tempPath, contents, { encoding: 'utf8', mode: 0o600 });
+    await fs.rename(tempPath, configPath);
+    if (process.platform !== 'win32') {
+        await fs.chmod(configPath, 0o600).catch(() => undefined);
+    }
+}

package/dist/src/browser/actions/assistantResponse.js

@@ -286,11 +286,15 @@ async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex) {
                 isCompletionVisible(Runtime),
             ]);
             const shortAnswer = currentLength > 0 && currentLength < 16;
+            const mediumAnswer = currentLength >= 16 && currentLength < 40;
+            const longAnswer = currentLength >= 40 && currentLength < 500;
             // Learned: short answers need a longer stability window or they truncate.
-            const completionStableTarget = shortAnswer ? 12 : currentLength < 40 ? 8 : 4;
-            const requiredStableCycles = shortAnswer ? 12 : 6;
+            // Learned: long streaming responses (esp. thinking models) can pause mid-stream;
+            // use progressively longer windows to avoid truncation (#71).
+            const completionStableTarget = shortAnswer ? 12 : mediumAnswer ? 8 : longAnswer ? 6 : 8;
+            const requiredStableCycles = shortAnswer ? 12 : mediumAnswer ? 8 : longAnswer ? 8 : 10;
             const stableMs = Date.now() - lastChangeAt;
-            const minStableMs = shortAnswer ? 8000 : 1200;
+            const minStableMs = shortAnswer ? 8000 : mediumAnswer ? 1200 : longAnswer ? 2000 : 3000;
             // Require stop button to disappear before treating completion as final.
             if (!stopVisible) {
                 const stableEnough = stableCycles >= requiredStableCycles && stableMs >= minStableMs;
@@ -546,15 +550,19 @@ function buildResponseObserverExpression(timeoutMs, minTurnIndex) {
 
     const waitForSettle = async (snapshot) => {
       // Learned: short answers can be 1-2 tokens; enforce longer settle windows to avoid truncation.
+      // Learned: long streaming responses (esp. thinking models) can pause mid-stream;
+      // use progressively longer windows to avoid truncation (#71).
       const initialLength = snapshot?.text?.length ?? 0;
       const shortAnswer = initialLength > 0 && initialLength < 16;
-      const settleWindowMs = shortAnswer ? 12_000 : 5_000;
+      const mediumAnswer = initialLength >= 16 && initialLength < 40;
+      const longAnswer = initialLength >= 40 && initialLength < 500;
+      const settleWindowMs = shortAnswer ? 12_000 : mediumAnswer ? 5_000 : longAnswer ? 8_000 : 10_000;
       const settleIntervalMs = 400;
       const deadline = Date.now() + settleWindowMs;
       let latest = snapshot;
       let lastLength = snapshot?.text?.length ?? 0;
       let stableCycles = 0;
-      const stableTarget = shortAnswer ? 6 : 3;
+      const stableTarget = shortAnswer ? 6 : mediumAnswer ? 3 : longAnswer ? 5 : 6;
       while (Date.now() < deadline) {
         await new Promise((resolve) => setTimeout(resolve, settleIntervalMs));
         const refreshedRaw = extractFromTurns();

package/dist/src/browser/actions/attachments.js

@@ -570,7 +570,7 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
       // keep it as a fallback, but strongly prefer visible (even sr-only 1x1) inputs.
       const localSet = new Set(localInputs);
       let idx = 0;
-      const candidates = inputs.map((el) => {
+      let candidates = inputs.map((el) => {
         const accept = el.getAttribute('accept') || '';
         const imageOnly = acceptIsImageOnly(accept);
         const rect = el instanceof HTMLElement ? el.getBoundingClientRect() : { width: 0, height: 0 };
@@ -583,9 +583,18 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
           (!imageOnly ? 30 : isImageAttachment ? 20 : 5);
         el.setAttribute('data-oracle-upload-candidate', 'true');
         el.setAttribute('data-oracle-upload-idx', String(idx));
-        return { idx: idx++, score, imageOnly, visible, local };
+        return { idx: idx++, score, imageOnly };
       });
 
+      // When the attachment isn't an image, avoid inputs that only accept images.
+      // Some ChatGPT surfaces expose multiple file inputs (e.g. image-only vs generic upload).
+      if (!isImageAttachment) {
+        const nonImage = candidates.filter((candidate) => !candidate.imageOnly);
+        if (nonImage.length > 0) {
+          candidates = nonImage;
+        }
+      }
+
       // Prefer higher scores first.
       candidates.sort((a, b) => b.score - a.score);
       return {
@@ -829,8 +838,8 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
                 continue;
             }
             const baselineInputSnapshot = await readInputSnapshot(idx);
-            const gatherSignals = async () => {
-                const signalResult = await waitForAttachmentUiSignal(attachmentUiSignalWaitMs);
+            const gatherSignals = async (waitMs = attachmentUiSignalWaitMs) => {
+                const signalResult = await waitForAttachmentUiSignal(waitMs);
                 const postInputSnapshot = await readInputSnapshot(idx);
                 const postInputSignals = inputSignalsFor(baselineInputSnapshot, postInputSnapshot);
                 const snapshot = await runtime
@@ -890,22 +899,6 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
                 if (!hasExpectedFile) {
                     if (mode === 'set') {
                         await dom.setFileInputFiles({ nodeId: resultNode.nodeId, files: [attachment.path] });
-                        await runtime
-                            .evaluate({
-                            expression: `(() => {
-                  const input = document.querySelector('input[type="file"][data-oracle-upload-idx="${idx}"]');
-                  if (!(input instanceof HTMLInputElement)) return false;
-                  try {
-                    input.dispatchEvent(new Event('input', { bubbles: true }));
-                    input.dispatchEvent(new Event('change', { bubbles: true }));
-                    return true;
-                  } catch {
-                    return false;
-                  }
-                })()`,
-                            returnByValue: true,
-                        })
-                            .catch(() => undefined);
                     }
                     else {
                         const selector = `input[type="file"][data-oracle-upload-idx="${idx}"]`;
@@ -930,12 +923,43 @@ export async function uploadAttachmentFile(deps, attachment, logger, options) {
                 const evaluation = await evaluateSignals(signalState.signalResult, signalState.postInputSignals, immediateInputMatch);
                 return { evaluation, signalState, immediateInputMatch };
             };
+            const dispatchInputEvents = async () => {
+                await runtime
+                    .evaluate({
+                    expression: `(() => {
+              const input = document.querySelector('input[type="file"][data-oracle-upload-idx="${idx}"]');
+              if (!(input instanceof HTMLInputElement)) return false;
+              try {
+                input.dispatchEvent(new Event('input', { bubbles: true }));
+                input.dispatchEvent(new Event('change', { bubbles: true }));
+                return true;
+              } catch {
+                return false;
+              }
+            })()`,
+                    returnByValue: true,
+                })
+                    .catch(() => undefined);
+            };
             let result = await runInputAttempt('set');
             if (result.evaluation.status === 'ui') {
                 confirmedAttachment = true;
                 break;
             }
             if (result.evaluation.status === 'input') {
+                await dispatchInputEvents();
+                await delay(150);
+                const forcedState = await gatherSignals(1_500);
+                const forcedEvaluation = await evaluateSignals(forcedState.signalResult, forcedState.postInputSignals, result.immediateInputMatch);
+                if (forcedEvaluation.status === 'ui') {
+                    confirmedAttachment = true;
+                    break;
+                }
+                if (forcedEvaluation.status === 'input') {
+                    logger('Attachment input set; proceeding without UI confirmation.');
+                    inputConfirmed = true;
+                    break;
+                }
                 logger('Attachment input set; retrying with data transfer to trigger ChatGPT upload.');
                 await dom.setFileInputFiles({ nodeId: resultNode.nodeId, files: [] }).catch(() => undefined);
                 await delay(150);

package/dist/src/browser/chromeLifecycle.js

@@ -124,15 +124,14 @@ export async function connectToChrome(port, logger, host) {
 }
 export async function connectToRemoteChrome(host, port, logger, targetUrl) {
     if (targetUrl) {
-        try {
-            const target = await CDP.New({ host, port, url: targetUrl });
-            const client = await CDP({ host, port, target: target.id });
-            logger(`Opened dedicated remote Chrome tab targeting ${targetUrl}`);
-            return { client, targetId: target.id };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger(`Failed to open dedicated remote Chrome tab (${message}); falling back to first target.`);
+        const targetConnection = await connectToNewTarget(host, port, targetUrl, logger, {
+            opened: () => `Opened dedicated remote Chrome tab targeting ${targetUrl}`,
+            openFailed: (message) => `Failed to open dedicated remote Chrome tab (${message}); falling back to first target.`,
+            attachFailed: (targetId, message) => `Failed to attach to dedicated remote Chrome tab ${targetId} (${message}); falling back to first target.`,
+            closeFailed: (targetId, message) => `Failed to close unused remote Chrome tab ${targetId}: ${message}`,
+        });
+        if (targetConnection) {
+            return { client: targetConnection.client, targetId: targetConnection.targetId };
         }
     }
     const fallbackClient = await CDP({ host, port });
@@ -154,6 +153,60 @@ export async function closeRemoteChromeTarget(host, port, targetId, logger) {
         logger(`Failed to close remote Chrome tab ${targetId}: ${message}`);
     }
 }
+async function connectToNewTarget(host, port, url, logger, messages) {
+    try {
+        const target = await CDP.New({ host, port, url });
+        try {
+            const client = await CDP({ host, port, target: target.id });
+            if (messages.opened) {
+                logger(messages.opened(target.id));
+            }
+            return { client, targetId: target.id };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger(messages.attachFailed(target.id, message));
+            try {
+                await CDP.Close({ host, port, id: target.id });
+            }
+            catch (closeError) {
+                const closeMessage = closeError instanceof Error ? closeError.message : String(closeError);
+                logger(messages.closeFailed(target.id, closeMessage));
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(messages.openFailed(message));
+    }
+    return null;
+}
+export async function connectWithNewTab(port, logger, initialUrl, host) {
+    const effectiveHost = host ?? '127.0.0.1';
+    const url = initialUrl ?? 'about:blank';
+    const targetConnection = await connectToNewTarget(effectiveHost, port, url, logger, {
+        opened: (targetId) => `Opened isolated browser tab (target=${targetId})`,
+        openFailed: (message) => `Failed to open isolated browser tab (${message}); falling back to default target.`,
+        attachFailed: (targetId, message) => `Failed to attach to isolated browser tab ${targetId} (${message}); falling back to default target.`,
+        closeFailed: (targetId, message) => `Failed to close unused browser tab ${targetId}: ${message}`,
+    });
+    if (targetConnection) {
+        return targetConnection;
+    }
+    const client = await connectToChrome(port, logger, effectiveHost);
+    return { client };
+}
+export async function closeTab(port, targetId, logger, host) {
+    const effectiveHost = host ?? '127.0.0.1';
+    try {
+        await CDP.Close({ host: effectiveHost, port, id: targetId });
+        logger(`Closed isolated browser tab (target=${targetId})`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to close browser tab ${targetId}: ${message}`);
+    }
+}
 function buildChromeFlags(headless, debugBindAddress) {
     const flags = [
         '--disable-background-networking',