@youdie006/prodex 0.40.11 → 0.40.13

package/README.md

@@ -69,6 +69,10 @@ prodex pro latest                 # re-print the last answer
 
 `prodex ask` is the short form of `prodex pro browser ask`; every flag works on both. The login opens its own Chrome profile (`~/.local/share/prodex/chrome-chatgpt-pro`), never your daily browser, and in a terminal it keeps watching the window and names the manual step still missing (sign in, clear a check, open a chat) until it reports READY.
 
+For a one-time visible login followed by a verified headless handoff, use `prodex pro browser login --background`. Keep the window open until `background: READY`: prodex verifies login, gracefully closes only an idle dedicated browser, then reopens the same profile and conversation headless. Future CLI/MCP relaunches reuse that mode. Other tabs, Chrome account/permission confirmation windows, unfinished input, and active answers block the handoff. A verification challenge remains a blocker; this option does not guarantee that ChatGPT accepts headless Chrome.
+
+Finish any native browser or OS confirmation before requesting the handoff: Chrome does not expose every native dialog through its page-control interface. The guard detects page targets and rendered dialogs, not every OS prompt. Incognito, guest, and explicitly selected Chrome sub-profiles are refused.
+
 While Pro thinks, progress goes to stderr: connecting, prompt sent, elapsed time while generating. A Pro selection raises the send budget to twenty minutes on its own; `--timeout-ms` overrides it. Answers are read from the rendered page, so formatting can differ from the original message. If the dedicated browser is not running, an interactive `ask` starts it, waits for your saved session, and retries once (`--no-auto-login` turns that off; scripts opt in with `--auto-login`).
 
 If the browser stops responding after your question was sent, prodex stops without sending it again. Use the `thread` and `request_id` from the error with `prodex pro browser recover --target-url <thread-url> --request-id <32hex>` (MCP: `pro_recover`). The request ID verifies that the recovered assistant answer follows that exact marked user turn. Legacy recovery without it remains available but returns `request_verified: false` and a warning.
@@ -115,7 +119,7 @@ a configurable approval checkpoint (default 5, not a target round count); an
 See [same-task dialogue](docs/clients.md#same-task-dialogue) for the budget and
 `user_approved` contract. New topics still start fresh chats.
 
-Updating the installed npm package does not reload an MCP process that is already running. Reconnect the MCP server or restart the Codex/Claude client to load the new build. The dedicated browser profile is separate and remains signed in, so this does not require ChatGPT authentication again.
+Updating the installed npm package does not reload an MCP process that is already running. Reconnect the MCP server or restart the Codex/Claude client to load the new build. This preserves the separate dedicated browser profile and does not itself require another login. ChatGPT can still expire the saved session; a `login_required` blocker means you need to sign in manually again.
 
 An MCP server usually starts without `--cwd`, so a per-repo default can be missed. For defaults that apply from any directory, set `PRODEX_DEFAULT_PROJECT`, `PRODEX_DEFAULT_MODEL`, `PRODEX_DEFAULT_EFFORT` or `PRODEX_DEFAULT_PRO_MODE` in the agent's MCP `env` block; a per-repo config still wins field by field.
 
@@ -179,9 +183,9 @@ The last recorded window mode is reused by later `login` commands and by CLI/MCP
 
 `--minimized` keeps a window but minimizes it. Under WSLg a minimized Chrome still reports itself visible and consults keep working; a normal Linux desktop marks it hidden, and prodex refuses to send into a tab it cannot read, restores the window, and tells you.
 
-`--headless` exists and is not usable against ChatGPT today: measured on a signed-in profile, headless Chrome stays on Cloudflare's interstitial past sixty seconds. Only the window is optional; the login is not.
+`--headless` may be blocked even with a saved login: a previous test on a signed-in profile stayed on Cloudflare's interstitial past sixty seconds. `--background` verifies the actual handoff and only reports READY when the signed-in composer works headless. A challenge does not prove that the saved login was lost. Only the window is optional; authentication and protection checks still apply.
 
-If a hidden or virtual browser needs login, captcha, Cloudflare, or account verification, close that browser yourself and run `prodex pro browser login --headed` to complete the interactive step. Merely omitting `--headless` does not switch modes because the saved mode persists. prodex does not bypass the protection or kill a running browser to change its mode.
+If a hidden or virtual browser needs login, captcha, Cloudflare, or account verification, close that browser yourself and run `prodex pro browser login --headed` to complete the interactive step. Merely omitting `--headless` does not switch modes because the saved mode persists. prodex does not bypass protection or force-kill a browser for a mode change; `--background` permits only the guarded graceful handoff described above.
 
 Before a prompt is submitted, a browser confirmed to have stopped answering its control port can be ended and started fresh, and the receipt says so (`PRODEX_NO_AUTO_CLEAR=1` turns that off). A browser that is merely slow is left alone. After submission, prodex never auto-resends a lost prompt.
 
@@ -245,6 +249,14 @@ Reports are deduplicated by blocker code, so something that stays broken adds to
 
 ## FAQ
 
+**Do I need tmux?** No. Explicit CLI commands work in a normal terminal, and stdio MCP works through pipes without a terminal. Only the interactive picker and `setup --interactive` need keyboard input from a terminal. Keep the calling CLI or agent running while waiting for an answer: closing its terminal or disconnecting SSH can interrupt collection. tmux is an optional way to keep that foreground session alive, not a requirement. `prodex start` is also a foreground process, not an installed service.
+
+**Can I close the terminal after login?** Yes, once login is READY: the dedicated Chrome is launched separately. Keep that browser running for consults. If a CLI or agent exits during a request, ChatGPT may still finish it; recover the original thread and request ID rather than automatically sending the question again.
+
+**Does closing the Chrome window switch to headless?** No. Use `login --background` and wait for `background: READY`; ordinary headed login never silently changes mode. A closed window alone is not evidence of logout. Before an unsent request, MCP or an auto-login-enabled CLI can reopen one missing ChatGPT tab in the existing browser and recheck the saved login without restarting Chrome.
+
+**It stopped with `browser_tab_crashed` or `Runtime.enable`.** Chrome can leave an "Aw, Snap!" tab listed on its control port even though that tab's renderer has crashed. Before typing a new prompt, prodex can reload a confirmed crashed tab once at the same conversation address and records `browser_tab_recovered`. A timeout alone never authorizes a reload. A crash after a prompt was submitted stops without resending; inspect the original conversation, then recover with both `--target-url` and `--request-id` from the blocker. Other tabs, the browser profile, and saved login are left alone.
+
 **A send failed with `send_ui_changed`.** ChatGPT redesigned the composer or send control. Update (`npm i -g @youdie006/prodex@latest`); if it persists, `prodex pro report-issue`, and paste the prompt by hand meanwhile.
 
 **It stopped with `tab_not_visible`.** A tab counts as watchable only while its window is not minimized and it is the active tab. Leave the dedicated window behind your editor and it sends in the background; prodex never steals focus (`PRODEX_ACTIVATE_TAB=1` if you want the tab pulled forward on a stopped send).

package/dist/browser-handoff.js

@@ -0,0 +1,189 @@
+import { spawnSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import WebSocket from "ws";
+import { ChatGptBrowserBlockerError, attachmentPresenceExpression, composerTextStateExpression, detectChatGptPageBlocker, findLaunchedBrowserProcesses, inferChatGptPageLoggedInLikely, statusExpression } from "./chatgpt-browser.js";
+function blocked(message) {
+    throw new ChatGptBrowserBlockerError({
+        code: "browser_handoff_blocked", message, retryable: false,
+        next_step: "Keep only the intended idle ChatGPT tab open, finish any Chrome account or permission confirmation yourself, and retry `prodex pro browser login --background`. Do not close active work or log in again solely because the handoff stopped."
+    });
+}
+function browserIdentity(port, profileDir) {
+    const listed = spawnSync("ps", ["-Ao", "user,pid,command"], { encoding: "utf8", timeout: 5_000 });
+    if (listed.status !== 0 || typeof listed.stdout !== "string")
+        blocked("Could not verify the dedicated browser process.");
+    const pids = findLaunchedBrowserProcesses(listed.stdout, { port, profileDir });
+    const mains = listed.stdout.split(/\r?\n/).filter((line) => {
+        const pid = Number(/^\s*\S+\s+(\d+)\s/.exec(line)?.[1]);
+        return pids.includes(pid) && !/\s--type=/.test(line) && new RegExp(`--remote-debugging-port=${port}(?!\\d)`).test(line);
+    });
+    if (mains.length !== 1)
+        blocked("Could not identify exactly one dedicated browser for this port.");
+    if (/\s--(?:incognito|guest)(?:\s|=|$)/.test(mains[0]))
+        blocked("An incognito or guest browser cannot preserve its login through a restart.");
+    if (/\s--profile-directory(?:\s|=|$)/.test(mains[0]))
+        blocked("An explicitly selected Chrome sub-profile cannot be preserved by this handoff; no browser was closed.");
+    const actualProfile = /--user-data-dir=(.*?)(?=\s--|$)/.exec(mains[0])?.[1];
+    if (!actualProfile || !path.isAbsolute(actualProfile))
+        blocked("The browser profile could not be verified.");
+    try {
+        if (realpathSync(actualProfile) !== realpathSync(profileDir))
+            blocked("The actual browser profile differs from the requested profile.");
+    }
+    catch (error) {
+        if (error instanceof ChatGptBrowserBlockerError)
+            throw error;
+        blocked("The browser profile path could not be verified.");
+    }
+    return { main: Number(/^\s*\S+\s+(\d+)\s/.exec(mains[0])[1]), pids, headless: /\s--headless(?:\s|=|$)/.test(mains[0]) };
+}
+export function getDedicatedBrowserHeadlessMode(options) {
+    return browserIdentity(options.port, options.profileDir).headless;
+}
+async function readJson(port, resource) {
+    const response = await fetch(`http://127.0.0.1:${port}/json/${resource}`, { signal: AbortSignal.timeout(2_000) });
+    if (!response.ok)
+        blocked(`The browser did not answer the ${resource} identity check.`);
+    return response.json();
+}
+function localSocket(value, port, kind) {
+    if (typeof value !== "string")
+        blocked("Missing browser control socket.");
+    const url = new URL(value);
+    if (url.protocol !== "ws:" || !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) ||
+        Number(url.port) !== port || url.username || url.password || !url.pathname.startsWith(`/devtools/${kind}/`)) {
+        blocked("The control socket is not bound to the expected local browser.");
+    }
+    return value;
+}
+async function singlePage(port) {
+    const response = await readJson(port, "list");
+    if (!Array.isArray(response))
+        blocked("The browser page list is invalid.");
+    const pages = response.filter((page) => page?.type === "page");
+    if (pages.length !== 1)
+        blocked("The dedicated browser has other tabs or a Chrome confirmation surface; nothing was closed.");
+    const page = pages[0];
+    const url = new URL(page.url);
+    if (url.protocol !== "https:" || url.hostname !== "chatgpt.com" || url.username || url.password || url.port ||
+        url.searchParams.has("temporary-chat") || !page.id) {
+        blocked("Handoff requires one normal, non-temporary ChatGPT page.");
+    }
+    localSocket(page.webSocketDebuggerUrl, port, "page");
+    return page;
+}
+// Unlike normal send connections this must not enable Page or answer dialogs.
+async function request(socketUrl, method, params = {}) {
+    return new Promise((resolve, reject) => {
+        const socket = new WebSocket(socketUrl);
+        let sent = false;
+        let finished = false;
+        const finish = (error, value) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            socket.removeAllListeners();
+            socket.on("error", () => { });
+            socket.terminate();
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const timer = setTimeout(() => finish(new Error(`${method} timed out; browser handoff stopped.`)), 5_000);
+        socket.once("open", () => {
+            try {
+                socket.send(JSON.stringify({ id: 1, method, params }));
+                sent = true;
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        socket.on("message", (data) => {
+            let reply;
+            try {
+                reply = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            if (reply.id === 1)
+                finish(reply.error ? new Error(reply.error.message ?? "CDP command failed") : undefined, reply.result);
+        });
+        socket.once("error", (error) => finish(error));
+        socket.once("close", () => finish(method === "Browser.close" && sent ? undefined : new Error("Browser control socket closed before verification.")));
+    });
+}
+async function verifyIdle(page) {
+    const expression = `(() => {
+    const status = ${statusExpression()};
+    const composer = ${composerTextStateExpression()};
+    const visible = (e) => e.getClientRects().length > 0 && getComputedStyle(e).visibility !== 'hidden';
+    const attachmentState = ${attachmentPresenceExpression()};
+    return { status,
+      draft: composer.ok !== false || composer.reason !== 'Composer stayed empty after text insertion',
+      dialog: [...document.querySelectorAll('dialog[open],[role="dialog"],[aria-modal="true"]')].some(visible),
+      attachments: attachmentState.removed > 0 || [...document.querySelectorAll('input[type="file"]')].some(e => e.files?.length > 0) || [...document.querySelectorAll('[role="progressbar"]')].some(visible),
+      unpersisted: !location.pathname.includes('/c/') && !!document.querySelector('[data-message-author-role]')
+    };
+  })()`;
+    const reply = await request(page.webSocketDebuggerUrl, "Runtime.evaluate", { expression, returnByValue: true });
+    const value = reply?.result?.value;
+    if (reply?.exceptionDetails || !value?.status || [value.draft, value.dialog, value.attachments, value.unpersisted].some((v) => typeof v !== "boolean")) {
+        blocked("Could not verify the page's input and dialog state.");
+    }
+    const state = value.status;
+    if (state.url !== page.url || !state.hasComposer || !inferChatGptPageLoggedInLikely(state) || detectChatGptPageBlocker(state)) {
+        blocked("ChatGPT is not ready in the expected conversation; no browser was closed.");
+    }
+    if (state.generating || state.awaitingResponseChoice || state.openDialogText || value.draft || value.dialog || value.attachments || value.unpersisted) {
+        blocked("The page has active work, unfinished input, attachments, or a dialog; no browser was closed.");
+    }
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+/** Caller holds the shared browser send lock through this close AND relaunch. */
+export async function closeIdleChatGptBrowserForHandoff(options) {
+    const { port, profileDir } = options;
+    if (!Number.isInteger(port) || port < 1 || port > 65535 || !path.isAbsolute(profileDir))
+        blocked("Invalid browser handoff identity.");
+    const identity = browserIdentity(port, profileDir);
+    const page = await singlePage(port);
+    const version = await readJson(port, "version");
+    const socket = localSocket(version?.webSocketDebuggerUrl, port, "browser");
+    await verifyIdle(page);
+    const current = await singlePage(port);
+    const currentVersion = await readJson(port, "version");
+    if (current.id !== page.id || current.url !== page.url || current.webSocketDebuggerUrl !== page.webSocketDebuggerUrl ||
+        currentVersion.webSocketDebuggerUrl !== socket || browserIdentity(port, profileDir).main !== identity.main) {
+        blocked("The browser or conversation changed during handoff verification.");
+    }
+    await verifyIdle(current);
+    await request(socket, "Browser.close");
+    const deadline = Date.now() + 10_000;
+    while (Date.now() < deadline) {
+        if (!identity.pids.some(alive)) {
+            try {
+                await readJson(port, "version");
+            }
+            catch (error) {
+                const cause = error.cause;
+                if (cause?.code === "ECONNREFUSED")
+                    return { url: page.url };
+                blocked("The old browser exited, but its control port could not be verified closed.");
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    blocked("The dedicated browser did not finish closing. It was not force-killed and no replacement was launched.");
+}

package/dist/chatgpt-browser.js

@@ -4,6 +4,7 @@ import { accessSync, constants, statSync } from "node:fs";
 import net from "node:net";
 import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import WsWebSocket from "ws";
 import { captureBrowserDiagnostics, diagnosticsEnabled, diagnosticsNote } from "./browser-diagnostics.js";
 import { withCrossProcessFileLock } from "./safe-file.js";
 import os from "node:os";
@@ -17,6 +18,22 @@ export class ChatGptBrowserBlockerError extends Error {
         this.blocker = blocker;
     }
 }
+function crashedTabBlocker(thread, requestId) {
+    return {
+        code: "browser_tab_crashed",
+        message: "Chrome reported that this ChatGPT tab's renderer crashed. The browser itself may still be running.",
+        retryable: false,
+        next_step: requestId
+            ? `Do not resend automatically. Reload the crashed tab at the same address, then ${thread
+                ? `collect the original answer with \`prodex pro browser recover --target-url ${thread} --request-id ${requestId}\`.`
+                : `find [prodex-request:${requestId}] in the original conversation before recovering its answer; its thread URL was not captured.`}`
+            : "Before typing, prodex can reload a confirmed crashed tab once at the same address. If it crashes again, inspect Chrome's error screen; do not restart other tabs or resend an uncertain request.",
+        ...(thread ? { thread } : {})
+    };
+}
+function isCrashedTabError(error) {
+    return error instanceof ChatGptBrowserBlockerError && error.blocker.code === "browser_tab_crashed";
+}
 function unsupportedChatGptOperationError(operation, nextStep) {
     return new ChatGptBrowserBlockerError({
         code: "unsupported_chatgpt_operation",
@@ -1410,9 +1427,18 @@ export async function getChatGptBrowserStatus(options = {}) {
     // `pro browser check --timeout-ms 5000` measured 65 seconds because every
     // evaluate silently used the default. Agents read that silence as a hung
     // bridge and start "recovering" a browser that is merely busy.
-    const state = await evaluateOnPage(page.page, statusExpression(), {
-        ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {})
-    });
+    let state;
+    try {
+        state = await evaluateOnPage(page.page, statusExpression(), {
+            ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {})
+        });
+    }
+    catch (error) {
+        if (!isCrashedTabError(error))
+            throw error;
+        return { reachable: true, loggedInLikely: false, hasComposer: false, modelHints: [],
+            url: page.page.url, blocker: crashedTabBlocker(page.page.url) };
+    }
     const loggedInLikely = inferChatGptPageLoggedInLikely(state);
     // The busy verdict is checked against the transcript here too, so `check`
     // does not report a finished conversation as one still being written.
@@ -1862,6 +1888,47 @@ async function reloadPageAndAwaitComposer(page) {
         cdp.close();
     }
 }
+/** A crashed renderer cannot mark its document or enable Runtime before reload. */
+async function recoverCrashedPageBeforeSend(port, page) {
+    const cdp = await connectCdp(page.webSocketDebuggerUrl, 2_000);
+    try {
+        if (!cdp.crashed())
+            return { state: await readSettledChatGptPageStatus(page), reloaded: false };
+        const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(2_000) });
+        if (!response.ok)
+            throw new Error("Could not verify the crashed tab before reload");
+        const pages = await response.json();
+        const current = pages.find((candidate) => candidate.webSocketDebuggerUrl === page.webSocketDebuggerUrl && candidate.id === page.id);
+        if (!current)
+            throw new Error("The crashed ChatGPT tab closed before recovery; nothing was reloaded");
+        assertChatGptTargetUrlMatches(current.url, page.url);
+        if (!cdp.crashed())
+            return { state: await readSettledChatGptPageStatus(page), reloaded: false };
+        const reply = await cdp.send("Page.reload");
+        if (reply.error?.message)
+            throw new Error(`Page.reload failed: ${reply.error.message}`);
+        const deadline = Date.now() + RELOAD_SETTLE_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            await sleep(250);
+            try {
+                const state = await cdp.evaluate(statusExpression());
+                if (detectChatGptPageBlocker(state))
+                    return { state, reloaded: true };
+                assertChatGptTargetUrlMatches(state.url, page.url);
+                if (state.hasComposer)
+                    return { state, reloaded: true };
+            }
+            catch (error) {
+                if (!/execution context|cannot find context|Runtime\.evaluate failed/i.test(error instanceof Error ? error.message : String(error)))
+                    throw error;
+            }
+        }
+        throw new ChatGptBrowserBlockerError(crashedTabBlocker(page.url));
+    }
+    finally {
+        cdp.close();
+    }
+}
 // Every alternative is wording measured on the error page itself, anchored so
 // the whole body has to be made of them and nothing else. It may repeat one:
 // the heading and the button carry the same words.
@@ -3246,7 +3313,22 @@ export async function sendChatGptPrompt(options) {
         assertChatGptPageAvailable();
     }
     const page = pageResult.page;
-    let status = await readSettledChatGptPageStatus(page);
+    const preflightWarnings = [];
+    let status;
+    try {
+        status = await readSettledChatGptPageStatus(page);
+    }
+    catch (error) {
+        if (!isCrashedTabError(error))
+            throw error;
+        emitProgress("waiting", "Chrome reported a crashed tab; checking same-tab recovery before typing");
+        const recovered = await recoverCrashedPageBeforeSend(port, page);
+        status = recovered.state;
+        if (recovered.reloaded) {
+            preflightWarnings.push("browser_tab_recovered: Chrome reported a crashed tab; reloaded the same conversation before typing. No previous prompt was resent.");
+            emitProgress("waiting", "crashed tab reloaded at the same address; rechecking readiness");
+        }
+    }
     status = await ensureVisibleChatGptPage(port, page, status);
     const blocker = detectChatGptPageBlocker(status);
     if (blocker) {
@@ -3426,7 +3508,7 @@ export async function sendChatGptPrompt(options) {
     let beforeSubmit;
     let boundProjectId;
     let submitButtonFound = false;
-    const sendWarnings = [];
+    const sendWarnings = [...preflightWarnings];
     // Anything the page put in front of prodex was answered on the caller's
     // behalf. The note is read at return time - there are several return paths -
     // so it is folded into the array rather than pushed from each of them.
@@ -3593,6 +3675,8 @@ export async function sendChatGptPrompt(options) {
         // looks the way it looked when it refused, and the selection failures this
         // project keeps hitting are invisible in the error text alone.
         await captureOnFailure(`send-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+        if (isCrashedTabError(error))
+            throw attachSendWarnings(new ChatGptBrowserBlockerError(crashedTabBlocker(undefined, requestId)), sendWarnings);
         throw attachSendWarnings(error, sendWarnings);
     }
     finally {
@@ -3608,7 +3692,9 @@ export async function sendChatGptPrompt(options) {
         try {
             finalState = await evaluateOnPage(page, answerExpression());
         }
-        catch {
+        catch (error) {
+            if (isCrashedTabError(error))
+                throw attachSendWarnings(new ChatGptBrowserBlockerError(crashedTabBlocker(undefined, requestId)), sendWarnings);
             // Transient CDP failure (command timeout, mid-poll navigation): retry the
             // poll rather than aborting the whole send.
             continue;
@@ -3704,6 +3790,8 @@ export async function sendChatGptPrompt(options) {
             finalState = observedState;
         }
         catch (error) {
+            if (isCrashedTabError(error))
+                throw attachSendWarnings(new ChatGptBrowserBlockerError(crashedTabBlocker(pinnedThreadUrl, requestId)), sendWarnings);
             if (error instanceof ChatGptBrowserBlockerError)
                 throw error;
             // Transient CDP failure while the answer is streaming: retry. A throw here
@@ -3713,7 +3801,7 @@ export async function sendChatGptPrompt(options) {
             // sitting out the whole budget on it only delays the recovery.
             consecutiveReadFailures += 1;
             if (consecutiveReadFailures >= CONSECUTIVE_READ_FAILURES_BEFORE_GIVING_UP) {
-                throw new ChatGptBrowserBlockerError(browserLostMidWaitBlocker(pinnedThreadUrl ?? finalState?.url));
+                throw new ChatGptBrowserBlockerError(browserLostMidWaitBlocker(pinnedThreadUrl ?? finalState?.url, requestId));
             }
             continue;
         }
@@ -4417,8 +4505,10 @@ async function getChatGptPageVisibility(pages) {
         try {
             visibilityByPage.set(page.webSocketDebuggerUrl, await evaluateOnPage(page, "document.visibilityState", { timeoutMs: PAGE_VISIBILITY_PROBE_TIMEOUT_MS }));
         }
-        catch {
-            // Leave visibility unknown; untargeted sends treat unknown ChatGPT pages conservatively.
+        catch (error) {
+            if (isCrashedTabError(error))
+                visibilityByPage.set(page.webSocketDebuggerUrl, "crashed");
+            // Other failures leave visibility unknown; untargeted sends treat them conservatively.
         }
     }));
     return visibilityByPage;
@@ -4463,9 +4553,11 @@ export function resolveCdpTimeoutMs(explicit) {
 }
 async function connectCdp(webSocketUrl, timeoutMs) {
     const effectiveTimeoutMs = resolveCdpTimeoutMs(timeoutMs);
-    const ws = new WebSocket(webSocketUrl);
+    const WebSocketConstructor = globalThis.WebSocket ?? WsWebSocket;
+    const ws = new WebSocketConstructor(webSocketUrl);
     let id = 0;
     const pending = new Map();
+    let crashError;
     /** Types of JavaScript dialog answered on this connection. */
     const dialogsAnswered = [];
     ws.addEventListener("message", (event) => {
@@ -4480,6 +4572,23 @@ async function connectCdp(webSocketUrl, timeoutMs) {
             // the per-command timeout fires.
             return;
         }
+        const method = message.method;
+        if (method === "Inspector.targetCrashed") {
+            crashError = new ChatGptBrowserBlockerError(crashedTabBlocker());
+            for (const [messageId, waiter] of pending) {
+                if (waiter.method === "Inspector.enable" || waiter.method === "Page.reload")
+                    continue;
+                if (waiter.timer)
+                    clearTimeout(waiter.timer);
+                pending.delete(messageId);
+                waiter.reject(crashError);
+            }
+            return;
+        }
+        if (method === "Inspector.targetReloadedAfterCrash") {
+            crashError = undefined;
+            return;
+        }
         if (message.id && pending.has(message.id)) {
             const waiter = pending.get(message.id);
             if (waiter.timer)
@@ -4505,7 +4614,7 @@ async function connectCdp(webSocketUrl, timeoutMs) {
         for (const [messageId, waiter] of pending) {
             if (waiter.timer)
                 clearTimeout(waiter.timer);
-            waiter.reject(new Error("Chrome DevTools websocket closed"));
+            waiter.reject(crashError ?? new Error("Chrome DevTools websocket closed"));
             pending.delete(messageId);
         }
     });
@@ -4544,13 +4653,15 @@ async function connectCdp(webSocketUrl, timeoutMs) {
     /** The timeout that closed this socket, so later commands can name it rather than a bare closed socket. */
     let closedByTimeout;
     const send = (method, params = {}) => {
+        if (crashError && method !== "Inspector.enable" && method !== "Page.reload")
+            return Promise.reject(crashError);
         // Once a timeout has closed the socket, every later command would sit out
         // its own full timeout for an answer that cannot come. Measured cost of not
         // checking: a 14-probe confirmation loop turning into minutes of silence.
         // The rejection carries the timeout that did the closing: a caller that
         // swallowed that first error and moved on would otherwise report "socket
         // not open", which names neither the stalled tab nor the dialog cure.
-        if (ws.readyState !== WebSocket.OPEN) {
+        if (ws.readyState !== WebSocketConstructor.OPEN) {
             return Promise.reject(new Error(closedByTimeout
                 ? `${closedByTimeout} (the connection was closed by that timeout before ${method})`
                 : `Chrome DevTools websocket is not open (${method})`));
@@ -4563,7 +4674,7 @@ async function connectCdp(webSocketUrl, timeoutMs) {
                 ws.close();
                 reject(new Error(closedByTimeout));
             }, Math.max(1, effectiveTimeoutMs));
-            pending.set(messageId, { resolve, reject, timer });
+            pending.set(messageId, { method, resolve, reject, timer });
             ws.send(JSON.stringify({ id: messageId, method, params }));
         });
     };
@@ -4576,6 +4687,15 @@ async function connectCdp(webSocketUrl, timeoutMs) {
     // caller's diagnosis from "command timed out: Runtime.enable" - which at
     // least names what was being attempted - into a bare "websocket closed".
     // Nothing waits on the arming, so a build without the domain is no worse off.
+    // Inspector is browser-side and replays an existing renderer crash. Runtime
+    // and DOM commands cannot diagnose that state because the renderer is gone.
+    try {
+        await send("Inspector.enable");
+    }
+    catch (error) {
+        ws.close();
+        throw error;
+    }
     ws.send(JSON.stringify({ id: ++id, method: "Page.enable", params: {} }));
     const evaluate = async (expression) => {
         const response = await send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true });
@@ -4585,7 +4705,7 @@ async function connectCdp(webSocketUrl, timeoutMs) {
             throw new Error("Runtime.evaluate failed");
         return response.result?.result?.value;
     };
-    return { send, evaluate, dialogsAnswered, close: () => ws.close() };
+    return { send, evaluate, dialogsAnswered, crashed: () => crashError !== undefined, close: () => ws.close() };
 }
 // In-page reasoning-header placeholder test, shared by statusExpression and
 // answerExpression. MUST stay in sync with isUsableChatGptAnswer: a header
@@ -5154,7 +5274,7 @@ export function chunkComposerText(text, size = COMPOSER_INSERT_CHUNK_CHARS) {
 // Reading the page can fail for a moment (a navigation, a busy renderer). Five
 // failures in a row is not a moment - it is a browser that went away.
 const CONSECUTIVE_READ_FAILURES_BEFORE_GIVING_UP = 5;
-export function browserLostMidWaitBlocker(threadUrl) {
+export function browserLostMidWaitBlocker(threadUrl, requestId) {
     // Killing the browser aborts a streaming answer too, so promise nothing
     // about the answer itself - only say where to look. Deep research is the one
     // case that genuinely keeps going without us.
@@ -5165,8 +5285,8 @@ export function browserLostMidWaitBlocker(threadUrl) {
         // Retrying the send would duplicate a prompt that has already posted.
         retryable: false,
         next_step: threadUrl
-            ? `Run \`prodex pro browser login\` to reopen the browser, then collect the answer with \`prodex pro browser recover --target-url ${threadUrl}\` (MCP: pro_recover with thread ${threadUrl}).`
-            : "Run `prodex pro browser login` to reopen the browser, then inspect the original chat before asking again. The prompt was already submitted; prodex did not capture its thread URL.",
+            ? `Run \`prodex pro browser login\` to reopen the browser, then collect the answer with \`prodex pro browser recover --target-url ${threadUrl}${requestId ? ` --request-id ${requestId}` : ""}\` (MCP: pro_recover with thread ${threadUrl}${requestId ? ` and request_id ${requestId}` : ""}).`
+            : `Run \`prodex pro browser login\` to reopen the browser, then inspect the original chat before asking again. The prompt was already submitted; prodex did not capture its thread URL.${requestId ? ` Find [prodex-request:${requestId}] in that conversation before recovering its answer; do not resend automatically.` : ""}`,
         ...(threadUrl ? { thread: threadUrl } : {})
     };
 }

package/dist/cli-help.js

@@ -19,7 +19,7 @@ Ask / consult commands:
   prodex ask [same flags as pro browser ask] "prompt"  # top-level shortcut for pro browser ask
   prodex pro ask [--dry-run] [--cwd /absolute/path/to/repo] [--file path] [--attach path] [--tool deep-research|web-search|create-image] "prompt"  # dry-run preview
   prodex pro debate-prompt [--topic "..."] [--rounds 2] [--source-cli /absolute/path/to/dist/cli.js]  # print an agent prompt for a structured GPT Pro debate
-  prodex pro browser login [--cwd /absolute/path/to/repo] [--dry-run] [--source-cli /absolute/path/to/dist/cli.js] [--profile-dir path] [--port 9333] [--url https://chatgpt.com/...] [--launch-timeout-ms 5000] [--wait|--no-wait] [--headed|--headless|--minimized|--virtual-display] [--wait-timeout-ms 300000]  # preview/open browser login
+  prodex pro browser login [--cwd /absolute/path/to/repo] [--dry-run] [--source-cli /absolute/path/to/dist/cli.js] [--profile-dir path] [--port 9333] [--url https://chatgpt.com/...] [--launch-timeout-ms 5000] [--wait|--no-wait] [--headed|--headless|--minimized|--virtual-display] [--wait-timeout-ms 300000] [--background]  # preview/open browser login
   prodex pro browser help [--source-cli /absolute/path/to/dist/cli.js]
   prodex pro browser check [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 1500]
   prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]
@@ -166,7 +166,7 @@ Commands:
   prodex pro ask [--dry-run] [--cwd /absolute/path/to/repo] [--file path] [--attach path] [--tool deep-research|web-search|create-image] "prompt"
   prodex pro debate-prompt [--topic "..."] [--rounds 2] [--source-cli /absolute/path/to/dist/cli.js]
   prodex pro browser help [--source-cli /absolute/path/to/dist/cli.js]
-  prodex pro browser login [--cwd /absolute/path/to/repo] [--dry-run] [--source-cli /absolute/path/to/dist/cli.js] [--launch-timeout-ms 5000] [--wait|--no-wait] [--headed|--headless|--minimized|--virtual-display] [--wait-timeout-ms 300000]
+  prodex pro browser login [--cwd /absolute/path/to/repo] [--dry-run] [--source-cli /absolute/path/to/dist/cli.js] [--launch-timeout-ms 5000] [--wait|--no-wait] [--headed|--headless|--minimized|--virtual-display] [--wait-timeout-ms 300000] [--background]
   prodex pro browser check [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js]
@@ -251,8 +251,8 @@ export function printProBrowserHelp(stdout, sourceCli) {
     const cli = formatCliCommand(sourceCli);
     const sourceCliOption = formatSourceCliOption(sourceCli);
     const loginUsage = sourceCli
-        ? `${cli} pro browser login${sourceCliOption} [--cwd /absolute/path/to/repo] [--dry-run] [--profile-dir path] [--port 9333] [--url https://chatgpt.com/...] [--launch-timeout-ms 5000] [--wait|--no-wait] [--headed|--headless|--minimized|--virtual-display] [--wait-timeout-ms 300000]`
-        : "prodex pro browser login [--cwd /absolute/path/to/repo] [--dry-run] [--source-cli /absolute/path/to/dist/cli.js] [--profile-dir path] [--port 9333] [--url https://chatgpt.com/...] [--launch-timeout-ms 5000] [--wait|--no-wait] [--headed|--headless|--minimized|--virtual-display] [--wait-timeout-ms 300000]";
+        ? `${cli} pro browser login${sourceCliOption} [--cwd /absolute/path/to/repo] [--dry-run] [--profile-dir path] [--port 9333] [--url https://chatgpt.com/...] [--launch-timeout-ms 5000] [--wait|--no-wait] [--headed|--headless|--minimized|--virtual-display] [--wait-timeout-ms 300000] [--background]`
+        : "prodex pro browser login [--cwd /absolute/path/to/repo] [--dry-run] [--source-cli /absolute/path/to/dist/cli.js] [--profile-dir path] [--port 9333] [--url https://chatgpt.com/...] [--launch-timeout-ms 5000] [--wait|--no-wait] [--headed|--headless|--minimized|--virtual-display] [--wait-timeout-ms 300000] [--background]";
     const checkUsage = sourceCli
         ? `${cli} pro browser check${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 1500]`
         : "prodex pro browser check [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 1500]";

package/dist/cli-pro.js

@@ -2,7 +2,7 @@ import { existsSync, realpathSync, statSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { buildDryRunBundle } from "./bundle.js";
-import { DEFAULT_CDP_PORT, resolveCdpPort, resolveConversationToDelete, resolveProjectToDelete, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, formatModelMenuOption, listChatGptModelOptions, deleteChatGptConversation, endWedgedBrowser, browserRecoveryPlan, findWedgedBrowser, wedgedBrowserBlocker, deleteChatGptProject, listChatGptProjectsWithIds, listRecentChatGptConversations, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, openChatGptTab, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveBrowserWindowMode, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt, statusMeansBrowserDead, namesPro, sendWarningsFromError, destinationVerification, chatGptProjectIdFromUrl } from "./chatgpt-browser.js";
+import { ChatGptBrowserBlockerError, DEFAULT_CDP_PORT, resolveCdpPort, resolveConversationToDelete, resolveProjectToDelete, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, formatModelMenuOption, listChatGptModelOptions, deleteChatGptConversation, endWedgedBrowser, browserRecoveryPlan, findWedgedBrowser, wedgedBrowserBlocker, deleteChatGptProject, listChatGptProjectsWithIds, listRecentChatGptConversations, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, openChatGptTab, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveBrowserWindowMode, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt, statusMeansBrowserDead, namesPro, sendWarningsFromError, destinationVerification, chatGptProjectIdFromUrl } from "./chatgpt-browser.js";
 import { ASK_PRO_BOOLEAN_FLAGS, ASK_PRO_PREVIEW_VALUE_FLAGS, ASK_PRO_VALUE_FLAGS, assertHelpRequestArgs, assertNoExtraArgs, assertOnlyOptions, findHelpFlagIndexBeforePromptDelimiter, formatCliCommand, hasAskProDryRunMode, hasAskProMode, hasAskProSendMode, isHelpSubcommand, parseAskProArgs, printHelpIfRequested, readFlag, readPortFlag, readPositionalsWithOptions, readNonNegativeIntegerFlag, readPositiveIntegerFlag, readRepeatedFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError } from "./cli-args.js";
 import { printProBrowserHelp, printProHelp } from "./cli-help.js";
 import { listRawResultsForInspection, listTasksForInspection } from "./cli-ledger.js";
@@ -206,11 +206,15 @@ export async function runProCommand(rest, io, runCliFn) {
         if (browserSubcommand === "login") {
             if (printProBrowserHelpIfRequested(browserArgs, "pro browser login", io, {
                 valueFlags: ["--cwd", "--profile-dir", "--port", "--url", "--source-cli", "--launch-timeout-ms", "--wait-timeout-ms"],
-                booleanFlags: ["--dry-run", "--wait", "--no-wait", "--headed", "--headless", "--minimized", "--virtual-display"]
+                booleanFlags: ["--dry-run", "--wait", "--no-wait", "--headed", "--headless", "--minimized", "--virtual-display", "--background"]
             })) {
                 return 0;
             }
-            assertOnlyOptions(browserArgs, "pro browser login", ["--cwd", "--profile-dir", "--port", "--url", "--source-cli", "--launch-timeout-ms", "--wait-timeout-ms"], ["--dry-run", "--wait", "--no-wait", "--headed", "--headless", "--minimized", "--virtual-display"]);
+            assertOnlyOptions(browserArgs, "pro browser login", ["--cwd", "--profile-dir", "--port", "--url", "--source-cli", "--launch-timeout-ms", "--wait-timeout-ms"], ["--dry-run", "--wait", "--no-wait", "--headed", "--headless", "--minimized", "--virtual-display", "--background"]);
+            const background = browserArgs.includes("--background");
+            if (background && browserArgs.some((arg) => ["--headed", "--headless", "--minimized", "--virtual-display", "--no-wait"].includes(arg))) {
+                throw new Error("--background cannot combine with another window mode or --no-wait: it waits for login, then verifies the headless handoff.");
+            }
             if (browserArgs.includes("--wait") && browserArgs.includes("--no-wait")) {
                 throw new Error("pro browser login cannot combine --wait and --no-wait");
             }
@@ -231,8 +235,8 @@ export async function runProCommand(rest, io, runCliFn) {
                 ? resolveBrowserProfileDirForLaunch(savedLaunchForPort.profile_dir)
                 : undefined;
             const profileDir = requestedProfileDir ?? savedProfileDir;
-            const windowMode = resolveBrowserWindowMode({
-                flags: {
+            let windowMode = resolveBrowserWindowMode({
+                flags: background ? (savedLaunchForPort?.headless === true ? { headless: true } : { headed: true }) : {
                     ...(browserArgs.includes("--headed") ? { headed: true } : {}),
                     ...(browserArgs.includes("--headless") ? { headless: true } : {}),
                     ...(browserArgs.includes("--virtual-display") ? { virtualDisplay: true } : {}),
@@ -260,15 +264,21 @@ export async function runProCommand(rest, io, runCliFn) {
                     sourceCli,
                     commandOptions
                 });
+                if (background)
+                    io.stdout("background: verify login, then hand the same profile to headless Chrome under the shared send lock. No prompt is sent.");
                 return 0;
             }
             // If the dedicated Chrome is already reachable on this port, do NOT spawn
             // again: Chrome's singleton would just open ANOTHER window (the recurring
             // "extra windows" problem, which then blocks sends as
             // ambiguous_chatgpt_tabs). Reuse the running instance instead.
+            const alreadyRunning = (await getChatGptBrowserStatus({ port })).reachable;
+            if (background && alreadyRunning) {
+                const { getDedicatedBrowserHeadlessMode } = await import("./browser-handoff.js");
+                windowMode = { headless: getDedicatedBrowserHeadlessMode({ port, profileDir: profileDir ?? defaultChatGptProfileDir() }), virtualDisplay: false, minimized: false };
+            }
             const headless = windowMode.headless;
             const wantsVirtualDisplay = windowMode.virtualDisplay;
-            const alreadyRunning = (await getChatGptBrowserStatus({ port })).reachable;
             if (alreadyRunning) {
                 if (requestedProfileDir &&
                     savedProfileDir &&
@@ -278,7 +288,7 @@ export async function runProCommand(rest, io, runCliFn) {
                 // One Chrome profile cannot serve a headed and a headless instance at
                 // once, and reusing the running one would silently ignore the
                 // requested mode. Say so instead of pretending the switch took.
-                const runningHeadless = savedLaunchForPort ? savedLaunchForPort.headless === true : undefined;
+                const runningHeadless = background ? headless : savedLaunchForPort ? savedLaunchForPort.headless === true : undefined;
                 if (runningHeadless !== undefined && runningHeadless !== headless) {
                     throw new Error(`A ${runningHeadless ? "headless" : "headed"} ChatGPT browser is already running on port ${port}, but ${headless ? "headless" : "headed"} was requested. Close the existing browser yourself, then rerun; prodex will not end it.`);
                 }
@@ -379,6 +389,8 @@ export async function runProCommand(rest, io, runCliFn) {
             });
             if (minimizeNote)
                 io.stdout(minimizeNote);
+            if (background && !headless)
+                io.stdout("background: keep this window open until login is ready; prodex will close the idle dedicated browser and verify the same profile headless.");
             if (headless) {
                 // Nobody can sign in to a window that does not exist, so a headless
                 // launch is only useful when the profile is already logged in.
@@ -392,18 +404,22 @@ export async function runProCommand(rest, io, runCliFn) {
                     headedLoginCommand: formatHeadedBrowserLoginCommand(sourceCli, commandOptions)
                 });
                 if (!headlessReady) {
-                    // Name the real cause. Cloudflare rejects headless Chrome by
-                    // design (its docs list headless browsers as unsupported), and
-                    // reporting that as "not signed in" sent users to re-login over
-                    // and over instead of back to a headed window.
+                    // A challenge is not evidence of a lost login. Report the observed
+                    // blocker without promising that another login fixes it.
                     const finalStatus = await getChatGptBrowserStatus({ port: opened.port, timeoutMs: 5_000 }).catch(() => undefined);
                     const challenged = finalStatus?.blocker?.code === "cloudflare_check" || /just a moment/i.test(finalStatus?.title ?? "");
                     io.stdout("");
                     io.stdout(challenged
-                        ? `headless: Cloudflare challenged the headless browser and never let ChatGPT load. Run \`${formatHeadedBrowserLoginCommand(sourceCli, commandOptions)}\` for a visible interactive check; headless browsers are not supported by Cloudflare.`
-                        : `headless: the profile is not signed in. Run \`${formatHeadedBrowserLoginCommand(sourceCli, commandOptions)}\` for a visible interactive login, sign in, close that browser yourself, then rerun with --headless.`);
+                        ? `headless: Cloudflare challenged this headless browser and ChatGPT did not become ready. Run \`${formatHeadedBrowserLoginCommand(sourceCli, commandOptions)}\` for a visible interactive check. This does not prove that the saved login was lost.`
+                        : `headless: readiness was not confirmed (${finalStatus?.blocker?.code ?? "not_ready"}). This does not prove that the saved login was lost. Inspect the dedicated browser with \`${formatHeadedBrowserLoginCommand(sourceCli, commandOptions)}\`; complete an interactive step only if requested.`);
                     return 1;
                 }
+                if (background) {
+                    const { getDedicatedBrowserHeadlessMode } = await import("./browser-handoff.js");
+                    if (!getDedicatedBrowserHeadlessMode({ port: opened.port, profileDir: opened.profileDir }))
+                        throw new Error("The browser is not actually headless; background readiness was not confirmed.");
+                    io.stdout("background: READY - the saved login works headless. Later consults reuse this mode.");
+                }
                 io.stdout("headless: signed-in session confirmed - consults will run with no visible window.");
                 return 0;
             }
@@ -411,7 +427,7 @@ export async function runProCommand(rest, io, runCliFn) {
             // state instead of returning while login is still unfinished. Scripts
             // and agents (non-TTY) keep the immediate return unless --wait is
             // passed; --no-wait always skips.
-            const shouldWaitForReady = !browserArgs.includes("--no-wait") && (browserArgs.includes("--wait") || io.isInteractive === true);
+            const shouldWaitForReady = background || (!browserArgs.includes("--no-wait") && (browserArgs.includes("--wait") || io.isInteractive === true));
             if (!shouldWaitForReady)
                 return 0;
             const waitTimeoutMs = readPositiveIntegerFlag(browserArgs, "--wait-timeout-ms") ?? 300_000;
@@ -421,6 +437,14 @@ export async function runProCommand(rest, io, runCliFn) {
                 windowMode,
                 headedLoginCommand: formatHeadedBrowserLoginCommand(sourceCli, commandOptions)
             });
+            if (ready && background) {
+                return completeBackgroundBrowserLogin(io, {
+                    port: opened.port,
+                    profileDir: opened.profileDir,
+                    timeoutMs: readPositiveIntegerFlag(browserArgs, "--wait-timeout-ms") ?? 30_000,
+                    headedLoginCommand: formatHeadedBrowserLoginCommand(sourceCli, commandOptions)
+                });
+            }
             return ready ? 0 : 1;
         }
         if (browserSubcommand === "ask") {
@@ -1219,20 +1243,27 @@ export async function runAskProCommand(rest, io, beforeSend) {
         // the name matching to do what it can; the send would fail on the same
         // browser anyway.
         let continuationProjectId;
+        let ambiguousProjectName = false;
         if (continuationProject) {
             try {
-                continuationProjectId = projectIdFromSidebar(await listChatGptProjectsWithIds({ port: resolveCdpPort(readPortFlag(parsedAskPro.optionArgs, "--port")) }), continuationProject);
+                const projects = await listChatGptProjectsWithIds({ port: resolveCdpPort(readPortFlag(parsedAskPro.optionArgs, "--port")) });
+                continuationProjectId = projectIdFromSidebar(projects, continuationProject);
+                ambiguousProjectName = !continuationProjectId && projects.some((project) => project.name.trim().toLowerCase() === continuationProject.trim().toLowerCase());
             }
             catch {
                 continuationProjectId = undefined;
             }
         }
+        if (ambiguousProjectName && continueTaskId === undefined) {
+            throw new Error(`Project name "${continuationProject}" is ambiguous in the sidebar. Name the intended conversation with --continue-task <task_id>.`);
+        }
         const resolved = resolveContinuationThread({
             consults: (await targetStore.listSessionsReadOnly()).map((session) => ({
                 taskId: session.task_id ?? "",
                 ...(session.session_key ? { sessionKey: session.session_key } : {}),
                 ...(session.thread ? { thread: session.thread } : {}),
                 status: session.status,
+                warnings: session.warnings,
                 ...(session.created_at ? { createdAt: session.created_at } : {})
             })),
             ...(continuationProject ? { project: continuationProject } : {}),
@@ -1459,10 +1490,11 @@ export async function runAskProCommand(rest, io, beforeSend) {
             catch (error) {
                 const firstBlocker = browserSendBlockerFromError(error);
                 // Loss while reading an already-submitted prompt must not send it again.
-                if (firstBlocker.code !== "browser_unreachable" ||
+                if (!["browser_unreachable", "chatgpt_page_missing"].includes(firstBlocker.code) ||
                     !firstBlocker.retryable || firstBlocker.thread || !autoLoginAllowed)
                     throw error;
-                const recovered = await attemptBrowserAutoRecovery(io.stderr, {
+                const recover = firstBlocker.code === "chatgpt_page_missing" ? attemptMissingChatGptTabRecovery : attemptBrowserAutoRecovery;
+                const recovered = await recover(io.stderr, {
                     ...(browserPort !== undefined ? { port: browserPort } : {}),
                     notes: recoveryNotes
                 });
@@ -1569,6 +1601,9 @@ export async function runAskProCommand(rest, io, beforeSend) {
         });
         if (destination.warning)
             persistenceWarnings.push(destination.warning);
+        if (consult.requestVerified === false && !persistenceWarnings.some((warning) => warning.startsWith("request_unverified:"))) {
+            persistenceWarnings.push("request_unverified: the saved answer was not verified against its requested user turn. Review the original conversation before continuing.");
+        }
         // Truncation and other send warnings must be visible at runtime, not
         // only inside the persisted receipt: a caller who never opens .bridge
         // would otherwise treat a cut-off answer as complete.
@@ -1995,6 +2030,41 @@ export function browserRecoveredNote(ended) {
         ? `browser_recovered: the dedicated browser stopped answering its control port and prodex ended it (pid ${ended.join(", ")}) and started a fresh one before sending. Anything it was doing at the time is gone; the profile and login were kept.`
         : "browser_recovered: the dedicated browser was not running, so prodex started it with the saved profile before sending. The login was kept; anything the old browser had open is gone.";
 }
+async function attemptMissingChatGptTabRecovery(stderr, options) {
+    const port = resolveCdpPort(options.port);
+    return withBrowserSendLock(30_000, (detail) => stderr(`recover: ${detail}`), async () => {
+        const saved = await readLastBrowserLoginLaunch();
+        if (saved?.port !== undefined && saved.port !== port) {
+            throw new Error("Saved browser identity belongs to a different port; no tab was opened.");
+        }
+        let status = await getChatGptBrowserStatus({ port, timeoutMs: 2_000 });
+        if (status.loggedInLikely && status.hasComposer && !status.blocker)
+            return true;
+        if (!status.reachable || status.blocker?.code !== "chatgpt_page_missing") {
+            if (status.blocker)
+                throw new ChatGptBrowserBlockerError(status.blocker);
+            return false;
+        }
+        stderr("recover: the browser is running but its ChatGPT tab was closed; opening one tab and checking the saved login...");
+        if (!await openChatGptTab(port))
+            return false;
+        const deadline = Date.now() + 30_000;
+        while (Date.now() < deadline) {
+            status = await getChatGptBrowserStatus({ port, timeoutMs: 2_000 });
+            if (status.loggedInLikely && status.hasComposer && !status.blocker) {
+                options.notes?.push("browser_tab_reopened: reopened the closed ChatGPT tab in the running browser and verified the saved login before sending. No previous prompt was resent.");
+                return true;
+            }
+            if (status.blocker && !["login_required", "chatgpt_page_missing", "composer_not_ready", "browser_slow"].includes(status.blocker.code)) {
+                throw new ChatGptBrowserBlockerError(status.blocker);
+            }
+            await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
+        }
+        if (status.blocker)
+            throw new ChatGptBrowserBlockerError(status.blocker);
+        return false;
+    });
+}
 export async function attemptBrowserAutoRecovery(stderr, options) {
     // Launching is right when the browser is gone and wrong when it is only deaf:
     // a second Chrome on the same profile joins the wedged one rather than
@@ -2121,6 +2191,35 @@ export async function attemptBrowserAutoRecovery(stderr, options) {
         return false;
     }
 }
+async function completeBackgroundBrowserLogin(io, options) {
+    return withBrowserSendLock(5_000, (detail) => io.stderr(`background: ${detail}`), async () => {
+        const { closeIdleChatGptBrowserForHandoff, getDedicatedBrowserHeadlessMode } = await import("./browser-handoff.js");
+        io.stderr("background: checking the dedicated browser before graceful handoff...");
+        const { url } = await closeIdleChatGptBrowserForHandoff({ port: options.port, profileDir: options.profileDir });
+        const opened = openChatGptBrowser({ port: options.port, profileDir: options.profileDir, headless: true, url });
+        await assertBrowserLaunchStayedAlive(opened);
+        // This records the actual process, not a claim that authentication succeeded.
+        const actualHeadless = getDedicatedBrowserHeadlessMode({ port: opened.port, profileDir: opened.profileDir });
+        await recordBrowserLoginLaunch({ port: opened.port, profile_dir: opened.profileDir, headless: actualHeadless, minimized: false });
+        if (!actualHeadless)
+            throw new Error("The replacement browser is not actually headless; background readiness was not confirmed.");
+        const ready = await waitForChatGptLoginReady(io.stderr, {
+            port: opened.port,
+            timeoutMs: options.timeoutMs,
+            windowMode: { headless: true, virtualDisplay: false, minimized: false },
+            headedLoginCommand: options.headedLoginCommand
+        });
+        if (!ready) {
+            const status = await getChatGptBrowserStatus({ port: opened.port, timeoutMs: 5_000 }).catch(() => undefined);
+            io.stderr(`background: NOT READY (${status?.blocker?.code ?? "not_ready"}). The same profile was kept; this is not proof that your saved login was lost. No prompt was sent.`);
+            return 1;
+        }
+        if (!getDedicatedBrowserHeadlessMode({ port: opened.port, profileDir: opened.profileDir }))
+            throw new Error("The replacement browser is not actually headless; background readiness was not confirmed.");
+        io.stdout("background: READY - the saved login works headless, with no visible window. You may close this terminal; later consults reuse this mode.");
+        return 0;
+    });
+}
 /**
  * Guided login: poll the visible browser until a logged-in ChatGPT tab with a
  * usable composer appears, narrating each state change so the user knows what
@@ -2536,8 +2635,9 @@ export function browserSendBlockerFromError(error) {
             code: "browser_cdp_timeout",
             message,
             retryable: true,
-            next_step: "The ChatGPT tab stopped responding. A very long thread does it, and so does an open JavaScript dialog - that one halts the page outright, and no retry gets past it because the browser will not let a late client dismiss it. " +
-                "Look at the visible window and close any dialog sitting on it, or reopen the window with `prodex pro browser login`. For a heavy thread, retry with `--new-chat` for a fresh, light one."
+            next_step: "The ChatGPT tab stopped responding; a timeout alone does not prove it crashed. A long thread or an open JavaScript dialog can also stall it. " +
+                "Inspect the visible tab: if Chrome shows 'Aw, Snap!', reload only that tab at the same address. Close an ordinary dialog manually; login, verification, and permission prompts require your action. " +
+                "If the browser is gone, reopen it with `prodex pro browser login`. Do not resend automatically when the prompt may already have posted; recover its original thread and request ID. Use `--new-chat` only for a new request after the original is accounted for."
         };
     }
     return {
@@ -2853,7 +2953,8 @@ export function printBrowserLoginGuide(stdout, input) {
     stdout(`Profile: ${input.profileDir}`);
     stdout(`Debug: http://127.0.0.1:${input.port}`);
     if (windowAvailable) {
-        stdout("You can close this Chrome window after check/smoke or when you are done. The dedicated profile is reused next time.");
+        stdout("Closing this Chrome window does not switch it to headless mode. Keep it open for headed consults; closing the terminal is different from closing the browser.");
+        stdout(`For a one-time login followed by a verified no-window handoff, run \`${loginCommand} --background\`. The same profile is reused; a closed tab alone does not mean you logged out.`);
     }
     else {
         stdout("The dedicated profile path above will be reused by the real login command.");

package/dist/continue-thread.js

@@ -72,6 +72,9 @@ export function projectIdsByName(threadUrls) {
     }
     return byName;
 }
+function projectIdFromThreadUrl(threadUrl) {
+    return /\/g\/g-p-([0-9a-f]+)(?:-|\/)/i.exec(threadUrl)?.[1]?.toLowerCase();
+}
 /**
  * Whether a recorded thread belongs to the project this send is for.
  *
@@ -153,13 +156,22 @@ export function resolveContinuationThread(input) {
                 "Pass --session-key <id> (or PRODEX_SESSION_KEY/CODEX_THREAD_ID), or name the intended consult with --continue-task <task_id>."
         };
     }
-    const knownProjectIds = new Set(input.project ? projectIdsByName(withThread.map((consult) => consult.thread)).get(chatGptProjectSlug(input.project)) ?? [] : []);
-    if (input.projectId)
-        knownProjectIds.add(input.projectId.toLowerCase());
+    const recordedProjectIds = new Set(input.project ? projectIdsByName(withThread.map((consult) => consult.thread)).get(chatGptProjectSlug(input.project)) ?? [] : []);
+    if (input.project && !input.projectId && recordedProjectIds.size > 1) {
+        return {
+            error: `Recorded project name "${input.project}" is ambiguous because its consult threads use multiple project ids. ` +
+                "Name the intended conversation with --continue-task <task_id>."
+        };
+    }
+    const selectedProjectId = input.project
+        ? input.projectId?.replace(/^g-p-/i, "").toLowerCase() ?? recordedProjectIds.values().next().value
+        : undefined;
     const candidates = withThread
         .filter((consult) => consult.sessionKey === input.sessionKey)
         .filter((consult) => consult.status === "done")
-        .filter((consult) => threadMatchesProject(consult.thread, input.project, knownProjectIds))
+        .filter((consult) => selectedProjectId
+        ? projectIdFromThreadUrl(consult.thread) === selectedProjectId
+        : threadMatchesProject(consult.thread, input.project))
         .sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
     const latest = candidates[0];
     if (!latest) {
@@ -169,5 +181,18 @@ export function resolveContinuationThread(input) {
                 `Send once without --continue, or name a consult with --continue-task <task_id>.`
         };
     }
+    const unreliableWarningPrefixes = [
+        "answer_incomplete:",
+        "request_unverified:",
+        "receipt_record_warning:",
+        "session_record_warning:"
+    ];
+    const unreliableWarning = latest.warnings?.find((warning) => unreliableWarningPrefixes.some((prefix) => warning.startsWith(prefix)));
+    if (unreliableWarning) {
+        return {
+            error: `Cannot implicitly continue consult "${latest.taskId}" because its record is unreliable: ${unreliableWarning} ` +
+                `Recover and verify the original answer first. After explicit user review, name it with --continue-task ${latest.taskId}. Do not resend automatically.`
+        };
+    }
     return { target: { taskId: latest.taskId, thread: latest.thread } };
 }

package/dist/issue-report.js

@@ -49,9 +49,7 @@ export function buildIssueReport(consult, environment) {
         `| platform | ${environment.platform} |`,
         `| node | ${environment.nodeVersion} |`,
         "",
-        "Private error details and recovery instructions are omitted. Review the local receipt before sharing more context.",
-        "",
-        "Receipt (local, not attached): " + consult.task_id
+        "Private error details and recovery instructions are omitted. Review the local receipt before sharing more context."
     ].join("\n");
     return {
         title: `${code}: ${message || "blocked consult"}`.slice(0, 120),

package/docs/cli-reference.md

@@ -118,7 +118,13 @@ What happens:
 ~/.local/share/prodex/chrome-chatgpt-pro
 ```
 
-You can close that Chrome window after check/smoke or when you are done. The next time you need it, run `pro browser login` or `pro browser check` again. `check` will tell you what to do if the browser is closed.
+Closing that Chrome window does not switch to headless mode or prove that the saved login was erased. Keep it open for headed consults. Closing the terminal after READY is safe because Chrome is detached; closing the CLI or agent during a consult may interrupt answer collection.
+
+For a one-time interactive login followed by a no-window handoff, run `prodex pro browser login --background`. It waits even without a terminal, verifies readiness, then under the shared send lock gracefully closes the idle dedicated browser and launches the same profile and conversation headless. Wait for `background: READY`. The resulting mode is recorded for future CLI/MCP relaunches. This option cannot be combined with other window modes or `--no-wait`; `--dry-run` previews without opening or closing anything. Other page targets (including Chrome account prompts), dialogs, drafts, attachments, active responses, and uncertain browser identity/shutdown stop the handoff. Headless authentication and protection checks are never bypassed.
+
+If only the ChatGPT tab was closed, MCP and auto-login-enabled CLI requests can reopen one tab in the existing browser before an unsent request. They verify the saved login before sending and never use this path to resend an accepted or uncertain request.
+
+Before requesting `--background`, finish native browser and OS confirmations yourself. Page targets and rendered dialogs are checked, but Chrome does not expose every native prompt through CDP. Incognito/guest mode and an explicit `--profile-directory` are refused because their login identity cannot be safely handed off by this launcher.
 
 Actual explicit visible-browser consult (`prodex ask` is the short form of `prodex pro browser ask`):
 
@@ -200,18 +206,18 @@ A browser already running on your desktop cannot be moved onto a virtual display
 
 ### Keeping the window, just out of the way
 
-`prodex pro browser login --minimized` (or `PRODEX_MINIMIZE_WINDOW=1`) launches the dedicated browser and then minimizes it. It stays a **real headed Chrome** — which is the point, because Cloudflare admits headed browsers and rejects headless ones — but nothing sits on your desktop.
+`prodex pro browser login --minimized` (or `PRODEX_MINIMIZE_WINDOW=1`) launches the dedicated browser and then minimizes it. It stays a **real headed Chrome**, which worked in the previous test where headless Chrome encountered a challenge. This is not a guarantee that future verification checks will pass.
 
 The catch is what "minimized" means to your desktop. Under WSLg a minimized Chrome still reports `visibilityState: "visible"`, so consults keep working (measured: a real Pro send completed in 26s with the window minimized). A normal Linux desktop instead marks minimized windows hidden, and prodex refuses to send into a tab it cannot read — so it restores the window and tells you, rather than leaving you a browser it cannot use. Try it; the login says which case you are in.
 
-### Headless mode (not usable against ChatGPT today)
+### Headless mode (requires live readiness verification)
 
 `prodex pro browser login --headless` (or `PRODEX_HEADLESS=1`, which also covers the MCP server and its auto-recovery) runs the dedicated browser with no visible window. Two constraints are real, not cosmetic:
 
 - **Sign in headed first.** Nobody can log in to a window that does not exist, so headless reuses a profile you already signed into. If login, captcha, Cloudflare, permission, or account verification is needed, close the hidden browser yourself and run `prodex pro browser login --headed` for a visible interactive window. Do not merely omit `--headless`: saved modes persist.
-- **One mode at a time.** A single Chrome profile cannot serve a headed and a headless instance simultaneously; close the running one before switching (prodex refuses the switch instead of silently reusing the wrong mode).
+- **One mode at a time.** A single Chrome profile cannot serve a headed and a headless instance simultaneously. Use the guarded `--background` handoff for headed-to-headless operation, or close the browser yourself before an explicit mode switch.
 
-**Cloudflare is the catch, and it is not theoretical.** Measured on a real signed-in profile: headless Chrome lands on the "Just a moment..." interstitial and stays there past 60 seconds, so ChatGPT never loads. A signed-in profile does not buy a pass — the challenge keys on the headless browser itself. Treat `--headless` as available-but-unproven against ChatGPT: if `prodex pro browser check` reports the challenge, run `prodex pro browser login --headed` and complete it visibly. prodex does not invoke a hidden API or bypass login/protection. Only the window is optional; the login is not.
+**A saved login does not guarantee headless readiness.** A previous test on a signed-in profile remained on the "Just a moment..." interstitial past 60 seconds. That observation does not establish why the challenge appeared or prove that the saved login was lost. Require an actual READY result; if a protection check blocks the browser, stop and inspect it visibly. prodex does not invoke a hidden API or bypass login/protection. Only the window is optional; the login is not.
 
 If a consult finds the browser closed, prodex now relaunches it in the same mode you last used and retries once — including from the MCP server, which has no terminal to prompt in. `PRODEX_NO_AUTO_LOGIN=1` turns that off.
 

package/docs/clients.md

@@ -74,9 +74,17 @@ already-resolved target). An answer that failed to save or is incomplete does no
 invite another automatic turn; report it and resolve the blocker first.
 
 After updating the installed package, reconnect the MCP server or restart the agent
-client. A running stdio process keeps the old code until it exits. The dedicated
-browser profile is unchanged, so restarting Codex/Claude does not require signing in
-to ChatGPT again.
+client. A running stdio process keeps the old code until it exits. This preserves the
+dedicated browser profile and does not itself require signing in again. A saved
+ChatGPT session can still expire independently; stop on `login_required` and finish
+the login manually.
+
+Stdio MCP does not require tmux or a terminal. The client launches prodex and keeps
+its stdin/stdout pipes open. Keep that client or its remote SSH session running
+while a consult is pending; restarting it can interrupt answer collection even if
+ChatGPT is still generating. Recover that marked request instead of resending it.
+The separate `prodex start` HTTP server runs in the foreground and also needs its
+own process kept alive; neither command installs a background service.
 
 ## Claude Code
 

package/docs/releasing.md

@@ -2,6 +2,20 @@
 
 How a version of `@youdie006/prodex` gets from `main` to npm, and the checks that guard it. Moved here from the README so the README can stay about using the tool.
 
+## 0.40.13 Verification Record
+
+Release target: `v0.40.13` on `main`. The GitHub Release records the resolved commit, publication workflow and final installation checks; an installed candidate is not proof of public publication or a restarted MCP process.
+
+- PASS: `npm run release:verify` after updating the obsolete window-closing assertions. This ran the full tests, typecheck, build, installed-package CLI/HTTP-MCP/stdio-MCP smoke and doctor.
+- PASS: `npx vitest run tests/browser-handoff.test.ts tests/background-login.test.ts --maxWorkers=2`, 30 tests. Targeted regressions first failed for stale mode, incognito/guest, explicit Chrome sub-profile and incorrect launch-mode recording, then passed with the fixes.
+- PASS: Node 20 imports the built handoff module; background dry-run works without opening a browser. This is not a Node 20 live Pro test.
+- PASS: M3 candidate CLI without tmux refused the existing Chrome account confirmation, returned exit 1, did not report READY, and preserved the same browser PIDs and page targets. Runtime modules matched the tested local build by SHA-256.
+- BLOCKED: M3's native account confirmation requires manual action before the actual close/relaunch can be tested. Not every OS dialog is exposed through CDP; native confirmations must be finished before requesting a handoff.
+- BLOCKED: local WSL headless startup with the saved profile reached `cloudflare_check`, not READY. No Pro request was sent and no protective check was bypassed.
+- Earlier full checks failed on two outdated CLI guidance assertions and then one installed-document assertion. Those expectations were corrected; the subsequent complete verification passed. WSL packaging used normalized staging because mount file modes are not publishable directly; the user's unrelated untracked file was left untouched.
+
+The release adds a guarded, opt-in transition and more accurate blocker reporting. It does not claim that headless Pro consultation is verified on either deployment target or that authentication can be retained indefinitely.
+
 ## Publishing
 
 Publishing to npm runs entirely in CI with **no long-lived token** — auth is npm [trusted publishing](https://docs.npmjs.com/trusted-publishers) (OIDC), so nothing needs to store or paste an `NPM_TOKEN`, and every release carries a verifiable `--provenance` attestation.
@@ -15,7 +29,7 @@ git tag v0.8.2
 git push origin v0.8.2
 ```
 
-`.github/workflows/publish.yml` fires on a `v*.*.*` tag: it checks out, installs, verifies the tag equals `package.json`'s version, runs `release:verify`, and publishes with `npm publish --provenance --access public`. The tag/version guard prevents publishing a mismatched version.
+`.github/workflows/publish.yml` fires on a `v*.*.*` tag: it checks out, installs, verifies the tag equals `package.json`'s version, builds, runs `release:check -- --metadata-only` and `release:verify`, then publishes with `npm publish --provenance --access public --ignore-scripts`. The explicit metadata check also runs for manual workflow dispatches. It is required because `--ignore-scripts` skips `prepublishOnly`; a separate main-branch CI run is not a substitute for checking the commit being published.
 
 One-time setup (owner, on npmjs.com): open the package → Settings → Trusted Publishing → add a GitHub Actions publisher for repo `youdie006/prodex` and workflow `publish.yml`. After that, no npm tokens are needed anywhere; revoke any previously issued automation tokens.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.40.11",
+  "version": "0.40.13",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",
@@ -59,12 +59,14 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.13.3",
+    "ws": "^8.21.3",
     "zod": "^3.25.67"
   },
   "devDependencies": {
     "@types/node": "^22.15.32",
+    "@types/ws": "^8.18.1",
     "tsx": "^4.20.3",
     "typescript": "^5.8.3",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.11"
   }
 }