@steipete/oracle 0.16.0 → 0.17.0

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";
@@ -69,6 +71,9 @@ function classifyPreservedBrowserError(error, headless) {
 function shouldPreserveBrowserOnError(error, headless) {
     return classifyPreservedBrowserError(error, headless) !== null;
 }
+function normalizeAuthenticatedModelSelectionError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
 function shouldKeepLocalBrowserOpen(options) {
     if (options.usingCopiedProfile)
         return false;
@@ -535,7 +540,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 +811,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]);
@@ -1012,11 +1057,9 @@ export async function runBrowserMode(options) {
                     }
                 },
             })).catch((error) => {
-                const base = error instanceof Error ? error.message : String(error);
-                const hint = appliedCookies === 0
-                    ? " No cookies were applied; log in to ChatGPT in Chrome or provide inline cookies (--browser-inline-cookies[(-file)] or ORACLE_BROWSER_COOKIES_JSON)."
-                    : "";
-                throw new Error(`${base}${hint}`);
+                // Login has already been verified above. Preserve the picker failure instead of
+                // misdiagnosing an unavailable model as missing cookies.
+                throw normalizeAuthenticatedModelSelectionError(error);
             });
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
             logger(`Prompt textarea ready (after model switch, ${promptText.length.toLocaleString()} chars queued)`);
@@ -1300,7 +1343,11 @@ export async function runBrowserMode(options) {
             if (conversationUrl && isConversationUrl(conversationUrl)) {
                 logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
                 await raceWithDisconnect(Page.navigate({ url: conversationUrl }));
-                await raceWithDisconnect(delay(1000));
+                await raceWithDisconnect(waitForResumedConversationHydration(Runtime, recheckTimeoutMs || 30_000, logger, {
+                    requirePriorTurns: true,
+                    requirePromptReady: false,
+                    expectedConversationUrl: conversationUrl,
+                }));
             }
             // Validate session before attempting recheck - sessions can expire during the delay
             const sessionValid = await validateChatGPTSession(Runtime, logger);
@@ -1727,19 +1774,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 +1820,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 +1843,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 +1860,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?.();
@@ -2520,7 +2612,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 lastUrl = conversationUrl;
                 logger(`[browser] Rechecking assistant response at ${conversationUrl}`);
                 await Page.navigate({ url: conversationUrl });
-                await delay(1000);
+                await waitForResumedConversationHydration(Runtime, recheckTimeoutMs || 30_000, logger, {
+                    requirePriorTurns: true,
+                    requirePromptReady: false,
+                    expectedConversationUrl: conversationUrl,
+                });
             }
             // Validate session before attempting recheck - sessions can expire during the delay
             const sessionValid = await validateChatGPTSession(Runtime, logger);
@@ -2869,15 +2965,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 +3005,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;
@@ -2929,9 +3060,12 @@ export const __test__ = {
     isManualLoginProfileInitialized,
     isImageOnlyUiChromeText,
     listIgnoredRemoteChromeFlags,
+    normalizeAuthenticatedModelSelectionError,
     resolveManualLoginWaitMs,
+    shouldCleanupBlankTabsAfterLastLease,
     shouldCloseOwnedRunTargetAfterRun,
     shouldKeepLocalBrowserOpen,
+    waitForAssistantResponseWithReload,
 };
 export { syncCookies } from "./cookies.js";
 export { navigateToChatGPT, ensureNotBlocked, ensurePromptReady, ensureModelSelection, submitPrompt, waitForAssistantResponse, captureAssistantMarkdown, uploadAttachmentFile, waitForAttachmentCompletion, } from "./pageActions.js";
@@ -2963,7 +3097,11 @@ async function waitForAssistantResponseWithReload(Runtime, Page, timeoutMs, logg
         }
         logger("Assistant response stalled; reloading conversation and retrying once");
         await Page.navigate({ url: conversationUrl });
-        await delay(1000);
+        await waitForResumedConversationHydration(Runtime, timeoutMs, logger, {
+            requirePriorTurns: true,
+            requirePromptReady: false,
+            expectedConversationUrl: conversationUrl,
+        });
         return await waitForAssistantResponse(Runtime, timeoutMs, logger, minTurnIndex, expectedConversationId);
     }
 }
@@ -3129,9 +3267,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 +3287,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/modelDisplay.js

@@ -0,0 +1,67 @@
+function cleanLabel(value) {
+    const label = value?.trim();
+    return label ? label : null;
+}
+function sameLabel(left, right) {
+    return left.localeCompare(right, undefined, { sensitivity: "accent" }) === 0;
+}
+/**
+ * Describe what a browser run will try to select without presenting the target as observed fact.
+ */
+export function formatBrowserModelTarget({ model, desiredModel, modelStrategy, }) {
+    const requested = cleanLabel(model) ?? "n/a";
+    if (modelStrategy === "current" || modelStrategy === "ignore") {
+        return `picker=${modelStrategy}; requested=${requested}`;
+    }
+    const target = cleanLabel(desiredModel);
+    if (!target) {
+        return requested;
+    }
+    return `target=${target}; requested=${requested}`;
+}
+/**
+ * Prefer picker evidence only when Oracle verified it. Otherwise retain the requested CLI key.
+ * In particular, a bare `Pro` picker label must not be expanded to a server-side model version.
+ */
+export function resolveBrowserModelDisplayName({ model, evidence, }) {
+    const verifiedLabel = evidence?.verified ? cleanLabel(evidence.resolvedLabel) : null;
+    return verifiedLabel ?? cleanLabel(model) ?? "n/a";
+}
+export function formatBrowserModelWithRequestedKey(input) {
+    const displayName = resolveBrowserModelDisplayName(input);
+    const requested = cleanLabel(input.model);
+    if (!requested || sameLabel(displayName, requested)) {
+        return displayName;
+    }
+    return `${displayName} (requested ${requested})`;
+}
+export function resolveSessionBrowserModelDisplayName(metadata, model = metadata.model) {
+    const sessionModel = cleanLabel(metadata.model);
+    const requestedModel = cleanLabel(model);
+    const evidenceApplies = requestedModel === null
+        ? sessionModel === null
+        : sessionModel !== null && sameLabel(requestedModel, sessionModel);
+    return resolveBrowserModelDisplayName({
+        model,
+        evidence: evidenceApplies ? metadata.browser?.modelSelection : undefined,
+    });
+}
+export function formatSessionBrowserModelWithRequestedKey(metadata, model = metadata.model) {
+    const sessionModel = cleanLabel(metadata.model);
+    const requestedModel = cleanLabel(model);
+    const evidenceApplies = requestedModel === null
+        ? sessionModel === null
+        : sessionModel !== null && sameLabel(requestedModel, sessionModel);
+    return formatBrowserModelWithRequestedKey({
+        model,
+        evidence: evidenceApplies ? metadata.browser?.modelSelection : undefined,
+    });
+}
+export function formatBrowserModelSelectionEvidence(evidence, model) {
+    const requestedKey = cleanLabel(model) ?? "(none)";
+    const target = cleanLabel(evidence.requestedModel) ?? "(none)";
+    const resolvedLabel = cleanLabel(evidence.resolvedLabel) ?? "(unavailable)";
+    const strategy = evidence.strategy ?? "(default)";
+    const verified = evidence.verified ? "yes" : "no";
+    return `requestedKey=${requestedKey}; target=${target}; resolvedLabel=${resolvedLabel}; status=${evidence.status}; strategy=${strategy}; verified=${verified}; source=${evidence.source}; capturedAt=${evidence.capturedAt}`;
+}

package/dist/src/browser/reattach.js

@@ -2,7 +2,7 @@ import CDP from "chrome-remote-interface";
 import os from "node:os";
 import path from "node:path";
 import { mkdtemp, mkdir, rm } from "node:fs/promises";
-import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, } from "./pageActions.js";
+import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, waitForResumedConversationHydration, } from "./pageActions.js";
 import { launchChrome, connectToChrome, positionChromeWindowOffscreen, connectToRemoteChromeTarget, listRemoteChromeTargets, } from "./chromeLifecycle.js";
 import { resolveBrowserConfig } from "./config.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
@@ -98,6 +98,13 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         const pingTimeoutMs = Math.min(5_000, Math.max(1_500, Math.floor(timeoutMs * 0.05)));
         await withTimeout(Runtime.evaluate({ expression: "1+1", returnByValue: true }), pingTimeoutMs, "Reattach target did not respond");
         await ensureConversationOpen();
+        const waitForHydration = deps.waitForConversationHydration ?? waitForResumedConversationHydration;
+        const expectedConversationUrl = buildConversationUrl(runtime, resolveBrowserConfig(config ?? {}).url);
+        await waitForHydration(Runtime, timeoutMs, logger, {
+            requirePriorTurns: true,
+            requirePromptReady: false,
+            expectedConversationUrl: expectedConversationUrl ?? undefined,
+        });
         const minTurnIndex = (await readPromptPreviewTurnIndex(Runtime, deps.promptPreview)) ??
             (deps.promptPreview ? null : await readConversationTurnIndex(Runtime, logger));
         if (config?.researchMode === "deep") {
@@ -226,6 +233,12 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
         }
         await waitForLocationChange(Runtime, 15_000);
     }
+    const waitForHydration = deps.waitForConversationHydration ?? waitForResumedConversationHydration;
+    await waitForHydration(Runtime, resolved.inputTimeoutMs, logger, {
+        requirePriorTurns: true,
+        requirePromptReady: false,
+        expectedConversationUrl: conversationUrl ?? undefined,
+    });
     const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
     const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
     const timeoutMs = resolved.timeoutMs ?? 120_000;

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/recoverConversation.js

@@ -67,7 +67,8 @@ export function isRecoveredConversationHarvestReady(harvested) {
         (typeof harvested.lastAssistantTurnIndex === "number" &&
             typeof harvested.lastUserTurnIndex === "number" &&
             harvested.lastAssistantTurnIndex > harvested.lastUserTurnIndex);
-    return (harvested.stopExists === true ||
+    const hasHydratedUserTurn = typeof harvested.lastUserTurnIndex === "number" && harvested.lastUserTurnIndex >= 0;
+    return ((harvested.stopExists === true && hasHydratedUserTurn) ||
         ((harvested.assistantCount ?? 0) > 0 &&
             assistantFollowsLatestUser &&
             latestAssistant.trim().length > 0 &&

package/dist/src/browser/sessionRunner.js

@@ -5,6 +5,7 @@ import { runBrowserMode } from "../browserMode.js";
 import { assembleBrowserPrompt } from "./prompt.js";
 import { BrowserAutomationError } from "../oracle/errors.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
+import { formatBrowserModelSelectionEvidence, formatBrowserModelTarget, resolveBrowserModelDisplayName, } from "./modelDisplay.js";
 const LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD = 25_000;
 const LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD = 120_000;
 function buildUnavailableModelSelectionEvidence(browserConfig) {
@@ -21,13 +22,6 @@ function buildUnavailableModelSelectionEvidence(browserConfig) {
         capturedAt: new Date().toISOString(),
     };
 }
-function formatModelSelectionEvidence(evidence) {
-    const requested = evidence.requestedModel ?? "(none)";
-    const resolved = evidence.resolvedLabel ?? "(unavailable)";
-    const strategy = evidence.strategy ?? "(default)";
-    const verified = evidence.verified ? "yes" : "no";
-    return `[browser] Model selection evidence: requested=${requested}; resolved=${resolved}; status=${evidence.status}; strategy=${strategy}; verified=${verified}.`;
-}
 function isRequestedProBrowserRun(runOptions, browserConfig, evidence) {
     const candidates = [
         runOptions.model,
@@ -87,7 +81,12 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (promptArtifacts.bundled) {
         log(chalk.dim(`Packed ${promptArtifacts.bundled.originalCount} files into 1 bundle (contents counted in token estimate).`));
     }
-    const headerLine = `Launching browser mode (${runOptions.model}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens.`;
+    const launchModel = formatBrowserModelTarget({
+        model: runOptions.model,
+        desiredModel: browserConfig.desiredModel,
+        modelStrategy: browserConfig.modelStrategy,
+    });
+    const headerLine = `Launching browser mode (${launchModel}) with ~${promptArtifacts.estimatedInputTokens.toLocaleString()} tokens.`;
     const automationLogger = ((message) => {
         if (typeof message !== "string")
             return;
@@ -150,7 +149,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     }
     const modelSelection = browserResult.modelSelection ?? buildUnavailableModelSelectionEvidence(browserConfig);
     if (modelSelection) {
-        log(formatModelSelectionEvidence(modelSelection));
+        log(`[browser] Model selection evidence: ${formatBrowserModelSelectionEvidence(modelSelection, runOptions.model)}`);
     }
     const warnings = buildBrowserRunWarnings({
         runOptions,
@@ -199,7 +198,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     })();
     const { line1, line2 } = formatFinishLine({
         elapsedMs: browserResult.tookMs,
-        model: `${runOptions.model}[browser]`,
+        model: `${resolveBrowserModelDisplayName({ model: runOptions.model, evidence: modelSelection })}[browser]`,
         tokensPart,
         detailParts: [
             runOptions.file && runOptions.file.length > 0 ? `files=${runOptions.file.length}` : null,

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)}.`);
 }