@steipete/oracle 0.8.5 → 0.8.6

package/dist/src/browser/index.js

@@ -6,6 +6,7 @@ import { resolveBrowserConfig } from './config.js';
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, closeRemoteChromeTarget, connectWithNewTab, closeTab, } from './chromeLifecycle.js';
 import { syncCookies } from './cookies.js';
 import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, submitPrompt, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from './pageActions.js';
+import { INPUT_SELECTORS } from './constants.js';
 import { uploadAttachmentViaDataTransfer } from './actions/remoteFileTransfer.js';
 import { ensureThinkingTime } from './actions/thinkingTime.js';
 import { estimateTokenCount, withRetries, delay } from './utils.js';
@@ -13,7 +14,7 @@ import { formatElapsed } from '../oracle/format.js';
 import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR, DEFAULT_MODEL_STRATEGY } from './constants.js';
 import { BrowserAutomationError } from '../oracle/errors.js';
 import { alignPromptEchoPair, buildPromptEchoMatcher } from './reattachHelpers.js';
-import { cleanupStaleProfileState, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
+import { cleanupStaleProfileState, acquireProfileRunLock, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from './constants.js';
 export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from './utils.js';
 export async function runBrowserMode(options) {
@@ -96,7 +97,9 @@ export async function runBrowserMode(options) {
         logger(`Created temporary Chrome profile at ${userDataDir}`);
     }
     const effectiveKeepBrowser = Boolean(config.keepBrowser);
-    const reusedChrome = manualLogin ? await maybeReuseRunningChrome(userDataDir, logger) : null;
+    const reusedChrome = manualLogin
+        ? await maybeReuseRunningChrome(userDataDir, logger, { waitForPortMs: config.reuseChromeWaitMs })
+        : null;
     const chrome = reusedChrome ??
         (await launchChrome({
             ...config,
@@ -134,7 +137,12 @@ export async function runBrowserMode(options) {
     let appliedCookies = 0;
     try {
         try {
-            const connection = await connectWithNewTab(chrome.port, logger, undefined, chromeHost);
+            const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+            const connection = await connectWithNewTab(chrome.port, logger, undefined, chromeHost, {
+                fallbackToDefault: !strictTabIsolation,
+                retries: strictTabIsolation ? 3 : 0,
+                retryDelayMs: 500,
+            });
             client = connection.client;
             isolatedTargetId = connection.targetId ?? null;
         }
@@ -346,6 +354,23 @@ export async function runBrowserMode(options) {
                 },
             }));
         }
+        const profileLockTimeoutMs = manualLogin ? (config.profileLockTimeoutMs ?? 0) : 0;
+        let profileLock = null;
+        const acquireProfileLockIfNeeded = async () => {
+            if (profileLockTimeoutMs <= 0)
+                return;
+            profileLock = await acquireProfileRunLock(userDataDir, {
+                timeoutMs: profileLockTimeoutMs,
+                logger,
+            });
+        };
+        const releaseProfileLockIfHeld = async () => {
+            if (!profileLock)
+                return;
+            const handle = profileLock;
+            profileLock = null;
+            await handle.release().catch(() => undefined);
+        };
         const submitOnce = async (prompt, submissionAttachments) => {
             const baselineSnapshot = await readAssistantSnapshot(Runtime).catch(() => null);
             const baselineAssistantText = typeof baselineSnapshot?.text === 'string' ? baselineSnapshot.text.trim() : '';
@@ -421,27 +446,33 @@ export async function runBrowserMode(options) {
         };
         let baselineTurns = null;
         let baselineAssistantText = null;
+        await acquireProfileLockIfNeeded();
         try {
-            const submission = await raceWithDisconnect(submitOnce(promptText, attachments));
-            baselineTurns = submission.baselineTurns;
-            baselineAssistantText = submission.baselineAssistantText;
-        }
-        catch (error) {
-            const isPromptTooLarge = error instanceof BrowserAutomationError &&
-                error.details?.code === 'prompt-too-large';
-            if (fallbackSubmission && isPromptTooLarge) {
-                // Learned: when prompts truncate, retry with file uploads so the UI receives the full content.
-                logger('[browser] Inline prompt too large; retrying with file uploads.');
-                await raceWithDisconnect(clearPromptComposer(Runtime, logger));
-                await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
-                const submission = await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
+            try {
+                const submission = await raceWithDisconnect(submitOnce(promptText, attachments));
                 baselineTurns = submission.baselineTurns;
                 baselineAssistantText = submission.baselineAssistantText;
             }
-            else {
-                throw error;
+            catch (error) {
+                const isPromptTooLarge = error instanceof BrowserAutomationError &&
+                    error.details?.code === 'prompt-too-large';
+                if (fallbackSubmission && isPromptTooLarge) {
+                    // Learned: when prompts truncate, retry with file uploads so the UI receives the full content.
+                    logger('[browser] Inline prompt too large; retrying with file uploads.');
+                    await raceWithDisconnect(clearPromptComposer(Runtime, logger));
+                    await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+                    const submission = await raceWithDisconnect(submitOnce(fallbackSubmission.prompt, fallbackSubmission.attachments));
+                    baselineTurns = submission.baselineTurns;
+                    baselineAssistantText = submission.baselineAssistantText;
+                }
+                else {
+                    throw error;
+                }
             }
         }
+        finally {
+            await releaseProfileLockIfHeld();
+        }
         stopThinkingMonitor = startThinkingStatusMonitor(Runtime, logger, options.verbose ?? false);
         // Helper to normalize text for echo detection (collapse whitespace, lowercase)
         const normalizeForComparison = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
@@ -468,7 +499,83 @@ export async function runBrowserMode(options) {
             }
             return null;
         };
-        let answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined));
+        let answer;
+        const recheckDelayMs = Math.max(0, config.assistantRecheckDelayMs ?? 0);
+        const recheckTimeoutMs = Math.max(0, config.assistantRecheckTimeoutMs ?? 0);
+        const attemptAssistantRecheck = async () => {
+            if (!recheckDelayMs)
+                return null;
+            logger(`[browser] Assistant response timed out; waiting ${formatElapsed(recheckDelayMs)} before rechecking conversation.`);
+            await raceWithDisconnect(delay(recheckDelayMs));
+            await updateConversationHint('assistant-recheck', 15_000).catch(() => false);
+            await captureRuntimeSnapshot().catch(() => undefined);
+            const conversationUrl = await readConversationUrl(Runtime);
+            if (conversationUrl && isConversationUrl(conversationUrl)) {
+                logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
+                await raceWithDisconnect(Page.navigate({ url: conversationUrl }));
+                await raceWithDisconnect(delay(1000));
+            }
+            // Validate session before attempting recheck - sessions can expire during the delay
+            const sessionValid = await validateChatGPTSession(Runtime, logger);
+            if (!sessionValid.valid) {
+                logger(`[browser] Session validation failed: ${sessionValid.reason}`);
+                // Update session metadata to indicate login is needed
+                await emitRuntimeHint();
+                throw new BrowserAutomationError(`ChatGPT session expired during recheck: ${sessionValid.reason}. ` +
+                    `Conversation URL: ${conversationUrl || lastUrl || 'unknown'}. ` +
+                    `Please sign in and retry.`, {
+                    stage: 'assistant-recheck',
+                    details: {
+                        conversationUrl: conversationUrl || lastUrl || null,
+                        sessionStatus: 'needs_login',
+                        validationReason: sessionValid.reason,
+                    },
+                    runtime: {
+                        chromePid: chrome.pid,
+                        chromePort: chrome.port,
+                        chromeHost,
+                        userDataDir,
+                        chromeTargetId: lastTargetId,
+                        tabUrl: lastUrl,
+                        conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                        controllerPid: process.pid,
+                    },
+                });
+            }
+            const timeoutMs = recheckTimeoutMs > 0 ? recheckTimeoutMs : config.timeoutMs;
+            const rechecked = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined));
+            logger('Recovered assistant response after delayed recheck');
+            return rechecked;
+        };
+        try {
+            answer = await raceWithDisconnect(waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined));
+        }
+        catch (error) {
+            if (isAssistantResponseTimeoutError(error)) {
+                const rechecked = await attemptAssistantRecheck().catch(() => null);
+                if (rechecked) {
+                    answer = rechecked;
+                }
+                else {
+                    await updateConversationHint('assistant-timeout', 15_000).catch(() => false);
+                    await captureRuntimeSnapshot().catch(() => undefined);
+                    const runtime = {
+                        chromePid: chrome.pid,
+                        chromePort: chrome.port,
+                        chromeHost,
+                        userDataDir,
+                        chromeTargetId: lastTargetId,
+                        tabUrl: lastUrl,
+                        conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                        controllerPid: process.pid,
+                    };
+                    throw new BrowserAutomationError('Assistant response timed out before completion; reattach later to capture the answer.', { stage: 'assistant-timeout', runtime }, error);
+                }
+            }
+            else {
+                throw error;
+            }
+        }
         // Ensure we store the final conversation URL even if the UI updated late.
         await updateConversationHint('post-response', 15_000);
         const baselineNormalized = baselineAssistantText ? normalizeForComparison(baselineAssistantText) : '';
@@ -658,7 +765,10 @@ export async function runBrowserMode(options) {
         catch {
             // ignore
         }
-        if (!effectiveKeepBrowser && isolatedTargetId && chrome?.port) {
+        // Close the isolated tab once the response has been fully captured to prevent
+        // tab accumulation across repeated runs. Keep the tab open on incomplete runs
+        // so reattach can recover the response.
+        if (runStatus === 'complete' && isolatedTargetId && chrome?.port) {
             await closeTab(chrome.port, isolatedTargetId, logger, chromeHost).catch(() => undefined);
         }
         removeDialogHandler?.();
@@ -817,11 +927,20 @@ async function _assertNavigatedToHttp(runtime, _logger, timeoutMs = 10_000) {
         details: { url: lastUrl || '(empty)' },
     });
 }
-async function maybeReuseRunningChrome(userDataDir, logger) {
-    const port = await readDevToolsPort(userDataDir);
+async function maybeReuseRunningChrome(userDataDir, logger, options = {}) {
+    const waitForPortMs = Math.max(0, options.waitForPortMs ?? 0);
+    let port = await readDevToolsPort(userDataDir);
+    if (!port && waitForPortMs > 0) {
+        const deadline = Date.now() + waitForPortMs;
+        logger(`Waiting up to ${formatElapsed(waitForPortMs)} for shared Chrome to appear...`);
+        while (!port && Date.now() < deadline) {
+            await delay(250);
+            port = await readDevToolsPort(userDataDir);
+        }
+    }
     if (!port)
         return null;
-    const probe = await verifyDevToolsReachable({ port });
+    const probe = await (options.probe ?? verifyDevToolsReachable)({ port });
     if (!probe.ok) {
         logger(`DevToolsActivePort found for ${userDataDir} but unreachable (${probe.error}); launching new Chrome.`);
         // Safe cleanup: remove stale DevToolsActivePort; only remove lock files if this was an Oracle-owned pid that died.
@@ -1023,7 +1142,87 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
             return null;
         };
-        let answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined);
+        let answer;
+        const recheckDelayMs = Math.max(0, config.assistantRecheckDelayMs ?? 0);
+        const recheckTimeoutMs = Math.max(0, config.assistantRecheckTimeoutMs ?? 0);
+        const attemptAssistantRecheck = async () => {
+            if (!recheckDelayMs)
+                return null;
+            logger(`[browser] Assistant response timed out; waiting ${formatElapsed(recheckDelayMs)} before rechecking conversation.`);
+            await delay(recheckDelayMs);
+            const conversationUrl = await readConversationUrl(Runtime);
+            if (conversationUrl && isConversationUrl(conversationUrl)) {
+                lastUrl = conversationUrl;
+                logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
+                await Page.navigate({ url: conversationUrl });
+                await delay(1000);
+            }
+            // Validate session before attempting recheck - sessions can expire during the delay
+            const sessionValid = await validateChatGPTSession(Runtime, logger);
+            if (!sessionValid.valid) {
+                logger(`[browser] Session validation failed: ${sessionValid.reason}`);
+                // Update session metadata to indicate login is needed
+                await emitRuntimeHint();
+                throw new BrowserAutomationError(`ChatGPT session expired during recheck: ${sessionValid.reason}. ` +
+                    `Conversation URL: ${conversationUrl || lastUrl || 'unknown'}. ` +
+                    `Please sign in and retry.`, {
+                    stage: 'assistant-recheck',
+                    details: {
+                        conversationUrl: conversationUrl || lastUrl || null,
+                        sessionStatus: 'needs_login',
+                        validationReason: sessionValid.reason,
+                    },
+                    runtime: {
+                        chromeHost: host,
+                        chromePort: port,
+                        chromeTargetId: remoteTargetId ?? undefined,
+                        tabUrl: lastUrl,
+                        conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                        controllerPid: process.pid,
+                    },
+                });
+            }
+            await emitRuntimeHint();
+            const timeoutMs = recheckTimeoutMs > 0 ? recheckTimeoutMs : config.timeoutMs;
+            const rechecked = await waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logger, baselineTurns ?? undefined);
+            logger('Recovered assistant response after delayed recheck');
+            return rechecked;
+        };
+        try {
+            answer = await waitForAssistantResponseWithReload(Runtime, Page, config.timeoutMs, logger, baselineTurns ?? undefined);
+        }
+        catch (error) {
+            if (isAssistantResponseTimeoutError(error)) {
+                const rechecked = await attemptAssistantRecheck().catch(() => null);
+                if (rechecked) {
+                    answer = rechecked;
+                }
+                else {
+                    try {
+                        const conversationUrl = await readConversationUrl(Runtime);
+                        if (conversationUrl) {
+                            lastUrl = conversationUrl;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                    await emitRuntimeHint();
+                    const runtime = {
+                        chromePort: port,
+                        chromeHost: host,
+                        chromeTargetId: remoteTargetId ?? undefined,
+                        tabUrl: lastUrl,
+                        conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                        controllerPid: process.pid,
+                    };
+                    throw new BrowserAutomationError('Assistant response timed out before completion; reattach later to capture the answer.', { stage: 'assistant-timeout', runtime }, error);
+                }
+            }
+            else {
+                throw error;
+            }
+        }
         const baselineNormalized = baselineAssistantText ? normalizeForComparison(baselineAssistantText) : '';
         if (baselineNormalized) {
             const normalizedAnswer = normalizeForComparison(answer.text ?? '');
@@ -1178,6 +1377,9 @@ export { estimateTokenCount } from './utils.js';
 export { resolveBrowserConfig, DEFAULT_BROWSER_CONFIG } from './config.js';
 export { syncCookies } from './cookies.js';
 export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from './pageActions.js';
+export async function maybeReuseRunningChromeForTest(userDataDir, logger, options = {}) {
+    return maybeReuseRunningChrome(userDataDir, logger, options);
+}
 function isWebSocketClosureError(error) {
     const message = error.message.toLowerCase();
     return (message.includes('websocket connection closed') ||
@@ -1222,6 +1424,17 @@ function shouldReloadAfterAssistantError(error) {
         message.includes('timeout') ||
         message.includes('capture assistant response'));
 }
+function isAssistantResponseTimeoutError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    if (!message)
+        return false;
+    return (message.includes('assistant-response') ||
+        message.includes('assistant response') ||
+        message.includes('watchdog') ||
+        message.includes('capture assistant response'));
+}
 async function readConversationUrl(Runtime) {
     try {
         const currentUrl = await Runtime.evaluate({ expression: 'location.href', returnByValue: true });
@@ -1231,6 +1444,110 @@ async function readConversationUrl(Runtime) {
         return null;
     }
 }
+/**
+ * Validates that the ChatGPT session is still active by checking for login CTAs
+ * and textarea availability. Sessions can expire during long delays (e.g., recheck).
+ *
+ * @param Runtime - Chrome Runtime client
+ * @param logger - Browser logger for diagnostics
+ * @returns SessionValidationResult indicating if session is valid and reason if not
+ */
+async function validateChatGPTSession(Runtime, logger) {
+    try {
+        const outcome = await Runtime.evaluate({
+            expression: buildSessionValidationExpression(),
+            awaitPromise: true,
+            returnByValue: true,
+        });
+        const result = outcome.result?.value;
+        if (!result) {
+            return { valid: false, reason: 'Failed to evaluate session state' };
+        }
+        if (result.onAuthPage) {
+            return { valid: false, reason: 'Redirected to auth page' };
+        }
+        if (result.hasLoginCta) {
+            return { valid: false, reason: 'Login button detected on page' };
+        }
+        if (!result.hasTextarea) {
+            return { valid: false, reason: 'Prompt textarea not available' };
+        }
+        return { valid: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`[browser] Session validation error: ${message}`);
+        return { valid: false, reason: `Validation error: ${message}` };
+    }
+}
+function buildSessionValidationExpression() {
+    const selectorLiteral = JSON.stringify(INPUT_SELECTORS);
+    return `(async () => {
+    const pageUrl = typeof location === 'object' && location?.href ? location.href : null;
+    const onAuthPage =
+      typeof location === 'object' &&
+      typeof location.pathname === 'string' &&
+      /^\\/(auth|login|signin)/i.test(location.pathname);
+
+    // Check for login CTAs (similar to ensureLoggedIn logic)
+    const hasLoginCta = (() => {
+      const candidates = Array.from(
+        document.querySelectorAll(
+          [
+            'a[href*="/auth/login"]',
+            'a[href*="/auth/signin"]',
+            'button[type="submit"]',
+            'button[data-testid*="login"]',
+            'button[data-testid*="log-in"]',
+            'button[data-testid*="sign-in"]',
+            'button[data-testid*="signin"]',
+            'button',
+            'a',
+          ].join(','),
+        ),
+      );
+      const textMatches = (text) => {
+        if (!text) return false;
+        const normalized = text.toLowerCase().trim();
+        return ['log in', 'login', 'sign in', 'signin', 'continue with'].some((needle) =>
+          normalized.startsWith(needle),
+        );
+      };
+      for (const node of candidates) {
+        if (!(node instanceof HTMLElement)) continue;
+        const label =
+          node.textContent?.trim() ||
+          node.getAttribute('aria-label') ||
+          node.getAttribute('title') ||
+          '';
+        if (textMatches(label)) {
+          return true;
+        }
+      }
+      return false;
+    })();
+
+    // Check for textarea availability
+    const hasTextarea = (() => {
+      const selectors = ${selectorLiteral};
+      for (const selector of selectors) {
+        const node = document.querySelector(selector);
+        if (node) {
+          return true;
+        }
+      }
+      return false;
+    })();
+
+    return {
+      valid: !onAuthPage && !hasLoginCta && hasTextarea,
+      hasLoginCta,
+      hasTextarea,
+      onAuthPage,
+      pageUrl,
+    };
+  })()`;
+}
 async function readConversationTurnCount(Runtime, logger) {
     const selectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     const attempts = 4;

package/dist/src/browser/profileState.js

@@ -1,13 +1,16 @@
 import path from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { delay } from './utils.js';
 const DEVTOOLS_ACTIVE_PORT_FILENAME = 'DevToolsActivePort';
 const DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS = [
     DEVTOOLS_ACTIVE_PORT_FILENAME,
     path.join('Default', DEVTOOLS_ACTIVE_PORT_FILENAME),
 ];
 const CHROME_PID_FILENAME = 'chrome.pid';
+const ORACLE_PROFILE_LOCK_FILENAME = 'oracle-automation.lock';
 const execFileAsync = promisify(execFile);
 export function getDevToolsActivePortPaths(userDataDir) {
     return DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS.map((relative) => path.join(userDataDir, relative));
@@ -81,6 +84,96 @@ export function isProcessAlive(pid) {
         return false;
     }
 }
+function parseProfileRunLock(payload) {
+    if (!payload)
+        return null;
+    try {
+        const parsed = JSON.parse(payload);
+        if (!Number.isFinite(parsed.pid) || parsed.pid <= 0)
+            return null;
+        if (!parsed.lockId || typeof parsed.lockId !== 'string')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function acquireProfileRunLock(userDataDir, options) {
+    const timeoutMs = options.timeoutMs;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return null;
+    }
+    const pollMs = typeof options.pollMs === 'number' && Number.isFinite(options.pollMs) && options.pollMs > 0
+        ? options.pollMs
+        : 1000;
+    const lockPath = path.join(userDataDir, ORACLE_PROFILE_LOCK_FILENAME);
+    const lockId = randomUUID();
+    const startedAt = Date.now();
+    let warned = false;
+    for (;;) {
+        try {
+            const payload = {
+                pid: process.pid,
+                lockId,
+                createdAt: new Date().toISOString(),
+                sessionId: options.sessionId,
+            };
+            await mkdir(path.dirname(lockPath), { recursive: true });
+            await writeFile(lockPath, JSON.stringify(payload), { encoding: 'utf8', flag: 'wx' });
+            options.logger?.(`Acquired Oracle profile lock at ${lockPath}`);
+            return {
+                path: lockPath,
+                lockId,
+                release: async () => releaseProfileRunLock(lockPath, lockId, options.logger),
+            };
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'EEXIST') {
+                throw error;
+            }
+            let existing = parseProfileRunLock(await readFile(lockPath, 'utf8').catch(() => null));
+            if (!existing) {
+                // Likely partial write / corruption; re-read once, then delete (user preference: delete unreadable lockfiles).
+                await delay(200);
+                existing = parseProfileRunLock(await readFile(lockPath, 'utf8').catch(() => null));
+                if (!existing) {
+                    options.logger?.('Oracle profile lock unreadable; deleting lockfile.');
+                    await rm(lockPath, { force: true }).catch(() => undefined);
+                    continue;
+                }
+            }
+            if (!existing || !isProcessAlive(existing.pid)) {
+                await rm(lockPath, { force: true }).catch(() => undefined);
+                continue;
+            }
+            if (!warned) {
+                const waited = Math.round(timeoutMs / 1000);
+                options.logger?.(`Oracle profile lock held by pid ${existing.pid}; waiting up to ${waited}s.`);
+                warned = true;
+            }
+            const elapsed = Date.now() - startedAt;
+            if (elapsed >= timeoutMs) {
+                throw new Error(`Oracle profile lock still held by pid ${existing.pid} after ${Math.round(elapsed / 1000)}s`);
+            }
+            await delay(Math.min(pollMs, timeoutMs - elapsed));
+        }
+    }
+}
+export async function releaseProfileRunLock(lockPath, lockId, logger) {
+    try {
+        const existing = parseProfileRunLock(await readFile(lockPath, 'utf8').catch(() => null));
+        if (!existing || existing.lockId !== lockId) {
+            return;
+        }
+        await rm(lockPath, { force: true });
+        logger?.(`Released Oracle profile lock ${lockPath}`);
+    }
+    catch {
+        // best effort
+    }
+}
 export async function verifyDevToolsReachable({ port, host = '127.0.0.1', attempts = 3, timeoutMs = 3000, }) {
     const versionUrl = `http://${host}:${port}/json/version`;
     for (let attempt = 0; attempt < attempts; attempt++) {

package/dist/src/cli/browserConfig.js

@@ -5,6 +5,8 @@ import { normalizeBrowserModelStrategy } from '../browser/modelStrategy.js';
 import { getOracleHomeDir } from '../oracleHome.js';
 const DEFAULT_BROWSER_TIMEOUT_MS = 1_200_000;
 const DEFAULT_BROWSER_INPUT_TIMEOUT_MS = 60_000;
+const DEFAULT_BROWSER_RECHECK_TIMEOUT_MS = 120_000;
+const DEFAULT_BROWSER_AUTO_REATTACH_TIMEOUT_MS = 120_000;
 const DEFAULT_CHROME_PROFILE = 'Default';
 // Ordered array: most specific models first to ensure correct selection.
 // The browser label is passed to the model picker which fuzzy-matches against ChatGPT's UI.
@@ -82,6 +84,25 @@ export async function buildBrowserConfig(options) {
         inputTimeoutMs: options.browserInputTimeout
             ? parseDuration(options.browserInputTimeout, DEFAULT_BROWSER_INPUT_TIMEOUT_MS)
             : undefined,
+        assistantRecheckDelayMs: options.browserRecheckDelay
+            ? parseDuration(options.browserRecheckDelay, 0)
+            : undefined,
+        assistantRecheckTimeoutMs: options.browserRecheckTimeout
+            ? parseDuration(options.browserRecheckTimeout, DEFAULT_BROWSER_RECHECK_TIMEOUT_MS)
+            : undefined,
+        reuseChromeWaitMs: options.browserReuseWait ? parseDuration(options.browserReuseWait, 0) : undefined,
+        profileLockTimeoutMs: options.browserProfileLockTimeout
+            ? parseDuration(options.browserProfileLockTimeout, 0)
+            : undefined,
+        autoReattachDelayMs: options.browserAutoReattachDelay
+            ? parseDuration(options.browserAutoReattachDelay, 0)
+            : undefined,
+        autoReattachIntervalMs: options.browserAutoReattachInterval
+            ? parseDuration(options.browserAutoReattachInterval, 0)
+            : undefined,
+        autoReattachTimeoutMs: options.browserAutoReattachTimeout
+            ? parseDuration(options.browserAutoReattachTimeout, DEFAULT_BROWSER_AUTO_REATTACH_TIMEOUT_MS)
+            : undefined,
         cookieSyncWaitMs: options.browserCookieWait ? parseDuration(options.browserCookieWait, 0) : undefined,
         cookieSync: options.browserNoCookieSync ? false : undefined,
         cookieNames,

package/dist/src/cli/browserDefaults.js

@@ -33,6 +33,27 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     if (isUnset('browserInputTimeout') && typeof browser.inputTimeoutMs === 'number') {
         options.browserInputTimeout = String(browser.inputTimeoutMs);
     }
+    if (isUnset('browserRecheckDelay') && typeof browser.assistantRecheckDelayMs === 'number') {
+        options.browserRecheckDelay = String(browser.assistantRecheckDelayMs);
+    }
+    if (isUnset('browserRecheckTimeout') && typeof browser.assistantRecheckTimeoutMs === 'number') {
+        options.browserRecheckTimeout = String(browser.assistantRecheckTimeoutMs);
+    }
+    if (isUnset('browserReuseWait') && typeof browser.reuseChromeWaitMs === 'number') {
+        options.browserReuseWait = String(browser.reuseChromeWaitMs);
+    }
+    if (isUnset('browserProfileLockTimeout') && typeof browser.profileLockTimeoutMs === 'number') {
+        options.browserProfileLockTimeout = String(browser.profileLockTimeoutMs);
+    }
+    if (isUnset('browserAutoReattachDelay') && typeof browser.autoReattachDelayMs === 'number') {
+        options.browserAutoReattachDelay = String(browser.autoReattachDelayMs);
+    }
+    if (isUnset('browserAutoReattachInterval') && typeof browser.autoReattachIntervalMs === 'number') {
+        options.browserAutoReattachInterval = String(browser.autoReattachIntervalMs);
+    }
+    if (isUnset('browserAutoReattachTimeout') && typeof browser.autoReattachTimeoutMs === 'number') {
+        options.browserAutoReattachTimeout = String(browser.autoReattachTimeoutMs);
+    }
     if (isUnset('browserCookieWait') && typeof browser.cookieSyncWaitMs === 'number') {
         options.browserCookieWait = String(browser.cookieSyncWaitMs);
     }