@steipete/oracle 0.16.0 → 0.16.1

package/README.md

@@ -294,7 +294,7 @@ Browser automation can open or control Chrome, so dry-runs and live runs print a
 | `--followup-model <model>`                                                     | For multi-model OpenAI/Azure parent sessions, choose which model response to continue from.                                                                                                                                                                                                                                               |
 | `--base-url <url>`                                                             | Point API runs at LiteLLM/Azure/OpenRouter/etc.                                                                                                                                                                                                                                                                                           |
 | `--chatgpt-url <url>`                                                          | Target a ChatGPT workspace/folder or Temporary Chat URL (browser).                                                                                                                                                                                                                                                                        |
-| `--browser-model-strategy <select\|current\|ignore>`                           | Control ChatGPT model selection in browser mode (current keeps the active model; ignore skips the picker).                                                                                                                                                                                                                                |
+| `--browser-model-strategy <select\|current\|ignore>`                           | Control ChatGPT model selection in browser mode. Explicit `current` keeps the active model without inheriting configured thinking time; pass `--browser-thinking-time` to change effort. `ignore` skips the picker.                                                                                                                       |
 | `--browser-manual-login`                                                       | Skip cookie copy; reuse a persistent automation profile and wait for manual ChatGPT login.                                                                                                                                                                                                                                                |
 | `--browser-attach-running`                                                     | Reuse your current local browser session through local `DevToolsActivePort` discovery; Oracle opens a dedicated tab instead of launching Chrome (defaults to `127.0.0.1:9222`, or combine with `--remote-chrome <host:port>` to hint a different local endpoint).                                                                         |
 | `--browser-tab <ref>`                                                          | Reuse an existing ChatGPT tab by `current`, target id, URL, or title substring instead of opening a new tab.                                                                                                                                                                                                                              |

package/dist/src/browser/cdpLiveness.js

@@ -0,0 +1,78 @@
+import { listRemoteChromeTargets } from "./chromeLifecycle.js";
+import { verifyDevToolsReachable } from "./profileState.js";
+/**
+ * Probe whether Chrome's DevTools endpoint (and optionally a specific target)
+ * is still reachable after a CDP client WebSocket disconnect.
+ */
+export async function probeChromeTargetLiveness(options) {
+    const host = options.host || "127.0.0.1";
+    const port = options.port;
+    if (!Number.isFinite(port) || port <= 0) {
+        return { endpointReachable: false, targetFound: null, error: "missing debug port" };
+    }
+    const verifyEndpoint = options.verifyEndpoint ?? verifyDevToolsReachable;
+    const endpoint = await verifyEndpoint({ host, port, attempts: 2, timeoutMs: 1500 });
+    if (!endpoint.ok) {
+        return {
+            endpointReachable: false,
+            targetFound: null,
+            error: endpoint.error,
+        };
+    }
+    const targetId = options.targetId?.trim();
+    if (!targetId) {
+        return { endpointReachable: true, targetFound: null };
+    }
+    try {
+        const listTargets = options.listTargets ?? listRemoteChromeTargets;
+        const targets = await listTargets({
+            host,
+            port,
+            browserWSEndpoint: options.browserWSEndpoint,
+        });
+        const match = targets.find((target) => {
+            const id = target.targetId ?? target.id;
+            return id === targetId;
+        });
+        if (!match) {
+            return { endpointReachable: true, targetFound: false };
+        }
+        return {
+            endpointReachable: true,
+            targetFound: true,
+            matchedUrl: typeof match.url === "string" ? match.url : undefined,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // Endpoint answered /json/version; treat list failures as still recoverable.
+        return { endpointReachable: true, targetFound: null, error: message };
+    }
+}
+export function isRecoverableChromeDisconnect(liveness) {
+    if (!liveness.endpointReachable) {
+        return false;
+    }
+    // Confirmed live target → recoverable.
+    if (liveness.targetFound === true) {
+        return true;
+    }
+    // Confirmed missing target → not recoverable.
+    if (liveness.targetFound === false) {
+        return false;
+    }
+    // targetFound === null:
+    // - no target id was provided (endpoint-only check) → recoverable
+    // - target list failed after a specific id was requested (error set) → fail closed
+    return !liveness.error;
+}
+export function connectionLostUserMessage(options) {
+    if (options.recoverable) {
+        return options.remote
+            ? "Remote Chrome DevTools client disconnected before oracle finished; the browser target appears still alive."
+            : "Chrome DevTools client disconnected before oracle finished; the browser target appears still alive.";
+    }
+    return options.remote
+        ? "Remote Chrome connection lost before Oracle finished."
+        : "Chrome window closed before oracle finished. Please keep it open until completion.";
+}

package/dist/src/browser/chromeLifecycle.js

@@ -406,13 +406,79 @@ 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})`);
+        for (let attempt = 0; attempt < 40; attempt += 1) {
+            await delay(25);
+            let targets;
+            try {
+                targets = (await CDP.List({ host: effectiveHost, port }));
+            }
+            catch {
+                continue;
+            }
+            if (!targets.some((target) => (target.targetId ?? target.id) === targetId)) {
+                logger(`Closed isolated browser tab (target=${targetId})`);
+                return true;
+            }
+        }
+        logger(`Browser tab close was not confirmed (target=${targetId})`);
+        return false;
     }
     catch (error) {
+        try {
+            const targets = (await CDP.List({ host: effectiveHost, port }));
+            if (!targets.some((target) => (target.targetId ?? target.id) === targetId)) {
+                logger(`Closed isolated browser tab (target=${targetId})`);
+                return true;
+            }
+        }
+        catch {
+            // Preserve the original close error below.
+        }
         const message = error instanceof Error ? error.message : String(error);
         logger(`Failed to close browser tab ${targetId}: ${message}`);
+        return false;
     }
 }
+export async function createChromePageTarget(port, logger, host) {
+    const effectiveHost = host ?? "127.0.0.1";
+    try {
+        const created = (await CDP.New({
+            host: effectiveHost,
+            port,
+            url: "about:blank",
+        }));
+        const createdTargetId = created.targetId ?? created.id;
+        if (!createdTargetId) {
+            logger("Failed to create a replacement Chrome tab.");
+            return undefined;
+        }
+        logger(`Opened replacement Chrome tab (target=${createdTargetId})`);
+        return createdTargetId;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to create a replacement Chrome tab: ${message}`);
+        return undefined;
+    }
+}
+export async function ensureChromePageTargetAfterClose(port, closingTargetId, logger, host) {
+    const effectiveHost = host ?? "127.0.0.1";
+    try {
+        const targets = (await CDP.List({ host: effectiveHost, port }));
+        const existingPageTargetId = targets
+            .filter((target) => target.type === "page")
+            .map((target) => target.targetId ?? target.id)
+            .find((targetId) => Boolean(targetId) && targetId !== closingTargetId);
+        if (existingPageTargetId) {
+            return existingPageTargetId;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to inspect Chrome tabs before closing ${closingTargetId}: ${message}`);
+    }
+    return await createChromePageTarget(port, logger, host);
+}
 export async function closeBlankChromeTabs(port, logger, host, options) {
     const effectiveHost = host ?? "127.0.0.1";
     const excluded = new Set([...(options?.excludeTargetIds ?? [])].filter((targetId) => typeof targetId === "string" && targetId.length > 0));
@@ -425,10 +491,20 @@ export async function closeBlankChromeTabs(port, logger, host, options) {
         logger(`Failed to inspect blank Chrome tabs: ${message}`);
         return;
     }
+    const preservedBlankTargetId = options?.preserveOneBlank
+        ? targets
+            .filter(isBlankPageTarget)
+            .map((target) => target.targetId ?? target.id)
+            .filter((targetId) => Boolean(targetId))
+            .sort()[0]
+        : undefined;
     let closed = 0;
     for (const target of targets) {
         const targetId = target.targetId ?? target.id;
-        if (!targetId || excluded.has(targetId) || !isBlankPageTarget(target)) {
+        if (!targetId ||
+            targetId === preservedBlankTargetId ||
+            excluded.has(targetId) ||
+            !isBlankPageTarget(target)) {
             continue;
         }
         try {
@@ -487,6 +563,11 @@ function buildChromeFlags(headless, debugBindAddress, hideWindow = false) {
         // off-screen avoids desktop disruption while preserving normal rendering.
         flags.push("--window-position=-32000,-32000");
     }
+    // Opt-in only: container/CI Chromium often cannot use the sandbox. Callers must
+    // set ORACLE_CHROME_NO_SANDBOX=1 explicitly (never default this on).
+    if (process.env.ORACLE_CHROME_NO_SANDBOX === "1") {
+        flags.push("--no-sandbox", "--disable-dev-shm-usage");
+    }
     return flags;
 }
 export function buildChromeFlagsForTest(headless, debugBindAddress, hideWindow = false) {

package/dist/src/browser/conversationUrl.js

@@ -0,0 +1,16 @@
+const CONVERSATION_ID_PATH = /\/c\/([a-zA-Z0-9-]+)(?=[/?#]|$)/;
+/**
+ * Extract a durable ChatGPT conversation id from a URL.
+ *
+ * ChatGPT can briefly expose client-created routes such as `/c/WEB:<request-id>`
+ * before replacing them with the persisted conversation URL. Those transient
+ * routes must not be used to scope assistant-response capture or reattachment.
+ */
+export function extractStableConversationIdFromUrl(url) {
+    if (!url)
+        return undefined;
+    return url.match(CONVERSATION_ID_PATH)?.[1];
+}
+export function isStableConversationUrl(url) {
+    return extractStableConversationIdFromUrl(url) !== undefined;
+}

package/dist/src/browser/conversationUrlMonitor.js

@@ -1,4 +1,5 @@
 import { delay } from "./utils.js";
+import { isStableConversationUrl } from "./conversationUrl.js";
 export function createConversationUrlMonitor(options) {
     const pollIntervalMs = options.pollIntervalMs ?? 250;
     const wait = options.wait ?? delay;
@@ -14,7 +15,7 @@ export function createConversationUrlMonitor(options) {
                 if (stopped) {
                     return false;
                 }
-                if (url && isConversationUrl(url)) {
+                if (url && isStableConversationUrl(url)) {
                     options.logger(`[browser] conversation url (${label}) = ${url}`);
                     const persist = options.persistUrl(url);
                     activePersists.add(persist);
@@ -59,6 +60,3 @@ export function createConversationUrlMonitor(options) {
         },
     };
 }
-function isConversationUrl(url) {
-    return /\/c\/[a-z0-9-]+/i.test(url);
-}

package/dist/src/browser/cookies.js

@@ -244,12 +244,14 @@ function normalizeExpiration(expires) {
     if (value <= 0) {
         return undefined;
     }
-    if (value > 1_000_000_000_000) {
-        // Learned: Chrome may store WebKit microseconds since 1601; convert to Unix seconds.
+    // Units by magnitude (do not treat Unix seconds ~1.7e9 as milliseconds):
+    // - >= 1e15: Chrome/WebKit FILETIME microseconds since 1601
+    // - >= 1e12: Unix milliseconds
+    // - else: Unix seconds (sweet-cookie / Chromium Cookie.expires)
+    if (value >= 1_000_000_000_000_000) {
         return Math.round(value / 1_000_000 - 11644473600);
     }
-    if (value > 1_000_000_000) {
-        // Likely milliseconds; normalize to seconds for CDP.
+    if (value >= 1_000_000_000_000) {
         return Math.round(value / 1000);
     }
     return Math.round(value);

package/dist/src/browser/index.js

@@ -4,7 +4,7 @@ import os from "node:os";
 import net from "node:net";
 import { resolveBrowserConfig } from "./config.js";
 import { copyChromeProfile } from "./profileCopy.js";
-import { launchChrome, registerTerminationHooks, positionChromeWindowOffscreen, connectToRemoteChrome, connectWithNewTab, closeTab, closeRemoteChromeTarget, closeBlankChromeTabs, } from "./chromeLifecycle.js";
+import { launchChrome, registerTerminationHooks, positionChromeWindowOffscreen, connectToRemoteChrome, connectWithNewTab, closeTab, createChromePageTarget, ensureChromePageTargetAfterClose, closeBlankChromeTabs, } from "./chromeLifecycle.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
 import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureChatMode, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
 import { INPUT_SELECTORS } from "./constants.js";
@@ -19,6 +19,7 @@ import { BrowserAutomationError } from "../oracle/errors.js";
 import { alignPromptEchoPair, buildPromptEchoMatcher } from "./reattachHelpers.js";
 import { buildConversationTurnCountExpression } from "./conversationTurns.js";
 import { cleanupStaleProfileState, acquireProfileRunLock, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, terminateRecordedChromeForProfile, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
+import { connectionLostUserMessage, isRecoverableChromeDisconnect, probeChromeTargetLiveness, } from "./cdpLiveness.js";
 import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLeaseRegistry.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
 import { collectGeneratedImageArtifacts } from "./chatgptImages.js";
@@ -32,6 +33,7 @@ import { archiveChatGptConversation, resolveBrowserArchiveDecision, } from "./ac
 import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, isManualLoginProfileInitialized, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { describeBrowserControlPlan, formatBrowserControlPlan } from "./controlPlan.js";
 import { createConversationUrlMonitor, } from "./conversationUrlMonitor.js";
+import { extractStableConversationIdFromUrl as extractConversationIdFromUrl, isStableConversationUrl as isConversationUrl, } from "./conversationUrl.js";
 export { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./constants.js";
 export { parseDuration, delay, normalizeChatgptUrl, isTemporaryChatUrl } from "./utils.js";
 export { formatThinkingLog, formatThinkingWaitingLog, buildThinkingStatusExpressionForTest, readThinkingStatusForTest, sanitizeThinkingText, startThinkingStatusMonitorForTest, } from "./actions/thinkingStatus.js";
@@ -535,7 +537,17 @@ async function closeRemoteConnectionAfterRun(options) {
     }
 }
 function shouldCloseOwnedRunTargetAfterRun(options) {
-    return options.runStatus === "complete" && options.ownsTarget && !options.keepBrowser;
+    return (options.runStatus === "complete" &&
+        options.ownsTarget &&
+        (Boolean(options.closeOwnedTabOnComplete) || !options.keepBrowser));
+}
+function shouldCleanupBlankTabsAfterLastLease(options) {
+    return (options.runStatus === "complete" &&
+        options.ownsTarget &&
+        !options.connectionClosedUnexpectedly &&
+        options.manualLogin &&
+        options.keepBrowser &&
+        Boolean(options.chromePort));
 }
 function buildSkippedModelSelectionEvidence(desiredModel, strategy) {
     return {
@@ -796,8 +808,38 @@ export async function runBrowserMode(options) {
         const disconnectPromise = new Promise((_, reject) => {
             client?.on("disconnect", () => {
                 connectionClosedUnexpectedly = true;
-                logger("Chrome window closed; attempting to abort run.");
-                reject(new Error("Chrome window closed before oracle finished. Please keep it open until completion."));
+                void (async () => {
+                    const liveness = await probeChromeTargetLiveness({
+                        host: chromeHost,
+                        port: chrome.port,
+                        targetId: lastTargetId ?? isolatedTargetId,
+                    });
+                    const recoverable = isRecoverableChromeDisconnect(liveness);
+                    if (recoverable) {
+                        logger("CDP client disconnected; Chrome/target still reachable. Leaving run recoverable for reattach.");
+                    }
+                    else {
+                        logger("Chrome window closed; attempting to abort run.");
+                    }
+                    reject(new BrowserAutomationError(connectionLostUserMessage({ recoverable }), {
+                        stage: "connection-lost",
+                        recoverableDisconnect: recoverable,
+                        disconnectCause: recoverable ? "cdp-client-disconnect" : "chrome-closed",
+                        runtime: {
+                            chromePid: chrome.pid,
+                            chromePort: chrome.port,
+                            chromeHost,
+                            userDataDir,
+                            chromeTargetId: lastTargetId ?? isolatedTargetId ?? undefined,
+                            tabUrl: liveness.matchedUrl ?? lastUrl,
+                            conversationId: (liveness.matchedUrl ?? lastUrl)
+                                ? extractConversationIdFromUrl(liveness.matchedUrl ?? lastUrl ?? "")
+                                : undefined,
+                            promptSubmitted,
+                            controllerPid: process.pid,
+                        },
+                    }));
+                })();
             });
         });
         const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
@@ -1727,19 +1769,34 @@ export async function runBrowserMode(options) {
             throw normalizedError;
         }
         if ((config.debug || process.env.CHATGPT_DEVTOOLS_TRACE === "1") && normalizedError.stack) {
-            logger(`Chrome window closed before completion: ${normalizedError.message}`);
+            logger(`Chrome connection lost before completion: ${normalizedError.message}`);
             logger(normalizedError.stack);
         }
         await emitRuntimeHint();
-        throw new BrowserAutomationError("Chrome window closed before oracle finished. Please keep it open until completion.", {
+        if (normalizedError instanceof BrowserAutomationError &&
+            normalizedError.details?.stage === "connection-lost") {
+            throw normalizedError;
+        }
+        const liveness = await probeChromeTargetLiveness({
+            host: chromeHost,
+            port: chrome.port,
+            targetId: lastTargetId ?? isolatedTargetId,
+        });
+        const recoverable = isRecoverableChromeDisconnect(liveness);
+        throw new BrowserAutomationError(connectionLostUserMessage({ recoverable }), {
             stage: "connection-lost",
+            recoverableDisconnect: recoverable,
+            disconnectCause: recoverable ? "cdp-client-disconnect" : "chrome-closed",
             runtime: {
                 chromePid: chrome.pid,
                 chromePort: chrome.port,
                 chromeHost,
                 userDataDir,
                 chromeTargetId: lastTargetId,
-                tabUrl: lastUrl,
+                tabUrl: liveness.matchedUrl ?? lastUrl,
+                conversationId: (liveness.matchedUrl ?? lastUrl)
+                    ? extractConversationIdFromUrl(liveness.matchedUrl ?? lastUrl ?? "")
+                    : undefined,
                 promptSubmitted,
                 controllerPid: process.pid,
             },
@@ -1758,15 +1815,12 @@ export async function runBrowserMode(options) {
         // 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 (shouldCloseOwnedRunTargetAfterRun({
+        const shouldCloseOwnedRunTarget = shouldCloseOwnedRunTargetAfterRun({
             runStatus,
             ownsTarget,
             keepBrowser: effectiveKeepBrowser,
-        }) &&
-            isolatedTargetId &&
-            chrome?.port) {
-            await closeTab(chrome.port, isolatedTargetId, logger, chromeHost).catch(() => undefined);
-        }
+            closeOwnedTabOnComplete: options.closeOwnedTabOnComplete,
+        });
         let keepBrowserOpen = shouldKeepLocalBrowserOpen({
             effectiveKeepBrowser,
             preserveBrowserOnError,
@@ -1784,18 +1838,6 @@ export async function runBrowserMode(options) {
             }
             return otherActiveBrowserTabLeases;
         };
-        if (runStatus === "complete" &&
-            manualLogin &&
-            !connectionClosedUnexpectedly &&
-            chrome?.port &&
-            ownsTarget) {
-            const otherLeasesActive = await hasOtherActiveLeases().catch(() => true);
-            if (!otherLeasesActive) {
-                await closeBlankChromeTabs(chrome.port, logger, chromeHost, {
-                    excludeTargetIds: [isolatedTargetId, lastTargetId],
-                }).catch(() => undefined);
-            }
-        }
         if (!keepBrowserOpen && manualLogin && tabLease) {
             const cleanupLockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
             if (cleanupLockTimeoutMs > 0) {
@@ -1813,10 +1855,55 @@ export async function runBrowserMode(options) {
                 terminatedRecordedChrome = await terminateRecordedChromeForProfile(userDataDir, logger).catch(() => false);
             }
         }
+        const closeOwnedRunTarget = async () => {
+            if (!shouldCloseOwnedRunTarget || !isolatedTargetId || !chrome?.port) {
+                return;
+            }
+            const safeToClose = !effectiveKeepBrowser ||
+                Boolean(await ensureChromePageTargetAfterClose(chrome.port, isolatedTargetId, logger, chromeHost));
+            if (!safeToClose) {
+                logger(`[browser] Leaving completed browser tab open because Chrome has no replacement page target.`);
+                return;
+            }
+            const closeConfirmed = await closeTab(chrome.port, isolatedTargetId, logger, chromeHost);
+            if (!closeConfirmed && effectiveKeepBrowser) {
+                const replacementTargetId = await createChromePageTarget(chrome.port, logger, chromeHost);
+                if (!replacementTargetId) {
+                    logger(`[browser] Chrome page retention could not be verified after closing ${isolatedTargetId}.`);
+                }
+            }
+        };
+        const cleanupBlankTabs = async () => {
+            if (!shouldCleanupBlankTabsAfterLastLease({
+                runStatus,
+                ownsTarget,
+                connectionClosedUnexpectedly,
+                manualLogin,
+                keepBrowser: effectiveKeepBrowser,
+                chromePort: chrome?.port,
+            }) ||
+                !chrome?.port) {
+                return;
+            }
+            await closeBlankChromeTabs(chrome.port, logger, chromeHost, {
+                excludeTargetIds: [isolatedTargetId, lastTargetId],
+                preserveOneBlank: true,
+            });
+        };
         if (tabLease) {
             const handle = tabLease;
             tabLease = null;
-            await handle.release().catch(() => undefined);
+            const onRelease = async ({ isLastLease }) => {
+                await closeOwnedRunTarget();
+                if (isLastLease) {
+                    await cleanupBlankTabs();
+                }
+            };
+            await handle.release({ onRelease }).catch(() => undefined);
+        }
+        else {
+            await closeOwnedRunTarget();
+            await cleanupBlankTabs();
         }
         removeDialogHandler?.();
         removeTerminationHooks?.();
@@ -2869,15 +2956,27 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             }
             throw normalizedError;
         }
-        throw new BrowserAutomationError("Remote Chrome connection lost before Oracle finished.", {
+        const liveness = await probeChromeTargetLiveness({
+            host,
+            port,
+            targetId: remoteTargetId,
+            browserWSEndpoint,
+        });
+        const recoverable = isRecoverableChromeDisconnect(liveness);
+        throw new BrowserAutomationError(connectionLostUserMessage({ recoverable, remote: true }), {
             stage: "connection-lost",
+            recoverableDisconnect: recoverable,
+            disconnectCause: recoverable ? "cdp-client-disconnect" : "chrome-closed",
             runtime: {
                 chromeHost: host,
                 chromePort: port,
                 chromeBrowserWSEndpoint: browserWSEndpoint,
                 chromeProfileRoot,
                 chromeTargetId: remoteTargetId ?? undefined,
-                tabUrl: lastUrl,
+                tabUrl: liveness.matchedUrl ?? lastUrl,
+                conversationId: (liveness.matchedUrl ?? lastUrl)
+                    ? extractConversationIdFromUrl(liveness.matchedUrl ?? lastUrl ?? "")
+                    : undefined,
                 promptSubmitted,
                 controllerPid: process.pid,
             },
@@ -2897,17 +2996,40 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             // ignore
         }
         removeDialogHandler?.();
+        const keepRemoteBrowser = Boolean(config.keepBrowser);
+        const shouldCloseOwnedRemoteTarget = shouldCloseOwnedRunTargetAfterRun({
+            runStatus,
+            ownsTarget,
+            keepBrowser: keepRemoteBrowser,
+            closeOwnedTabOnComplete: options.closeOwnedTabOnComplete,
+        });
+        const closeOwnedRemoteTarget = async () => {
+            if (!shouldCloseOwnedRemoteTarget || !remoteTargetId) {
+                return;
+            }
+            const safeToClose = !keepRemoteBrowser ||
+                Boolean(await ensureChromePageTargetAfterClose(port, remoteTargetId, logger, host));
+            if (!safeToClose) {
+                logger(`[browser] Leaving completed remote browser tab open because Chrome has no replacement page target.`);
+                return;
+            }
+            const closeConfirmed = await closeTab(port, remoteTargetId, logger, host);
+            if (!closeConfirmed && keepRemoteBrowser) {
+                const replacementTargetId = await createChromePageTarget(port, logger, host);
+                if (!replacementTargetId) {
+                    logger(`[browser] Remote Chrome page retention could not be verified after closing ${remoteTargetId}.`);
+                }
+            }
+        };
         if (tabLease) {
             const handle = tabLease;
             tabLease = null;
-            await handle.release().catch(() => undefined);
+            await handle
+                .release({ onRelease: async () => closeOwnedRemoteTarget() })
+                .catch(() => undefined);
         }
-        if (shouldCloseOwnedRunTargetAfterRun({
-            runStatus,
-            ownsTarget,
-            keepBrowser: Boolean(config.keepBrowser),
-        })) {
-            await closeRemoteChromeTarget(host, port, remoteTargetId ?? undefined, logger);
+        else {
+            await closeOwnedRemoteTarget();
         }
         // Don't kill remote Chrome - it's not ours to manage
         const totalSeconds = (Date.now() - startedAt) / 1000;
@@ -2930,6 +3052,7 @@ export const __test__ = {
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
     resolveManualLoginWaitMs,
+    shouldCleanupBlankTabsAfterLastLease,
     shouldCloseOwnedRunTargetAfterRun,
     shouldKeepLocalBrowserOpen,
 };
@@ -3129,9 +3252,6 @@ async function readConversationTurnCount(Runtime, logger) {
     }
     return null;
 }
-function isConversationUrl(url) {
-    return /\/c\/[a-z0-9-]+/i.test(url);
-}
 function describeDevtoolsFirewallHint(host, port) {
     if (!isWsl())
         return null;
@@ -3152,10 +3272,6 @@ function isWsl() {
         return true;
     return os.release().toLowerCase().includes("microsoft");
 }
-function extractConversationIdFromUrl(url) {
-    const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
-    return match?.[1];
-}
 async function resolveUserDataBaseDir() {
     // On WSL, Chrome launched via Windows can choke on UNC paths; prefer a Windows-backed temp folder.
     if (isWsl()) {

package/dist/src/browser/liveTabs.js

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import { ANSWER_SELECTORS, ASSISTANT_ROLE_SELECTOR, INPUT_SELECTORS, MODEL_BUTTON_SELECTOR, SEND_BUTTON_SELECTORS, STOP_BUTTON_SELECTOR, } from "./constants.js";
 import { captureAssistantMarkdown, readAssistantSnapshot } from "./actions/assistantResponse.js";
 import { buildConversationTurnListExpression } from "./conversationTurns.js";
+import { extractStableConversationIdFromUrl } from "./conversationUrl.js";
 import { delay } from "./utils.js";
 export const DEFAULT_REMOTE_CHROME_HOST = "127.0.0.1";
 export const DEFAULT_REMOTE_CHROME_PORT = 9222;
@@ -481,8 +482,7 @@ export async function harvestChatGptTab(options = {}) {
     }
 }
 export function extractConversationIdFromUrl(url) {
-    const match = normalizeUrl(url).match(/\/c\/([^/?#]+)/);
-    return match?.[1] ?? undefined;
+    return extractStableConversationIdFromUrl(normalizeUrl(url));
 }
 export function formatBrowserTabState(tab) {
     return tab.state ?? classifyTabState(tab);

package/dist/src/browser/reattachHelpers.js

@@ -1,5 +1,6 @@
 import { CONVERSATION_TURN_SELECTOR } from "./constants.js";
 import { buildConversationTurnCountExpression } from "./conversationTurns.js";
+import { extractStableConversationIdFromUrl } from "./conversationUrl.js";
 import { delay } from "./utils.js";
 import { readAssistantSnapshot } from "./pageActions.js";
 export function pickTarget(targets, runtime) {
@@ -29,14 +30,11 @@ export function pickTarget(targets, runtime) {
     return targets.find((t) => t.type === "page") ?? targets[0];
 }
 export function extractConversationIdFromUrl(url) {
-    if (!url)
-        return undefined;
-    const match = url.match(/\/c\/([a-zA-Z0-9-]+)/);
-    return match?.[1];
+    return extractStableConversationIdFromUrl(url);
 }
 export function buildConversationUrl(runtime, baseUrl) {
     if (runtime.tabUrl) {
-        if (runtime.tabUrl.includes("/c/")) {
+        if (extractConversationIdFromUrl(runtime.tabUrl)) {
             return runtime.tabUrl;
         }
         return null;

package/dist/src/browser/reattachability.js

@@ -1,3 +1,4 @@
+import { isStableConversationUrl } from "./conversationUrl.js";
 /**
  * True when the URL points at a specific ChatGPT conversation (`/c/<id>`) on
  * chatgpt.com or chat.openai.com. Rejects home, project shell, and external
@@ -17,7 +18,7 @@ export function isRecoverableChatGptConversationUrl(candidate) {
         if (url.hostname !== "chatgpt.com" && url.hostname !== "chat.openai.com") {
             return false;
         }
-        return /(?:^|\/)c\/[^/]+/.test(url.pathname);
+        return isStableConversationUrl(url.pathname);
     }
     catch {
         return false;

package/dist/src/browser/tabLeaseRegistry.js

@@ -61,7 +61,7 @@ export async function acquireBrowserTabLease(profileDir, options, deps = {}) {
             options.logger?.(`[browser] Acquired ChatGPT browser slot ${leaseId.slice(0, 8)} (${maxConcurrentTabs} max).`);
             return {
                 id: leaseId,
-                release: async () => releaseBrowserTabLease(profileDir, leaseId, options.logger),
+                release: async (releaseOptions) => releaseBrowserTabLease(profileDir, leaseId, options.logger, releaseOptions),
                 update: async (patch) => updateBrowserTabLease(profileDir, leaseId, patch),
             };
         }
@@ -86,11 +86,17 @@ export async function updateBrowserTabLease(profileDir, leaseId, patch) {
         await writeRegistry(profileDir, { version: 1, leases });
     });
 }
-export async function releaseBrowserTabLease(profileDir, leaseId, logger) {
+export async function releaseBrowserTabLease(profileDir, leaseId, logger, options = {}) {
     await withRegistryLock(profileDir, async () => {
         const registry = await readRegistry(profileDir);
-        const leases = registry.leases.filter((lease) => lease.id !== leaseId);
+        const active = pruneStaleLeases(registry.leases, {
+            nowMs: Date.now(),
+            staleMs: DEFAULT_STALE_MS,
+            isProcessAlive,
+        });
+        const leases = active.filter((lease) => lease.id !== leaseId);
         await writeRegistry(profileDir, { version: 1, leases });
+        await options.onRelease?.({ isLastLease: leases.length === 0 });
     }).catch(() => undefined);
     logger?.(`[browser] Released ChatGPT browser slot ${leaseId.slice(0, 8)}.`);
 }

package/dist/src/cli/browserDefaults.js

@@ -11,6 +11,7 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     };
     const attachRunningRequested = options.browserAttachRunning === true ||
         (isUnset("browserAttachRunning") && browser.attachRunning === true);
+    const currentModelRequestedByCli = options.browserModelStrategy === "current" && getSource("browserModelStrategy") === "cli";
     const configuredChatgptUrl = browser.chatgptUrl ?? browser.url;
     const cliChatgptSet = options.chatgptUrl !== undefined || options.browserUrl !== undefined;
     if (isUnset("chatgptUrl") && !cliChatgptSet && configuredChatgptUrl !== undefined) {
@@ -89,7 +90,9 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     if (isUnset("browserModelStrategy") && browser.modelStrategy !== undefined) {
         options.browserModelStrategy = browser.modelStrategy;
     }
-    if (isUnset("browserThinkingTime") && browser.thinkingTime !== undefined) {
+    if (!currentModelRequestedByCli &&
+        isUnset("browserThinkingTime") &&
+        browser.thinkingTime !== undefined) {
         options.browserThinkingTime = normalizeThinkingTimeLevel(browser.thinkingTime) ?? undefined;
     }
     if (isUnset("browserResearch") && browser.researchMode !== undefined) {

package/dist/src/cli/sessionRunner.js

@@ -469,6 +469,41 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 response: { status: "running", incompleteReason: "chrome-disconnected" },
             });
             logBrowserReattachGuidance(recoverableRuntime);
+            // Only auto-reattach when liveness classified the target as still alive.
+            // Closed-Chrome disconnects stay running + guidance but must not enter a
+            // futile resume loop (fail closed on availability).
+            const recoverableDisconnect = userError.details
+                ?.recoverableDisconnect === true;
+            if (!recoverableDisconnect) {
+                log(dim("Skipping auto-reattach: disconnect classified as non-recoverable."));
+                return;
+            }
+            // Connection-lost should attempt the same recovery path as assistant-timeout.
+            // When auto-reattach interval is unset, still try a single resume so a live
+            // Chrome/target can be harvested instead of leaving the session permanently running.
+            const configuredIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
+            const connectionLostIntervalMs = configuredIntervalMs > 0
+                ? configuredIntervalMs
+                : Math.max(1_000, Math.min(browserConfig?.timeoutMs ?? 30_000, 30_000));
+            const success = await autoReattachUntilComplete({
+                sessionMeta,
+                runtime: recoverableRuntime ?? undefined,
+                browserConfig: {
+                    ...browserConfig,
+                    autoReattachIntervalMs: connectionLostIntervalMs,
+                    autoReattachDelayMs: browserConfig?.autoReattachDelayMs ?? 0,
+                    autoReattachTimeoutMs: browserConfig?.autoReattachTimeoutMs ?? browserConfig?.timeoutMs ?? 120_000,
+                },
+                browserMetadata: currentBrowser,
+                runOptions,
+                modelForStatus,
+                notificationSettings,
+                log,
+                maxAttempts: configuredIntervalMs > 0 ? undefined : 1,
+            });
+            if (success) {
+                return;
+            }
             return;
         }
         if (assistantTimeout && mode === "browser" && browserCanReattach) {
@@ -833,7 +868,7 @@ async function writeAssistantOutput(targetPath, content, log) {
         log(dim(`write-output failed (${reason}); session completed anyway.`));
     }
 }
-async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, }) {
+async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, maxAttempts, }) {
     if (!runtime || !browserConfig) {
         log(dim("Auto-reattach disabled: missing runtime or browser config."));
         return false;
@@ -848,11 +883,19 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
         120_000;
     const maxTotalMs = 2 * 60 * 60 * 1000; // 2h hard cap; avoid infinite polling by default.
     const maxDeadline = Date.now() + maxTotalMs;
+    const attemptLimit = typeof maxAttempts === "number" && maxAttempts > 0
+        ? Math.floor(maxAttempts)
+        : Number.POSITIVE_INFINITY;
     if (delayMs > 0) {
         log(dim(`Auto-reattach starting in ${formatElapsed(delayMs)}...`));
         await wait(delayMs);
     }
-    log(dim(`Auto-reattach will stop after ${formatElapsed(maxTotalMs)} if no answer is captured.`));
+    if (Number.isFinite(attemptLimit)) {
+        log(dim(`Auto-reattach will try up to ${attemptLimit} attempt(s).`));
+    }
+    else {
+        log(dim(`Auto-reattach will stop after ${formatElapsed(maxTotalMs)} if no answer is captured.`));
+    }
     const logger = ((message) => {
         if (message) {
             log(dim(message));
@@ -943,6 +986,10 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
             const message = error instanceof Error ? error.message : String(error);
             log(dim(`Auto-reattach attempt ${attempt} failed: ${message}`));
         }
+        if (attempt >= attemptLimit) {
+            log(dim(`Auto-reattach stopped after ${attempt} attempt(s) without capturing an answer.`));
+            return false;
+        }
         const remainingAfterAttemptMs = maxDeadline - Date.now();
         if (remainingAfterAttemptMs <= 0) {
             log(dim(`Auto-reattach stopped after ${formatElapsed(maxTotalMs)} without capturing an answer.`));

package/dist/src/remote/server.js

@@ -189,6 +189,9 @@ export async function createRemoteServer(options = {}, deps = {}) {
                 }
             });
             automationLogger.verbose = Boolean(payload.options.verbose);
+            // Preserve an explicit request to leave the completed conversation tab
+            // open before the service forces `keepBrowser` for process lifetime.
+            const clientRequestedKeepBrowser = payload.browserConfig?.keepBrowser === true;
             // Remote runs always rely on the host's own Chrome profile; ignore any inline cookie transfer.
             if (payload.browserConfig) {
                 payload.browserConfig.inlineCookies = null;
@@ -212,6 +215,11 @@ export async function createRemoteServer(options = {}, deps = {}) {
                 attachments,
                 fallbackSubmission,
                 config: payload.browserConfig,
+                // `keepBrowser` above preserves the authenticated shared Chrome
+                // process. This separate service policy closes only a successfully
+                // captured tab owned by this run, preventing one renderer leak per
+                // request while incomplete/reattachable tabs remain untouched.
+                closeOwnedTabOnComplete: Boolean(options.manualLoginDefault && !clientRequestedKeepBrowser),
                 log: automationLogger,
                 heartbeatIntervalMs: payload.options.heartbeatIntervalMs,
                 verbose: payload.options.verbose,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.6 Sol, GPT-5.6, GPT-5.5 Pro, GPT-5.5, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
   "homepage": "https://askoracle.sh",
@@ -58,14 +58,14 @@
   },
   "dependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@google/genai": "^2.10.0",
+    "@google/genai": "^2.13.0",
     "@google/generative-ai": "^0.24.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@steipete/sweet-cookie": "^0.4.0",
     "chalk": "^5.6.2",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.34.0",
-    "clipboardy": "^5.3.1",
+    "clipboardy": "^5.3.2",
     "commander": "^15.0.0",
     "dotenv": "^17.4.2",
     "fast-glob": "^3.3.3",
@@ -74,7 +74,7 @@
     "json5": "^2.2.3",
     "kleur": "^4.1.5",
     "markdansi": "0.3.2",
-    "openai": "^6.45.0",
+    "openai": "^6.48.0",
     "osc-progress": "^0.3.2",
     "qs": "^6.15.3",
     "shiki": "^4.3.1",
@@ -88,13 +88,13 @@
     "@types/inquirer": "^9.0.10",
     "@types/node": "^26.1.1",
     "@vitest/coverage-v8": "4.1.10",
-    "devtools-protocol": "0.0.1658499",
+    "devtools-protocol": "0.0.1666840",
     "es-toolkit": "^1.49.0",
     "esbuild": "^0.28.1",
-    "oxfmt": "0.58.0",
-    "oxlint": "^1.73.0",
+    "oxfmt": "0.60.0",
+    "oxlint": "^1.75.0",
     "puppeteer-core": "^25.3.0",
-    "tsx": "^4.23.0",
+    "tsx": "^4.23.1",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },