@youdie006/prodex 0.40.6 → 0.40.9

package/dist/chatgpt-browser.js

@@ -2,11 +2,13 @@ import { spawn, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { accessSync, constants, statSync } from "node:fs";
 import net from "node:net";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { captureBrowserDiagnostics, diagnosticsEnabled, diagnosticsNote } from "./browser-diagnostics.js";
+import { withCrossProcessFileLock } from "./safe-file.js";
 import os from "node:os";
 import { answeredDialogWarning, chatSurfaceState, effortNeedsWorkSurface, javascriptDialogResponse, menuKeyboardStep, readPowerSliderSelection, sliderRestoreStep, surfaceFromProbe, sliderPressOutcome, sliderDidNotRespond } from "./picker-interaction.js";
+import { projectsWithIdsExpression, recentConversationTitlesExpression } from "./tui.js";
 export class ChatGptBrowserBlockerError extends Error {
     blocker;
     constructor(blocker) {
@@ -15,8 +17,14 @@ export class ChatGptBrowserBlockerError extends Error {
         this.blocker = blocker;
     }
 }
-/** Where ChatGPT persists the Chat/Work choice, readable on every page. */
-const CHAT_SURFACE_STORAGE_KEY = "oai/apps/tpp/chat-surface-mode";
+function unsupportedChatGptOperationError(operation, nextStep) {
+    return new ChatGptBrowserBlockerError({
+        code: "unsupported_chatgpt_operation",
+        message: `${operation} is disabled because prodex cannot complete it through bounded, visible browser controls.`,
+        retryable: false,
+        next_step: nextStep
+    });
+}
 /** ~10s: measured, the surface took seconds to re-render after switching. */
 const CHAT_SURFACE_SETTLE_ATTEMPTS = 14;
 /** A full trip round the menu is far more than any real picker needs. */
@@ -231,11 +239,6 @@ export function buildChromeLaunchArgs(options) {
         options.url
     ];
 }
-/**
- * Headless is opt-in: an explicit option wins, otherwise PRODEX_HEADLESS
- * (1/true/yes) decides. The env var is the practical switch because the MCP
- * server and its auto-recovery launch the browser with no CLI flags.
- */
 /**
  * Minimize the dedicated browser window and report whether the tab is still
  * readable afterwards.
@@ -283,10 +286,10 @@ export async function minimizeChatGptWindow(options = {}) {
 // ---------------------------------------------------------------------------
 const VIRTUAL_DISPLAY_SCREEN = "1440x900x24";
 /**
- * X server arguments. The display is served over loopback TCP because WSLg
- * mounts /tmp/.X11-unix read-only, so the usual unix socket cannot be created;
- * an xauth cookie (never -ac) keeps other local processes off a display that
- * shows a signed-in ChatGPT window.
+ * X server arguments. Linux still creates its abstract X11 socket when the
+ * filesystem Unix transport is disabled, which works with WSLg's read-only
+ * /tmp/.X11-unix mount without exposing the display over TCP. An xauth cookie
+ * (never -ac) keeps other local processes off the signed-in browser display.
  */
 export function virtualDisplayServerArgs(displayNumber, xauthority) {
     return [
@@ -294,22 +297,22 @@ export function virtualDisplayServerArgs(displayNumber, xauthority) {
         "-screen",
         "0",
         VIRTUAL_DISPLAY_SCREEN,
-        "-listen",
+        "-nolisten",
         "tcp",
         "-nolisten",
         "unix",
         "-auth",
-        xauthority
+        xauthority,
+        "-pn"
     ];
 }
 export function virtualDisplayEnv(displayNumber, xauthority, env = process.env) {
-    return { ...env, DISPLAY: `127.0.0.1:${displayNumber}`, XAUTHORITY: xauthority };
+    return { ...env, DISPLAY: `:${displayNumber}`, XAUTHORITY: xauthority };
 }
 export function resolveVirtualDisplayPreference(explicit, env = process.env) {
     if (typeof explicit === "boolean")
         return explicit;
-    const raw = (env.PRODEX_VIRTUAL_DISPLAY ?? "").trim().toLowerCase();
-    return raw === "1" || raw === "true" || raw === "yes";
+    return browserModeSettingValue(env.PRODEX_VIRTUAL_DISPLAY);
 }
 export function assertVirtualDisplayToolingAvailable(hasCommand = isCommandOnPath) {
     const missing = ["Xvfb", "xauth"].filter((command) => !hasCommand(command));
@@ -320,10 +323,21 @@ export function assertVirtualDisplayToolingAvailable(hasCommand = isCommandOnPat
 function virtualDisplayStateDir() {
     return path.join(os.homedir(), ".local", "share", "prodex", "xvfb");
 }
-async function tcpPortAccepts(port, timeoutMs = 500) {
+async function socketAccepts(connect, timeoutMs = 500) {
     return new Promise((resolve) => {
-        const socket = net.connect({ host: "127.0.0.1", port });
+        let socket;
+        try {
+            socket = connect();
+        }
+        catch {
+            resolve(false);
+            return;
+        }
+        let settled = false;
         const done = (result) => {
+            if (settled)
+                return;
+            settled = true;
             socket.destroy();
             resolve(result);
         };
@@ -333,26 +347,47 @@ async function tcpPortAccepts(port, timeoutMs = 500) {
         socket.once("error", () => done(false));
     });
 }
+async function tcpPortAccepts(port, timeoutMs = 500) {
+    return socketAccepts(() => net.connect({ host: "127.0.0.1", port }), timeoutMs);
+}
+function virtualDisplayAbstractSocket(displayNumber) {
+    return `\0/tmp/.X11-unix/X${displayNumber}`;
+}
+async function virtualDisplaySocketAccepts(displayNumber, timeoutMs = 500) {
+    return socketAccepts(() => net.connect({ path: virtualDisplayAbstractSocket(displayNumber) }), timeoutMs);
+}
 /**
  * Start (or reuse) the prodex virtual display and return how to reach it.
  * The X server outlives the CLI process on purpose: the dedicated browser runs
  * on it, so tearing it down at exit would kill the browser.
  */
 export async function ensureVirtualDisplay(options = {}) {
+    if (process.platform !== "linux") {
+        throw new Error(`Virtual display abstract Unix sockets are supported on Linux/WSL only (current platform: ${process.platform}).`);
+    }
     assertVirtualDisplayToolingAvailable();
     const stateDir = virtualDisplayStateDir();
-    await mkdir(stateDir, { recursive: true, mode: 0o700 });
+    const allocationLock = path.join(stateDir, "allocation.lock");
+    return withCrossProcessFileLock(allocationLock, {
+        waitMs: 30_000,
+        privateParent: true,
+        busyError: () => new Error("Another prodex command is starting a virtual display. Wait for it to finish, then retry."),
+        unavailableError: () => new Error(`Virtual display allocation lock at ${allocationLock} is unavailable. Stop all prodex startups before removing that lock and its matching .reap claim, then retry.`)
+    }, () => ensureVirtualDisplayUnlocked(stateDir, options));
+}
+async function ensureVirtualDisplayUnlocked(stateDir, options) {
     const requested = options.displayNumber ?? Number(process.env.PRODEX_VIRTUAL_DISPLAY_NUM ?? 99);
     const first = Number.isInteger(requested) && requested > 0 && requested < 1000 ? requested : 99;
-    // Walk display numbers: a listening display is only reusable when OUR cookie
-    // for it exists, otherwise it belongs to something else (another tool, or a
-    // stale server started with a different key) and we could not authenticate
-    // to it - that produced "Authorization required" and a browser that died on
-    // launch. A free number gets a fresh server.
+    // Walk display numbers. Any legacy TCP listener reserves its number even if
+    // our old auth file still exists: never migrate, kill, or overwrite it. An
+    // abstract-only display is reusable when our cookie for it exists; otherwise
+    // it belongs to something else and cannot be authenticated. A number with
+    // neither transport gets a fresh server.
     for (let displayNumber = first; displayNumber < first + 10; displayNumber += 1) {
         const xauthority = path.join(stateDir, `Xauthority-${displayNumber}`);
-        const listening = await tcpPortAccepts(6000 + displayNumber);
-        if (listening) {
+        if (await tcpPortAccepts(6000 + displayNumber))
+            continue;
+        if (await virtualDisplaySocketAccepts(displayNumber)) {
             let ours = false;
             try {
                 ours = (await readFile(xauthority)).length > 0;
@@ -366,33 +401,78 @@ export async function ensureVirtualDisplay(options = {}) {
         }
         const cookie = randomBytes(16).toString("hex");
         await writeFile(xauthority, "", { mode: 0o600 });
-        const auth = spawnSync("xauth", ["-f", xauthority, "add", `127.0.0.1:${displayNumber}`, ".", cookie], {
+        await chmod(xauthority, 0o600);
+        const auth = spawnSync("xauth", ["-f", xauthority, "add", `:${displayNumber}`, ".", cookie], {
             encoding: "utf8",
             timeout: 10_000
         });
         if (auth.status !== 0) {
             throw new Error(`Could not create the X authority cookie: ${(auth.stderr || auth.stdout || "xauth failed").trim()}`);
         }
-        const child = spawn("Xvfb", virtualDisplayServerArgs(displayNumber, xauthority), {
-            detached: true,
-            stdio: "ignore",
-            env: process.env
+        await chmod(xauthority, 0o600);
+        let child;
+        try {
+            child = spawn("Xvfb", virtualDisplayServerArgs(displayNumber, xauthority), {
+                detached: true,
+                stdio: "ignore",
+                env: process.env
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Could not start Xvfb for display :${displayNumber}: ${message}`);
+        }
+        let rejectStartup;
+        const startupFailed = new Promise((_resolve, reject) => {
+            rejectStartup = reject;
+        });
+        child.on("error", (error) => {
+            rejectStartup(new Error(`Could not start Xvfb for display :${displayNumber}: ${error.message}`));
+        });
+        child.once("exit", (code, signal) => {
+            rejectStartup(new Error(`Xvfb for display :${displayNumber} exited before its abstract socket was ready (code ${code ?? "null"}, signal ${signal ?? "none"}).`));
         });
         child.unref();
-        const deadline = Date.now() + 10_000;
-        while (Date.now() < deadline) {
-            if (await tcpPortAccepts(6000 + displayNumber))
-                return { displayNumber, xauthority, startedNow: true };
-            await sleep(250);
+        try {
+            const deadline = Date.now() + 10_000;
+            while (Date.now() < deadline) {
+                if (await Promise.race([virtualDisplaySocketAccepts(displayNumber), startupFailed])) {
+                    return { displayNumber, xauthority, startedNow: true };
+                }
+                await Promise.race([sleep(250), startupFailed]);
+            }
+            throw new Error(`Xvfb did not open its abstract socket for display :${displayNumber} within 10s.`);
+        }
+        catch (error) {
+            if (child.exitCode === null && child.signalCode === null) {
+                try {
+                    child.kill("SIGTERM");
+                }
+                catch {
+                    // The exact child may already have disappeared between the state
+                    // check and kill; never broaden cleanup beyond this invocation.
+                }
+            }
+            throw error;
         }
-        throw new Error(`Xvfb did not start listening for display :${displayNumber} within 10s.`);
     }
     throw new Error(`No free X display between :${first} and :${first + 9}. Set PRODEX_VIRTUAL_DISPLAY_NUM to a free number.`);
 }
+function browserModeSettingValue(raw) {
+    const normalized = (raw ?? "").trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+function assertSingleBrowserWindowMode(modes) {
+    const enabled = modes.filter((mode) => mode.enabled).map((mode) => mode.label);
+    if (enabled.length > 1) {
+        throw new Error(`Browser window mode settings cannot combine ${enabled.join(" and ")}; choose exactly one.`);
+    }
+}
 /**
  * How should the dedicated browser be opened?
  *
- * An explicit flag or environment variable wins; otherwise reopen it the way it
+ * An explicitly supplied flag group wins; otherwise any non-empty environment
+ * mode group wins, including false values. With neither, reopen it the way it
  * was last opened. Without the saved fallback, `pro browser login` - the exact
  * command every `browser_unreachable` blocker tells people to run - put a
  * VISIBLE window back on the desktop of someone who had set up a virtual
@@ -405,37 +485,53 @@ export async function ensureVirtualDisplay(options = {}) {
 export function resolveBrowserWindowMode(args) {
     const env = args.env ?? process.env;
     const flags = args.flags ?? {};
-    const fromEnv = (name) => {
-        const raw = (env[name] ?? "").trim().toLowerCase();
-        if (raw === "")
-            return undefined;
-        return raw === "1" || raw === "true" || raw === "yes";
-    };
-    const explicit = {
-        headless: flags.headless ?? fromEnv("PRODEX_HEADLESS"),
-        virtualDisplay: flags.virtualDisplay ?? fromEnv("PRODEX_VIRTUAL_DISPLAY"),
-        minimized: flags.minimized ?? fromEnv("PRODEX_MINIMIZE_WINDOW")
-    };
-    const chosen = Object.values(explicit).some((value) => value === true);
-    if (chosen) {
+    const flagGroupSupplied = Object.values(flags).some((value) => typeof value === "boolean");
+    if (flagGroupSupplied) {
+        assertSingleBrowserWindowMode([
+            { enabled: flags.headless === true, label: "--headless" },
+            { enabled: flags.virtualDisplay === true, label: "--virtual-display" },
+            { enabled: flags.minimized === true, label: "--minimized" },
+            { enabled: flags.headed === true, label: "--headed" }
+        ]);
         return {
-            headless: explicit.headless === true,
-            virtualDisplay: explicit.virtualDisplay === true,
-            minimized: explicit.minimized === true
+            headless: flags.headless === true,
+            virtualDisplay: flags.virtualDisplay === true,
+            minimized: flags.minimized === true
         };
     }
+    const envModes = [
+        { key: "PRODEX_HEADLESS", mode: "headless" },
+        { key: "PRODEX_VIRTUAL_DISPLAY", mode: "virtualDisplay" },
+        { key: "PRODEX_MINIMIZE_WINDOW", mode: "minimized" }
+    ];
+    const envGroupSupplied = envModes.some(({ key }) => (env[key] ?? "").trim() !== "");
+    if (envGroupSupplied) {
+        const selected = Object.fromEntries(envModes.map(({ key, mode }) => [mode, browserModeSettingValue(env[key])]));
+        assertSingleBrowserWindowMode(envModes.map(({ key, mode }) => ({ enabled: selected[mode], label: key })));
+        return selected;
+    }
     const saved = args.lastLogin;
-    return {
+    const selected = {
         headless: saved?.headless === true,
         virtualDisplay: saved?.virtual_display !== undefined,
         minimized: saved?.minimized === true
     };
+    assertSingleBrowserWindowMode([
+        { enabled: selected.headless, label: "saved headless mode" },
+        { enabled: selected.virtualDisplay, label: "saved virtual-display mode" },
+        { enabled: selected.minimized, label: "saved minimized mode" }
+    ]);
+    return selected;
 }
+/**
+ * Resolve only the low-level headless toggle for direct browser-boundary
+ * callers. Login and recovery use resolveBrowserWindowMode so all primary
+ * modes share one precedence and conflict policy.
+ */
 export function resolveHeadlessPreference(explicit, env = process.env) {
     if (typeof explicit === "boolean")
         return explicit;
-    const raw = (env.PRODEX_HEADLESS ?? "").trim().toLowerCase();
-    return raw === "1" || raw === "true" || raw === "yes";
+    return browserModeSettingValue(env.PRODEX_HEADLESS);
 }
 /**
  * The two verdicts read different text on purpose.
@@ -618,19 +714,43 @@ export function isFreshChatGptPage(state) {
     const onRoot = /^https:\/\/chatgpt\.com\/?(?:[?#].*)?$/.test(state.url);
     return onRoot && state.assistantMessageCount === 0 && state.userMessageCount === 0;
 }
+/** Check and navigate in one renderer task, so a late stop control prevents the move. */
+export function idleChatGptNavigationExpression(url) {
+    return `(() => {
+    const status = ${statusExpression()};
+    if (status.generating && !status.awaitingResponseChoice) return false;
+    location.assign(${JSON.stringify(url)});
+    return true;
+  })()`;
+}
+async function navigateIdleChatGptPage(page, url) {
+    if (await evaluateOnPage(page, idleChatGptNavigationExpression(url)) !== true) {
+        throw new ChatGptBrowserBlockerError({
+            code: "response_in_progress",
+            message: "The shared ChatGPT tab became busy before navigation. Nothing was sent or moved.",
+            retryable: true,
+            next_step: "Wait for the current response to finish before retrying this operation."
+        });
+    }
+}
 /**
  * Poll until the tab settles on a fresh empty chat (or the timeout elapses).
  * Deterministically replaces a fixed post-navigation sleep so a slow SPA
- * navigation cannot leave the old thread's state in place. Best-effort: on
- * timeout it returns and the caller proceeds (the acceptance logic still
- * guards), but the poll removes the common race.
+ * navigation cannot leave the old thread's state in place. A false result
+ * must not be used as permission to send into stale content.
  */
 async function waitForFreshChatGptPage(page, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        const state = await evaluateOnPage(page, answerExpression());
-        if (isFreshChatGptPage(state))
-            return true;
+        try {
+            const state = await evaluateOnPage(page, answerExpression());
+            if (isFreshChatGptPage(state))
+                return true;
+        }
+        catch (error) {
+            if (!/execution context|cannot find context|Runtime\.evaluate failed/i.test(String(error)))
+                throw error;
+        }
         await sleep(300);
     }
     return false;
@@ -794,23 +914,6 @@ export function busyBlockerAfterTranscriptCheck(busyBlocker, transcript) {
         return undefined;
     return transcript?.ok === true && transcript.isComplete === true ? undefined : busyBlocker;
 }
-/**
- * Ask the transcript whether the conversation the tab is showing has finished.
- * Undefined when there is nothing to ask about (a fresh chat or project home
- * carries no conversation id) or the read fails.
- */
-async function readTranscriptCompletion(page, url) {
-    const conversationId = conversationIdFromThreadUrl(url);
-    if (!conversationId)
-        return undefined;
-    try {
-        const state = await evaluateOnPage(page, transcriptAnswerExpression(conversationId));
-        return { ok: state.ok === true, ...(state.isComplete !== undefined ? { isComplete: state.isComplete } : {}) };
-    }
-    catch {
-        return undefined;
-    }
-}
 export function isLikelyChatGptSubmitButton(label, dataTestId) {
     const normalized = label.trim().toLowerCase();
     return dataTestId === "send-button" || /\b(send|submit)\b|보내기|전송/.test(normalized);
@@ -1317,7 +1420,7 @@ export async function getChatGptBrowserStatus(options = {}) {
     const blocker = chatGptVisibilityBlocker(state.visibilityState, state.url) ??
         detectChatGptPageBlocker(state) ??
         chatGptResponseChoiceBlocker(state.awaitingResponseChoice === true) ??
-        (busyBlocker ? busyBlockerAfterTranscriptCheck(busyBlocker, await readTranscriptCompletion(page.page, state.url)) : undefined);
+        busyBlocker;
     return {
         reachable: true,
         loggedInLikely,
@@ -1653,21 +1756,7 @@ export function chatSurfaceProbeExpression() {
       label: ((el.innerText || el.textContent || "").trim()),
       checked: el.getAttribute("aria-checked") === "true" || el.getAttribute("aria-selected") === "true"
     }));
-    // The toggle is only on the home screen, but the choice is persisted where
-    // every page can read it.
-    let storedMode = "";
-    try {
-      storedMode = localStorage.getItem(${JSON.stringify(CHAT_SURFACE_STORAGE_KEY)}) || "";
-    } catch (error) {
-      storedMode = "";
-    }
-    if (!storedMode) {
-      // Anchored to the start of a cookie, so a name that merely ENDS with this
-      // one cannot answer for it.
-      const m = document.cookie.match(/(?:^|;)\\s*oai-chat-surface-mode=([^;]*)/);
-      storedMode = m ? decodeURIComponent(m[1]) : "";
-    }
-    return { surfaces, storedMode };
+    return { surfaces };
   })()`;
 }
 /** Where to click to go back to Chat. Only asked once a switch is decided. */
@@ -1679,21 +1768,6 @@ export function chatSurfaceToggleRectExpression() {
     return chat ? clickPoint(chat) : { ok: false, reason: "no Chat toggle" };
   })()`;
 }
-export function selectChatSurfaceExpression() {
-    return `(() => {
-    try {
-      localStorage.setItem(${JSON.stringify(CHAT_SURFACE_STORAGE_KEY)}, JSON.stringify("chat"));
-    } catch (error) {
-      // a blocked store is not fatal: the cookie below is what the app reads
-    }
-    // Host-only, the way the app writes it. Setting a domain-wide copy instead
-    // left two oai-chat-surface-mode cookies in play - one chat, one work - and
-    // which of them won was anyone's guess.
-    document.cookie = "oai-chat-surface-mode=chat; path=/; max-age=" + (60 * 60 * 24 * 365);
-    document.cookie = "oai-chat-surface-mode=; path=/; domain=.chatgpt.com; max-age=0";
-    return true;
-  })()`;
-}
 /**
  * Name of the stamp put on a document that is about to be reloaded. A stamp
  * cannot survive a navigation, so its absence is what tells the reloaded
@@ -2295,35 +2369,6 @@ async function ensureChatSurface(cdp, options) {
                 return note;
         }
     }
-    catch (error) {
-        if (cdpCommandTimedOut(error))
-            throw error;
-        // fall through to the stored preference, which works without the toggle
-    }
-    // Threads and project pages do not render the toggle at all, so the surface
-    // is set the way the app itself stores it and the page is reloaded onto it.
-    try {
-        await cdp.evaluate(selectChatSurfaceExpression());
-        // Reading the persisted value back right after writing it proves nothing;
-        // the new document rendering its composer is what proves the switch.
-        const plan = chatSurfaceRecoveryPlan({
-            href: await cdp.evaluate("location.href"),
-            mayLeaveCurrentPage: options.mayLeaveCurrentPage
-        });
-        let applied;
-        if (plan === "fresh-root") {
-            // Throws when the root never rendered a composer, which the catch below
-            // turns into the same "could not be switched back" warning as a reload
-            // that never settled.
-            await openFreshChatGptHome(cdp);
-            applied = true;
-        }
-        else {
-            applied = await reloadAndAwaitComposer(cdp, RELOAD_SETTLE_TIMEOUT_MS);
-        }
-        if (applied && (await confirm()))
-            return note;
-    }
     catch (error) {
         if (cdpCommandTimedOut(error))
             throw error;
@@ -2537,7 +2582,12 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
         // GPT-5.6 Sol) instead of a model radio list, so "Pro" is the top EFFORT.
         // Drive it when it is there and fall through to the legacy radio path when
         // it is not, so both UI generations work.
-        const sliderState = await cdp.evaluate(powerSliderStateExpression());
+        let sliderState = await cdp.evaluate(powerSliderStateExpression());
+        if (!sliderState?.ok && await waitForExpressionTrue(cdp, powerSliderPresentExpression(), MENU_OPEN_TIMEOUT_MS)) {
+            // The container and model rows can paint before the effort control.
+            // Do not toggle an already-open menu or guess that this is the old UI.
+            sliderState = await cdp.evaluate(powerSliderStateExpression());
+        }
         if (sliderState?.ok) {
             // The slider is the EFFORT control and the models are radios beside it.
             // Sending a model name into the slider made it walk every step looking
@@ -3016,6 +3066,9 @@ async function selectProject(cdp, options) {
 // sits in the thread the operator can see. Navigates the visible tab to the
 // thread and waits for a stable, non-generating answer.
 export async function recoverChatGptAnswerFromThread(options) {
+    if (options.requestId !== undefined && !/^[a-f0-9]{32}$/.test(options.requestId)) {
+        throw new Error("requestId must be the 32-character prodex request identifier.");
+    }
     const port = resolveCdpPort(options.port);
     const timeoutMs = Math.max(1_000, options.timeoutMs ?? 60_000);
     const url = normalizeChatGptTargetUrl(options.targetUrl);
@@ -3028,60 +3081,27 @@ export async function recoverChatGptAnswerFromThread(options) {
             next_step: "Run `prodex pro browser login` to reopen the dedicated window - it reuses the saved session (no manual login unless it expired) and returns immediately when run non-interactively - then retry."
         });
     }
+    const currentStatus = await readSettledChatGptPageStatus(page.page);
+    const currentBlocker = detectChatGptPageBlocker(currentStatus);
+    if (currentBlocker)
+        throw new ChatGptBrowserBlockerError(currentBlocker);
+    const alreadyOnTarget = chatGptUrlsReferToSameTarget(currentStatus.url, url);
+    const currentBusy = chatGptBusyBlocker(currentStatus);
+    if (!alreadyOnTarget && currentBusy)
+        throw new ChatGptBrowserBlockerError(currentBusy);
     const cdp = await connectCdp(page.page.webSocketDebuggerUrl);
     let state;
     let generating = false;
     let stableRuns = 0;
     let lastAnswer = "";
+    let lastObservedUrl = "";
+    let completed = false;
     try {
         await cdp.send("Runtime.enable");
         // In-tab navigation (location.assign, not Page.navigate which has crashed the
         // instance) so we read the requested thread, not whatever was open.
-        await cdp.evaluate(`location.assign(${JSON.stringify(url)})`);
-        // A deep research thread has no assistant message to recover - its report
-        // lives in the widget state on the conversation transcript. Check that
-        // first so `recover` works on research threads at all.
-        const conversationId = conversationIdFromThreadUrl(url);
-        if (conversationId) {
-            try {
-                const report = await evaluateOnPage(page.page, deepResearchReportExpression(conversationId), {
-                    timeoutMs: 60_000
-                });
-                if (report.ok && report.report.trim().length > 0) {
-                    return {
-                        url,
-                        title: "",
-                        answer: resolveTranscriptCitations(report.report, report.references).trim(),
-                        modelHints: [],
-                        warnings: []
-                    };
-                }
-                // Not a research thread: read the ordinary answer from the transcript
-                // too. Recover used to be page-only, so it inherited everything the
-                // page loses - flattened markdown, dropped citation urls - and it once
-                // saved ChatGPT's "Connection interrupted" notice as the answer.
-                const transcript = await evaluateOnPage(page.page, transcriptAnswerExpression(conversationId), {
-                    timeoutMs: 60_000
-                });
-                if (transcript.ok && transcript.text.trim().length > 0) {
-                    const recovered = resolveTranscriptCitations(transcript.text, transcript.references).trim();
-                    if (recovered.length > 0) {
-                        return {
-                            url,
-                            title: "",
-                            answer: recovered,
-                            modelHints: [],
-                            ...(transcript.modelSlug ? { modelSlug: transcript.modelSlug } : {}),
-                            warnings: []
-                        };
-                    }
-                }
-            }
-            catch {
-                // Not a research thread, or the transcript API is unavailable: fall
-                // through to the normal DOM recovery below.
-            }
-        }
+        if (!alreadyOnTarget)
+            await navigateIdleChatGptPage(page.page, url);
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             await sleep(500);
@@ -3092,9 +3112,28 @@ export async function recoverChatGptAnswerFromThread(options) {
                 continue;
             }
             generating = state.generating;
+            if (state.url !== lastObservedUrl) {
+                lastObservedUrl = state.url;
+                stableRuns = 0;
+                lastAnswer = "";
+            }
             const runtimeBlocker = chatGptBlockerFromAnswerState(state);
             if (runtimeBlocker)
                 throw new ChatGptBrowserBlockerError(runtimeBlocker);
+            if (!chatGptUrlsReferToSameTarget(state.url, url)) {
+                stableRuns = 0;
+                lastAnswer = "";
+                continue;
+            }
+            if (options.requestId && !chatGptRequestMarkerMatches(state.lastUserText ?? "", options.requestId)) {
+                throw new ChatGptBrowserBlockerError({
+                    code: "request_mismatch",
+                    message: "The recovered conversation's latest user turn does not match the requested prodex request. No answer was returned.",
+                    retryable: false,
+                    next_step: "Inspect the original request in the browser. Do not treat a later turn in the same conversation as its answer.",
+                    thread: url
+                });
+            }
             // Require a REAL assistant message, not answerExpression's page-chrome
             // fallback (empty assistant returns sidebar/nav text): the thread's
             // conversation loads asynchronously after navigation, so keep polling.
@@ -3103,8 +3142,10 @@ export async function recoverChatGptAnswerFromThread(options) {
                 // must not sneak into the recovered text.
                 stableRuns = state.answer === lastAnswer ? stableRuns + 1 : 0;
                 lastAnswer = state.answer;
-                if (stableRuns >= 1)
+                if (stableRuns >= 1) {
+                    completed = true;
                     break;
+                }
             }
             else {
                 stableRuns = 0;
@@ -3115,65 +3156,61 @@ export async function recoverChatGptAnswerFromThread(options) {
     finally {
         cdp.close();
     }
-    if (!state || state.assistantMessageCount < 1 || !isUsableChatGptAnswer(state.answer)) {
-        throw new ChatGptBrowserBlockerError({
-            code: generating ? "still_generating" : "no_recoverable_answer",
-            message: generating
+    if (!completed) {
+        const targetMatched = Boolean(state && chatGptUrlsReferToSameTarget(state.url, url));
+        const hasUsableAnswer = Boolean(state && state.assistantMessageCount > 0 && isUsableChatGptAnswer(state.answer));
+        const code = !targetMatched
+            ? "thread_target_mismatch"
+            : generating
+                ? "still_generating"
+                : hasUsableAnswer
+                    ? "answer_not_stable"
+                    : "no_recoverable_answer";
+        const message = code === "thread_target_mismatch"
+            ? `The visible ChatGPT tab did not settle on the requested conversation. It remained at ${state?.url || "an unreadable page"}.`
+            : code === "still_generating"
                 ? "That thread is still generating - the answer is not complete yet."
-                : "No finished assistant answer loaded from that thread (the conversation may not have rendered, or the URL is not the consult thread).",
+                : code === "answer_not_stable"
+                    ? "That thread showed changing answer text through the recovery deadline, so prodex cannot mark it complete."
+                    : "No finished assistant answer loaded from that thread (the conversation may not have rendered, or the URL is not the consult thread).";
+        throw new ChatGptBrowserBlockerError({
+            code,
+            message,
             retryable: true,
-            next_step: generating
-                ? "Wait for ChatGPT to finish, then rerun `prodex pro browser recover --target-url <url>`."
-                : "Confirm the URL is the consult thread that shows a finished answer, raise --timeout-ms if the page loads slowly, or send a fresh consult."
+            next_step: code === "still_generating" || code === "answer_not_stable"
+                ? "Wait for ChatGPT to finish and settle, then rerun `prodex pro browser recover --target-url <url>`."
+                : "Keep the dedicated visible tab on the requested consult thread, confirm it shows a finished answer, and retry recovery with a larger --timeout-ms if needed.",
+            thread: url
         });
     }
     return {
-        url: state.url,
+        url,
         title: state.title,
         answer: state.answer.trim(),
         modelHints: state.modelHints,
         ...(state.modelSlug ? { modelSlug: state.modelSlug } : {}),
-        warnings: []
+        ...(options.requestId ? { requestId: options.requestId } : {}),
+        requestVerified: options.requestId !== undefined,
+        warnings: options.requestId ? [] : ["request_unverified: recovered the latest answer in the named conversation without a request ID. Verify the preceding question before using this as a review."]
     };
 }
-async function readTranscriptAnswer(page, conversationId, sentPrompt) {
-    let transcript;
-    try {
-        transcript = await evaluateOnPage(page, transcriptAnswerExpression(conversationId), { timeoutMs: 30_000 });
-    }
-    catch {
-        // Transcript unreachable (endpoint changed, transient failure): the DOM
-        // reader still runs, so this never blocks a send.
-        return { classification: "unavailable" };
-    }
-    const classification = classifyTranscriptRead(transcript, sentPrompt);
-    if (classification !== "answer")
-        return { classification };
-    const answer = resolveTranscriptCitations(transcript.text, transcript.references).trim();
-    return answer.length > 0
-        ? { classification: "answer", answer: { answer, modelSlug: transcript.modelSlug } }
-        : { classification: "no_text" };
-}
-// A page that has not reported the prompt posting within this long is worth
-// double-checking against the transcript; the probe is a couple of small fetches.
-const ACCEPTANCE_TRANSCRIPT_PROBE_AFTER_MS = 20_000;
-const ACCEPTANCE_TRANSCRIPT_PROBE_EVERY_MS = 10_000;
-/** Which conversation, if any, already holds the prompt this send posted. */
-async function findLandedConversation(page, prompt) {
-    try {
-        const candidates = await evaluateOnPage(page, recentConversationsExpression(4), {
-            timeoutMs: 30_000
-        });
-        return pickLandedConversation(candidates ?? [], prompt);
-    }
-    catch {
-        // Transcript unavailable: the caller falls back to the page.
-        return undefined;
-    }
-}
 export async function sendChatGptPrompt(options) {
+    const toolLabels = (options.tools ?? []).map(resolveComposerToolLabel);
+    if (toolLabels.includes(DEEP_RESEARCH_TOOL_LABEL)) {
+        throw unsupportedChatGptOperationError("Deep research", "Use Deep research directly in the visible ChatGPT UI, or send an ordinary prodex consult without the Deep research tool.");
+    }
     const port = resolveCdpPort(options.port);
     const timeoutMs = options.timeoutMs ?? 90_000;
+    const requestId = randomBytes(16).toString("hex");
+    const sentPrompt = `${options.prompt}\n\n[prodex-request:${requestId}]`;
+    const requestMatches = (state) => chatGptRequestMatchesUserTurn(state.lastUserText ?? "", sentPrompt, requestId);
+    const requestMismatch = (thread) => new ChatGptBrowserBlockerError({
+        code: "request_mismatch",
+        message: "The visible user turn does not match this prodex request. No answer was returned because it may belong to another session.",
+        retryable: false,
+        next_step: `Do not resend automatically. Inspect the original chat for [prodex-request:${requestId}] before recovering its answer.`,
+        ...(thread ? { thread } : {})
+    });
     /** Dialogs answered on the reload connection, which comes and goes before the send's own, so the receipt still says so. */
     const earlyDialogsAnswered = [];
     const sendStartedAt = Date.now();
@@ -3209,27 +3246,6 @@ export async function sendChatGptPrompt(options) {
         assertChatGptPageAvailable();
     }
     const page = pageResult.page;
-    if (options.newChat && !options.project && !options.projectNew) {
-        // Long accumulated threads eventually break acceptance detection, so
-        // start from a clean chat. Wait for the tab to actually reach the fresh
-        // empty chat (root URL, zero messages) rather than a fixed sleep: a slow
-        // SPA navigation could otherwise leave the old thread rendered, poisoning
-        // the answer-count baseline captured below and causing a false timeout.
-        //
-        // Skipped when a project is requested: the project home the selection step
-        // navigates to IS the fresh composer for "a new chat in this project".
-        // Navigating to the root new chat first leaves the SPA composer bound to
-        // the ROOT conversation target even after entering the project, so the
-        // thread silently lands outside the project (measured live: --new-chat
-        // --project threads appeared in the root chat list, --project-only
-        // threads appeared inside the project).
-        // A temporary chat is reached by url rather than by clicking the control:
-        // the same navigation this already does, one query parameter different, and
-        // nothing to find on a page whose buttons keep moving.
-        const freshUrl = options.temporary ? "https://chatgpt.com/?temporary-chat=true" : "https://chatgpt.com/";
-        await evaluateOnPage(page, `location.assign(${JSON.stringify(freshUrl)})`);
-        await waitForFreshChatGptPage(page, 8_000);
-    }
     let status = await readSettledChatGptPageStatus(page);
     status = await ensureVisibleChatGptPage(port, page, status);
     const blocker = detectChatGptPageBlocker(status);
@@ -3243,7 +3259,7 @@ export async function sendChatGptPrompt(options) {
     // timeout: consults continue threads by default, so landing on a thread
     // whose previous (often timed-out Pro) answer is still streaming is a when,
     // not an if - queueing behind it beats failing.
-    let busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
+    let busyBlocker = chatGptBusyBlocker(status);
     const busyWaitBudgetMs = options.busyWaitMs ?? timeoutMs;
     if (busyBlocker && busyWaitBudgetMs > 0) {
         // Queue behind the in-flight response instead of failing: shared-tab
@@ -3257,7 +3273,7 @@ export async function sendChatGptPrompt(options) {
             const midBlocker = detectChatGptPageBlocker(status);
             if (midBlocker)
                 throw new ChatGptBrowserBlockerError(midBlocker);
-            busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
+            busyBlocker = chatGptBusyBlocker(status);
             if (busyBlocker)
                 emitProgress("waiting", "tab busy with another response; waiting");
         }
@@ -3267,9 +3283,11 @@ export async function sendChatGptPrompt(options) {
             // weigh that fresh reading the same way - a generation that started in
             // the meantime must still hold the send back.
             status = await readSettledChatGptPageStatus(page);
-            busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
+            busyBlocker = chatGptBusyBlocker(status);
         }
     }
+    if (busyBlocker)
+        throw new ChatGptBrowserBlockerError(busyBlocker);
     // ChatGPT's error page does not come back on a reload - measured: a project
     // home that failed reloaded straight back into it - and the tab then stays
     // there for every later send, including the retry its own blocker asks for.
@@ -3294,7 +3312,7 @@ export async function sendChatGptPrompt(options) {
             // The busy verdict above was decided about the page we just left, and it
             // is handed to the readiness assert as already decided. Carrying it over
             // would let a root page that is generating an answer be typed into.
-            busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(fresh), await readTranscriptCompletion(page, fresh.url));
+            busyBlocker = chatGptBusyBlocker(fresh);
             status = fresh;
         }
         catch (error) {
@@ -3332,7 +3350,7 @@ export async function sendChatGptPrompt(options) {
             const blockerAfterReload = detectChatGptPageBlocker(fresh);
             if (blockerAfterReload)
                 throw new ChatGptBrowserBlockerError(blockerAfterReload);
-            busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(fresh), await readTranscriptCompletion(page, fresh.url));
+            busyBlocker = chatGptBusyBlocker(fresh);
             status = fresh;
         }
         catch (error) {
@@ -3359,6 +3377,26 @@ export async function sendChatGptPrompt(options) {
         throw new ChatGptBrowserBlockerError(chatGptResponseChoiceBlocker(true));
     }
     assertChatGptIdleAndReadyForPrompt(status, busyBlocker, true);
+    if (options.newChat && !options.project && !options.projectNew) {
+        // Never navigate away from a prior in-flight request, including one whose
+        // caller timed out and released the process lock. Project homes supply
+        // their own fresh composer and must not pass through the root first.
+        const freshUrl = options.temporary ? "https://chatgpt.com/?temporary-chat=true" : "https://chatgpt.com/";
+        await navigateIdleChatGptPage(page, freshUrl);
+        if (!await waitForFreshChatGptPage(page, 8_000)) {
+            throw new ChatGptBrowserBlockerError({
+                code: "fresh_chat_not_ready",
+                message: "The new-chat page did not become an empty conversation. Nothing was sent.",
+                retryable: true,
+                next_step: "Wait for the dedicated browser to finish loading a new chat, then retry."
+            });
+        }
+        status = await readSettledChatGptPageStatus(page);
+        const freshBlocker = detectChatGptPageBlocker(status);
+        if (freshBlocker)
+            throw new ChatGptBrowserBlockerError(freshBlocker);
+        assertChatGptIdleAndReadyForPrompt(status);
+    }
     // Only a PINNED target has to be under the tab already; a resolved thread is
     // navigated to below, and asserting the match here would refuse the send for
     // the tab merely being somewhere else - which is the whole reason a
@@ -3388,7 +3426,6 @@ export async function sendChatGptPrompt(options) {
     let beforeSubmit;
     let boundProjectId;
     let submitButtonFound = false;
-    let wantsDeepResearch = false;
     const sendWarnings = [];
     // 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 -
@@ -3465,6 +3502,22 @@ export async function sendChatGptPrompt(options) {
         // so assistant-message counts compare within the thread we actually send
         // into; a --project/--project-new hop lands on a page with its own counts.
         beforeSubmit = await evaluateOnPage(page, answerExpression());
+        const beforeTyping = await readSettledChatGptPageStatus(page);
+        const beforeTypingBlocker = detectChatGptPageBlocker(beforeTyping);
+        if (beforeTypingBlocker)
+            throw new ChatGptBrowserBlockerError(beforeTypingBlocker);
+        assertChatGptIdleAndReadyForPrompt(beforeTyping);
+        if (normalizedTargetUrl)
+            assertChatGptTargetUrlMatches(beforeSubmit.url, normalizedTargetUrl);
+        if ((options.newChat || options.project || options.projectNew) &&
+            (beforeSubmit.userMessageCount !== 0 || beforeSubmit.assistantMessageCount !== 0 || conversationIdFromThreadUrl(beforeSubmit.url))) {
+            throw new ChatGptBrowserBlockerError({
+                code: "fresh_chat_not_ready",
+                message: "The fresh-chat destination changed to an existing conversation before typing. Nothing was sent.",
+                retryable: true,
+                next_step: "Wait for other browser activity to finish before starting a new consult."
+            });
+        }
         dbgSend(`baseline url=${beforeSubmit.url} user=${beforeSubmit.userMessageCount} assistant=${beforeSubmit.assistantMessageCount}`);
         // Read the binding once more, on the composer this send is about to type
         // into. Everything between selectProject and here - the model picker, the
@@ -3488,11 +3541,9 @@ export async function sendChatGptPrompt(options) {
             const uploaded = await attachFilesToComposer(cdp, options.attachments);
             emitProgress("selecting", `attached ${uploaded.attached.join(", ")}`);
         }
-        const toolLabels = (options.tools ?? []).map(resolveComposerToolLabel);
-        wantsDeepResearch = toolLabels.includes(DEEP_RESEARCH_TOOL_LABEL);
         if (toolLabels.length > 0)
             emitProgress("selecting", `tools=${toolLabels.join(", ")}`);
-        await insertComposerTextViaCdp(cdp, options.prompt, page, toolLabels);
+        await insertComposerTextViaCdp(cdp, sentPrompt, page, toolLabels);
         // The send button renders asynchronously after the prompt lands. Poll for it
         // BEFORE submitting so (a) submitButtonFound reflects whether the control
         // actually EXISTS - otherwise a successful Enter-key submit skips the fallback
@@ -3517,7 +3568,10 @@ export async function sendChatGptPrompt(options) {
         // inserts a newline) fall back to clicking the send button, re-reading
         // FRESH coordinates each attempt. Safe against double-submit: once the
         // prompt posts the composer clears and no send button is found.
-        const promptPostedExpression = `document.querySelectorAll('[data-message-author-role="user"]').length > ${beforeSubmit.userMessageCount}`;
+        const promptPostedExpression = `(() => {
+      const last = [...document.querySelectorAll('[data-message-author-role="user"]')].at(-1);
+      return Boolean(last && (last.innerText || "").includes(${JSON.stringify(`[prodex-request:${requestId}]`)}));
+    })()`;
         await cdp.send("Input.dispatchKeyEvent", enterKeyEvent("keyDown"));
         await cdp.send("Input.dispatchKeyEvent", enterKeyEvent("keyUp"));
         let promptPosted = await waitForExpressionTrue(cdp, promptPostedExpression, 1_500);
@@ -3533,26 +3587,6 @@ export async function sendChatGptPrompt(options) {
             }
         }
         dbgSend(`submit posted=${promptPosted} submitButtonFound=${submitButtonFound}`);
-        // Deep research does not begin when the prompt posts: it shows a start
-        // control with a countdown ring. Press it instead of trusting the timer -
-        // a run left waiting sat with zero assistant messages for 30+ minutes.
-        if (wantsDeepResearch) {
-            const startDeadline = Date.now() + 60_000;
-            let pressed = false;
-            while (Date.now() < startDeadline) {
-                const start = await cdp.evaluate(deepResearchStartButtonRectExpression());
-                if (start.ok && start.x !== undefined && start.y !== undefined) {
-                    await dispatchMouseClickAt(cdp, start.x, start.y);
-                    pressed = true;
-                    emitProgress("selecting", "deep research started");
-                    break;
-                }
-                await sleep(1_000);
-            }
-            if (!pressed) {
-                sendWarnings.push("deep_research_start_not_found: no start control appeared for the deep research run. If ChatGPT asked a clarifying question instead, answer it with a follow-up consult in the same thread.");
-            }
-        }
     }
     catch (error) {
         // Capture before the connection closes: this is the moment the page still
@@ -3569,27 +3603,8 @@ export async function sendChatGptPrompt(options) {
     const acceptDeadline = computePromptAcceptanceDeadline(timeoutMs, started);
     let accepted = false;
     let finalState;
-    // Seeded either from the url once ChatGPT rewrites it, or - when the page
-    // never showed the prompt post - from the transcript that proves it did.
-    let transcriptConversationId;
-    // Ask the transcript early rather than only at the deadline. Acceptance runs
-    // on the full send budget, so a page that stops reporting the prompt posting
-    // used to burn all twenty minutes before saying anything - while the prompt
-    // sat in a conversation the whole time.
-    let nextTranscriptProbeAt = started + ACCEPTANCE_TRANSCRIPT_PROBE_AFTER_MS;
     while (Date.now() < acceptDeadline) {
         await sleep(500);
-        if (Date.now() >= nextTranscriptProbeAt) {
-            nextTranscriptProbeAt = Date.now() + ACCEPTANCE_TRANSCRIPT_PROBE_EVERY_MS;
-            const landed = await findLandedConversation(page, options.prompt);
-            if (landed) {
-                transcriptConversationId = landed;
-                accepted = true;
-                sendWarnings.push("prompt_acceptance_unreadable: the page never showed the prompt posting, but the transcript has it - continuing on the conversation the transcript names.");
-                dbgSend(`acceptance recovered from transcript conversation=${landed}`);
-                break;
-            }
-        }
         try {
             finalState = await evaluateOnPage(page, answerExpression());
         }
@@ -3602,10 +3617,14 @@ export async function sendChatGptPrompt(options) {
         if (runtimeBlocker)
             throw new ChatGptBrowserBlockerError(runtimeBlocker);
         dbgSend(`accept-poll url=${finalState.url} user=${finalState.userMessageCount} assistant=${finalState.assistantMessageCount} generating=${finalState.generating}`);
-        if (hasChatGptPromptAcceptance(beforeSubmit, finalState)) {
+        if (requestMatches(finalState)) {
+            if (normalizedTargetUrl)
+                assertChatGptTargetUrlMatches(finalState.url, normalizedTargetUrl);
             accepted = true;
             break;
         }
+        if (hasChatGptPromptAcceptance(beforeSubmit, finalState))
+            throw requestMismatch(normalizedTargetUrl);
         emitProgress("waiting", "prompt posting");
     }
     if (!accepted) {
@@ -3639,145 +3658,50 @@ export async function sendChatGptPrompt(options) {
         catch {
             // best effort: fall back to submit-button signal only
         }
-        // Before calling this a failed send: did the prompt actually land? Reading
-        // acceptance off the page means a changed DOM reports "never posted" for a
-        // prompt that posted fine, and the caller's retry asks ChatGPT the same
-        // question twice. The transcript is the ground truth.
-        const landed = await findLandedConversation(page, options.prompt);
-        if (landed) {
-            transcriptConversationId = landed;
-            accepted = true;
-            sendWarnings.push("prompt_acceptance_unreadable: the page never showed the prompt posting, but the transcript has it - continuing on the conversation the transcript names.");
-            dbgSend(`acceptance recovered from transcript conversation=${landed}`);
-        }
-        if (!accepted)
-            throw acceptanceTimeoutError({ timeoutMs, composerStillHasText, submitButtonFound });
+        throw acceptanceTimeoutError({ timeoutMs, composerStillHasText, submitButtonFound });
     }
     // Pin the conversation the prompt actually landed in. The browser is shared
     // (other agents, the user, tooling), and a tab that moves mid-wait made
     // prodex read a DIFFERENT conversation and save it as this consult's answer -
     // silently, with a receipt (caught live). Nothing about that is recoverable
     // after the fact, so the wait either stays on this thread or fails loudly.
-    const pinnedThreadUrl = finalState?.url;
-    // Pin the CONVERSATION, not the tab. The transcript reader fetches by id, so
-    // it keeps working when the tab wanders off the thread - which is exactly how
-    // a finished answer was lost: the tab returned to the project page, the url
-    // still matched the pin taken before ChatGPT rewrote it, and the DOM reader
-    // sat on zero assistant messages until the budget ran out.
-    // Acceptance may already have adopted one from the transcript; otherwise take
-    // it from the url ChatGPT rewrote to.
-    transcriptConversationId ??= pinnedThreadUrl ? conversationIdFromThreadUrl(pinnedThreadUrl) : undefined;
-    const transcriptResult = (transcript) => {
-        emitProgress("answered", `transcript (${transcript.answer.length} chars)`);
-        return {
-            url: finalState?.url ?? pinnedThreadUrl ?? "",
-            title: finalState?.title ?? "",
-            answer: transcript.answer,
-            modelHints: finalState?.modelHints ?? [],
-            ...(transcript.modelSlug ? { modelSlug: transcript.modelSlug } : finalState?.modelSlug ? { modelSlug: finalState.modelSlug } : {}),
-            ...(boundProjectId ? { boundProjectId } : {}),
-            warnings: withDialogNote([...sendWarnings, selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...((transcript.modelSlug || finalState?.modelSlug) ? { modelSlug: (transcript.modelSlug || finalState?.modelSlug) } : {}) })]).filter((warning) => Boolean(warning))
-        };
-    };
-    // Deep research never reaches the DOM answer wait below: the report is
-    // rendered by a widget app in an iframe, so the main frame stays empty even
-    // when the run has finished. Read the run out of the conversation transcript
-    // instead, which is where the widget keeps its state.
-    if (wantsDeepResearch) {
-        const conversationId = pinnedThreadUrl ? conversationIdFromThreadUrl(pinnedThreadUrl) : undefined;
-        if (!conversationId)
-            throw new ChatGptBrowserBlockerError(deepResearchUnreadableBlocker(pinnedThreadUrl ?? "https://chatgpt.com/"));
-        let lastState;
-        let consecutiveResearchReadFailures = 0;
-        while (Date.now() - started < timeoutMs) {
-            try {
-                lastState = await evaluateOnPage(page, deepResearchReportExpression(conversationId), { timeoutMs: 60_000 });
-                consecutiveResearchReadFailures = 0;
-            }
-            catch {
-                // A few failures in a row mean the browser is gone, not busy. Waiting
-                // out a 30-minute budget on a dead browser helps nobody: the research
-                // finishes on ChatGPT's side anyway, so hand back the thread and let
-                // recover collect the report.
-                consecutiveResearchReadFailures += 1;
-                if (consecutiveResearchReadFailures >= CONSECUTIVE_READ_FAILURES_BEFORE_GIVING_UP) {
-                    throw new ChatGptBrowserBlockerError(browserLostMidWaitBlocker(pinnedThreadUrl));
-                }
-                await sleep(5_000);
-                continue;
-            }
-            if (lastState.ok && lastState.report.trim().length > 0 && transcriptMatchesSentPrompt(lastState.userText, options.prompt)) {
-                const report = resolveTranscriptCitations(lastState.report, lastState.references).trim();
-                emitProgress("answered", `deep research report (${report.length} chars)`);
-                return {
-                    url: pinnedThreadUrl ?? "",
-                    title: finalState?.title ?? "",
-                    answer: report,
-                    modelHints: finalState?.modelHints ?? [],
-                    ...(finalState?.modelSlug ? { modelSlug: finalState.modelSlug } : {}),
-                    warnings: withDialogNote(sendWarnings)
-                };
-            }
-            emitProgress("waiting", `deep research ${lastState.status || lastState.reason} (${formatDurationMs(Date.now() - started)})`);
-            // Each poll pulls the whole transcript, which a research run grows into
-            // the hundreds of KB - so poll on a calm cadence, not a tight one.
-            await sleep(15_000);
-        }
-        throw new ChatGptBrowserBlockerError({
-            code: "deep_research_still_running",
-            message: `The deep research run was still ${lastState?.status || "in progress"} after ${formatDurationMs(timeoutMs)}.`,
-            retryable: true,
-            next_step: `Fetch the report once it finishes with \`prodex pro browser recover --target-url ${pinnedThreadUrl}\`, or read it in your browser: ${pinnedThreadUrl}`,
-            ...(pinnedThreadUrl ? { thread: pinnedThreadUrl } : {})
-        });
-    }
-    let recoveredNavigations = 0;
-    let lastTranscriptClassification;
+    let pinnedConversationId = conversationIdFromThreadUrl(normalizedTargetUrl ?? finalState?.url ?? "");
+    let pinnedThreadUrl = pinnedConversationId
+        ? canonicalChatGptThreadUrl(pinnedConversationId, normalizedTargetUrl ?? finalState?.url)
+        : undefined;
     let consecutiveReadFailures = 0;
+    let answerSettled = false;
     const answerIsStable = createChatGptAnswerStabilityTracker();
     while (Date.now() - started < timeoutMs) {
         await sleep(1000);
         try {
-            finalState = await evaluateOnPage(page, answerExpression());
+            const observedState = await evaluateOnPage(page, answerExpression());
             consecutiveReadFailures = 0;
-            // First conversation id wins. Re-deriving it every poll would let a tab
-            // that wandered to another thread redirect the read to a stranger's
-            // conversation - and the prompt check below is the second line of defence,
-            // not the first.
-            if (!transcriptConversationId && finalState?.url)
-                transcriptConversationId = conversationIdFromThreadUrl(finalState.url);
-            // The transcript is the same data the page renders, minus the rendering:
-            // markdown instead of flattened innerText, an explicit finish state
-            // instead of caret heuristics, and the model that actually answered.
-            if (transcriptConversationId && !finalState.generating) {
-                const transcript = await readTranscriptAnswer(page, transcriptConversationId, options.prompt);
-                lastTranscriptClassification = transcript.classification;
-                if (transcript.answer)
-                    return transcriptResult(transcript.answer);
-                // A finished turn with no text is an answer of a different shape - an
-                // image, measured - and waiting for words it will never write spends
-                // the whole budget and then calls the result a timeout. The page must
-                // agree it has stopped generating before this counts.
-                if (transcript.classification === "no_text") {
-                    return transcriptResult({ answer: CHATGPT_NON_TEXT_ANSWER_NOTE, modelSlug: "" });
+            // Freeze the first conversation identity the accepted page exposes. A
+            // later tab move must never rewrite result metadata to another thread.
+            if (!pinnedConversationId) {
+                if (!requestMatches(observedState))
+                    throw requestMismatch();
+                const observedConversationId = conversationIdFromThreadUrl(observedState.url);
+                if (observedConversationId) {
+                    pinnedConversationId = observedConversationId;
+                    pinnedThreadUrl = canonicalChatGptThreadUrl(observedConversationId, observedState.url);
                 }
             }
-            if (shouldRecoverThreadNavigation({ pinnedThreadUrl, currentUrl: finalState?.url, lastTranscriptClassification })) {
-                if (recoveredNavigations >= 2) {
-                    throw new ChatGptBrowserBlockerError({
-                        code: "thread_navigated_away",
-                        message: "The browser tab was moved to a different ChatGPT conversation while this consult was waiting for its answer.",
-                        retryable: true,
-                        next_step: `Keep the dedicated browser on the consult thread, then fetch the answer with \`prodex pro browser recover --target-url ${pinnedThreadUrl}\`.`,
-                        thread: pinnedThreadUrl
-                    });
-                }
-                recoveredNavigations += 1;
-                sendWarnings.push(`thread_navigated_away_recovered: something moved the tab to another conversation mid-wait; prodex navigated back to ${pinnedThreadUrl}.`);
-                await evaluateOnPage(page, `location.assign(${JSON.stringify(pinnedThreadUrl)})`);
-                await sleep(3_000);
-                continue;
+            if (shouldRecoverThreadNavigation({ pinnedThreadUrl, currentUrl: observedState.url })) {
+                throw new ChatGptBrowserBlockerError({
+                    code: "thread_navigated_away",
+                    message: "The browser tab was moved to a different ChatGPT conversation while this consult was waiting for its answer.",
+                    retryable: false,
+                    next_step: `Do not resend automatically. After other sessions finish, inspect the original request [prodex-request:${requestId}] in ${pinnedThreadUrl}.`,
+                    thread: pinnedThreadUrl
+                });
             }
+            if (!requestMatches(observedState))
+                throw requestMismatch(pinnedThreadUrl);
+            // Only a state from the pinned conversation may become eligible for
+            // completed or partial result salvage after the polling deadline.
+            finalState = observedState;
         }
         catch (error) {
             if (error instanceof ChatGptBrowserBlockerError)
@@ -3789,7 +3713,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(finalState?.url ?? pinnedThreadUrl));
+                throw new ChatGptBrowserBlockerError(browserLostMidWaitBlocker(pinnedThreadUrl ?? finalState?.url));
             }
             continue;
         }
@@ -3804,34 +3728,22 @@ export async function sendChatGptPrompt(options) {
         // character that can outlive the stop button. The tracker requires extra
         // confirmations for caret-suspect tails (see its doc comment).
         if (answerIsStable(finalState.answer, finalState.generating)) {
-            // The rendered answer settles a beat before the server transcript does.
-            // Give the transcript that beat: it carries markdown (tables and fenced
-            // code that innerText flattens) and the model that actually answered.
-            if (transcriptConversationId) {
-                const transcript = await readTranscriptAnswer(page, transcriptConversationId, options.prompt);
-                lastTranscriptClassification = transcript.classification;
-                if (transcript.answer)
-                    return transcriptResult(transcript.answer);
-                // The transcript can read this conversation and says it is not done:
-                // believe it over a page that merely looks settled. A tool's progress
-                // panel renders exactly like a two-line answer, and that is how a
-                // consult once returned "Searching the web / Answer now" as its result.
-                if (transcript.classification === "pending")
-                    continue;
-            }
+            answerSettled = true;
             break;
         }
     }
     const completed = finalState;
-    if (completed && hasFreshChatGptAnswer(beforeSubmit.assistantMessageCount, completed)) {
+    if (answerSettled && completed && hasFreshChatGptAnswer(beforeSubmit.assistantMessageCount, completed)) {
         emitProgress("answered");
         return {
-            url: completed.url,
+            url: pinnedThreadUrl ?? completed.url,
             title: completed.title,
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
             ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
             ...(boundProjectId ? { boundProjectId } : {}),
+            requestId,
+            requestVerified: true,
             warnings: withDialogNote([...sendWarnings, selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...(completed.modelSlug !== undefined ? { modelSlug: completed.modelSlug } : {}) })]).filter((warning) => Boolean(warning))
         };
     }
@@ -3841,16 +3753,18 @@ export async function sendChatGptPrompt(options) {
     if (completed && hasPartialChatGptAnswer(beforeSubmit.assistantMessageCount, completed)) {
         emitProgress("answered", "partial");
         return {
-            url: completed.url,
+            url: pinnedThreadUrl ?? completed.url,
             title: completed.title,
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
             ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
             ...(boundProjectId ? { boundProjectId } : {}),
+            requestId,
+            requestVerified: true,
             warnings: withDialogNote([
                 ...sendWarnings,
                 ...(selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...(completed.modelSlug !== undefined ? { modelSlug: completed.modelSlug } : {}) }) ? [selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...(completed.modelSlug !== undefined ? { modelSlug: completed.modelSlug } : {}) })] : []),
-                `answer_incomplete: ChatGPT was still generating after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms), so the answer below may be truncated. Raise --timeout-ms and retry for the full response.`
+                `answer_incomplete: ChatGPT's answer did not reach a stable completed state after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms), so the answer below may be truncated. Do not resend the question. Recover the original answer with --target-url ${pinnedThreadUrl ?? completed.url} --request-id ${requestId} once it finishes.`
             ])
         };
     }
@@ -3858,7 +3772,7 @@ export async function sendChatGptPrompt(options) {
     // after prodex gives up, and `pro browser recover --target-url` exists to
     // fetch it - but only if the caller knows which thread to point at.
     throw Object.assign(new Error(`Timed out after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms) waiting for ChatGPT to respond. ` +
-        "Pro reasoning can run many minutes. Raise --timeout-ms and retry."), completed?.url ? { thread: completed.url } : {});
+        "Pro reasoning can run many minutes. Do not resend the question; recover the original answer once it finishes."), { requestId }, pinnedThreadUrl ?? completed?.url ? { thread: pinnedThreadUrl ?? completed?.url } : {});
 }
 /**
  * One line of `pro browser models`.
@@ -4008,12 +3922,18 @@ export function findLaunchedBrowserProcesses(psOutput, input) {
     // very tool running this scan can carry it on its command line, and this list
     // is what gets SIGTERM. Caught live - the probe matched its own node process.
     const isBrowserCommand = (line) => {
-        const command = line.replace(/^\s*\S+\s+\d+\s+/, "");
-        // Only the executable counts, never the arguments: a process that merely
-        // quotes a Chrome path is not Chrome. Everything up to the first flag is
-        // the program, which keeps the spaces macOS puts in "Google Chrome".
-        const executable = command.split(/\s-{1,2}\w/)[0];
-        return /(^|[/\\])(google[ -]?chrome|chromium|chrome)( helper)?( \([^)]*\))?$/i.test(executable.trim());
+        const command = line.replace(/^\s*\S+\s+\d+\s+/, "").trim();
+        // Linux/PATH executables cannot contain spaces, so only the first token is
+        // eligible. This keeps a node/shell argument that names a browser from
+        // becoming a process prodex may terminate.
+        const firstToken = command.split(/\s+/, 1)[0];
+        if (/(^|[/\\])(google[ -]?chrome(?:\.exe)?|chromium(?:-browser)?|chrome(?:\.exe)?|microsoft[ -]edge|msedge\.exe|brave[ -]browser)$/i.test(firstToken)) {
+            return true;
+        }
+        // macOS app executables and helpers have spaces in their absolute path.
+        // Match only anchored, known bundle layouts and require the next token to
+        // be a flag (or end-of-line), never arbitrary argument text.
+        return /^\/Applications\/(?:Google Chrome\.app\/Contents\/MacOS\/Google Chrome|Chromium\.app\/Contents\/MacOS\/Chromium|Microsoft Edge\.app\/Contents\/MacOS\/Microsoft Edge|Brave Browser\.app\/Contents\/MacOS\/Brave Browser|(?:Google Chrome|Chromium|Microsoft Edge|Brave Browser)\.app\/Contents\/Frameworks\/.*?\/Helpers\/(?:Google Chrome|Chromium|Microsoft Edge|Brave Browser) Helper(?: \([^)]*\))?)(?=\s--|$)/i.test(command);
     };
     const lines = psOutput.split(/\r?\n/).filter((line) => !/\bgrep\b/.test(line) && isBrowserCommand(line));
     // Exactly this port: a plain substring test let port 9 match 9333.
@@ -4134,49 +4054,9 @@ export function wedgedBrowserBlocker(pids, port) {
         next_step: "Clear it with `prodex pro browser reset --confirm` (it previews first), then run `prodex pro browser login`."
     };
 }
-export function deleteConversationExpression(conversationId) {
-    return `(async () => {
-  let token = "";
-  try {
-    const session = await fetch("/api/auth/session", { credentials: "include" });
-    if (!session.ok) return { ok: false, reason: "session_http_" + session.status };
-    const parsed = await session.json();
-    token = (parsed && parsed.accessToken) || "";
-  } catch (error) {
-    return { ok: false, reason: "session_error" };
-  }
-  try {
-    const response = await fetch("/backend-api/conversation/" + ${JSON.stringify(conversationId)}, {
-      method: "PATCH",
-      credentials: "include",
-      headers: token ? { Authorization: "Bearer " + token, "Content-Type": "application/json" } : { "Content-Type": "application/json" },
-      body: JSON.stringify({ is_visible: false })
-    });
-    const body = await response.text();
-    if (!response.ok) return { ok: false, reason: "delete_http_" + response.status + " " + body.slice(0, 120) };
-    return { ok: true, reason: "" };
-  } catch (error) {
-    return { ok: false, reason: "delete_error" };
-  }
-})()`;
-}
-/** Remove one conversation. Callers must have confirmed intent before calling. */
-export async function deleteChatGptConversation(input) {
-    const port = resolveCdpPort(input.port);
-    const page = await findChatGptPage(port, input.timeoutMs ?? 3_000);
-    if (!page.ok || !page.page) {
-        throw new ChatGptBrowserBlockerError(page.blocker ?? {
-            code: "browser_unreachable",
-            message: `No Chrome DevTools endpoint is reachable on 127.0.0.1:${port}.`,
-            retryable: true,
-            next_step: "Run `prodex pro browser login` to reopen the dedicated window, then retry."
-        });
-    }
-    const result = await evaluateOnPage(page.page, deleteConversationExpression(input.conversationId), {
-        timeoutMs: 30_000
-    });
-    if (!result?.ok)
-        throw new Error(`ChatGPT refused to delete the conversation: ${result?.reason ?? "unknown reason"}`);
+/** Conversation deletion has no bounded visible-DOM implementation. */
+export async function deleteChatGptConversation(_input) {
+    throw unsupportedChatGptOperationError("Conversation deletion", "Delete the conversation from its menu in the visible ChatGPT UI.");
 }
 export function resolveProjectToDelete(projects, request) {
     if (request.id) {
@@ -4199,78 +4079,33 @@ export function resolveProjectToDelete(projects, request) {
     }
     return { ok: true, id: matches[0].id, name: matches[0].name };
 }
-/** Delete one project by id. The caller is responsible for confirming intent. */
-export function deleteProjectExpression(projectId) {
-    return `(async () => {
-  let token = "";
-  try {
-    const session = await fetch("/api/auth/session", { credentials: "include" });
-    if (!session.ok) return { ok: false, reason: "session_http_" + session.status };
-    const parsed = await session.json();
-    token = (parsed && parsed.accessToken) || "";
-  } catch (error) {
-    return { ok: false, reason: "session_error" };
-  }
-  try {
-    const response = await fetch("/backend-api/gizmos/" + ${JSON.stringify(projectId)}, {
-      method: "DELETE",
-      credentials: "include",
-      headers: token ? { Authorization: "Bearer " + token, "Content-Type": "application/json" } : { "Content-Type": "application/json" }
-    });
-    const body = await response.text();
-    if (!response.ok) return { ok: false, reason: "delete_http_" + response.status + " " + body.slice(0, 120) };
-    return { ok: true, reason: "" };
-  } catch (error) {
-    return { ok: false, reason: "delete_error" };
-  }
-})()`;
-}
 export async function listChatGptProjectsWithIds(input = {}) {
-    const port = resolveCdpPort(input.port);
-    const page = await findChatGptPage(port, input.timeoutMs ?? 3_000);
-    if (!page.ok || !page.page)
-        return [];
-    const { projectsWithIdsExpression } = await import("./tui.js");
-    try {
-        return (await evaluateOnPage(page.page, projectsWithIdsExpression(), { timeoutMs: 30_000 })) ?? [];
-    }
-    catch {
-        return [];
-    }
+    return listVisibleChatGptNavigation(input, projectsWithIdsExpression());
 }
-/** Delete one project. Callers must have confirmed intent before calling. */
-export async function deleteChatGptProject(input) {
-    const port = resolveCdpPort(input.port);
-    const page = await findChatGptPage(port, input.timeoutMs ?? 3_000);
-    if (!page.ok || !page.page) {
-        throw new ChatGptBrowserBlockerError(page.blocker ?? {
-            code: "browser_unreachable",
-            message: `No Chrome DevTools endpoint is reachable on 127.0.0.1:${port}.`,
-            retryable: true,
-            next_step: "Run `prodex pro browser login` to reopen the dedicated window, then retry."
-        });
-    }
-    const result = await evaluateOnPage(page.page, deleteProjectExpression(input.projectId), {
-        timeoutMs: 30_000
-    });
-    if (!result?.ok)
-        throw new Error(`ChatGPT refused to delete the project: ${result?.reason ?? "unknown reason"}`);
+/** Project deletion has no bounded visible-DOM implementation. */
+export async function deleteChatGptProject(_input) {
+    throw unsupportedChatGptOperationError("Project deletion", "Delete the project from its menu in the visible ChatGPT UI.");
 }
 export async function listRecentChatGptConversations(input = {}) {
+    return listVisibleChatGptNavigation(input, recentConversationTitlesExpression(input.limit));
+}
+async function listVisibleChatGptNavigation(input, expression) {
     const port = resolveCdpPort(input.port);
-    const page = await findChatGptPage(port, input.timeoutMs ?? 3_000);
-    if (!page.ok || !page.page)
-        return [];
-    const { recentConversationTitlesExpression } = await import("./tui.js");
-    try {
-        return ((await evaluateOnPage(page.page, recentConversationTitlesExpression(input.limit ?? 10), {
-            timeoutMs: 30_000
-        })) ?? []);
-    }
-    catch {
-        // Nothing to continue from is a normal answer here, not a failure.
-        return [];
+    const timeoutMs = input.timeoutMs ?? 15_000;
+    const pageResult = await findChatGptPage(port, computePageDiscoveryTimeout(timeoutMs), undefined);
+    if (!pageResult.ok)
+        throwBlockerOrError(pageResult.blocker, "ChatGPT browser page is not available");
+    if (!pageResult.page) {
+        if (pageResult.blocker)
+            throw new ChatGptBrowserBlockerError(pageResult.blocker);
+        assertChatGptPageAvailable();
     }
+    const page = pageResult.page;
+    const status = await evaluateOnPage(page, statusExpression(), { timeoutMs });
+    const blocker = chatGptVisibilityBlocker(status.visibilityState, status.url) ?? detectChatGptPageBlocker(status);
+    if (blocker)
+        throw new ChatGptBrowserBlockerError(blocker);
+    return evaluateOnPage(page, expression, { timeoutMs });
 }
 export async function listChatGptSidebarProjects(input = {}) {
     const port = resolveCdpPort(input.port);
@@ -5327,10 +5162,11 @@ export function browserLostMidWaitBlocker(threadUrl) {
     return {
         code: "browser_unreachable",
         message: `The dedicated ChatGPT browser stopped responding while this consult was waiting for its answer.${where}`,
-        retryable: true,
+        // 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 retry.",
+            : "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.",
         ...(threadUrl ? { thread: threadUrl } : {})
     };
 }
@@ -5343,70 +5179,6 @@ export function deepResearchUnreadableBlocker(threadUrl) {
         thread: threadUrl
     };
 }
-/**
- * The most recently updated conversations, each with the prompt it opens with.
- *
- * Acceptance is otherwise read off the page: if the DOM changes shape, a prompt
- * that DID post looks like one that never left, the send fails, and the
- * caller's retry asks ChatGPT the same question twice. The transcript settles
- * it - the conversation either holds our prompt or it does not.
- *
- * Only the head of each prompt is returned: a research transcript runs to
- * hundreds of KB and none of that is needed to recognise it.
- */
-export function recentConversationsExpression(limit = 4) {
-    return `(async () => {
-  const out = [];
-  let token = "";
-  try {
-    const session = await fetch("/api/auth/session", { credentials: "include" });
-    if (!session.ok) return out;
-    const parsed = await session.json();
-    token = (parsed && parsed.accessToken) || "";
-  } catch (error) {
-    return out;
-  }
-  const headers = token ? { Authorization: "Bearer " + token } : {};
-  let items = [];
-  try {
-    const response = await fetch("/backend-api/conversations?offset=0&limit=${limit}&order=updated", {
-      credentials: "include",
-      headers
-    });
-    if (!response.ok) return out;
-    const listed = await response.json();
-    items = (listed && listed.items) || [];
-  } catch (error) {
-    return out;
-  }
-  for (const item of items) {
-    if (!item || !item.id) continue;
-    try {
-      const response = await fetch("/backend-api/conversation/" + item.id, { credentials: "include", headers });
-      if (!response.ok) continue;
-      const conversation = await response.json();
-      const mapping = (conversation && conversation.mapping) || {};
-      const chain = [];
-      let nodeId = conversation && conversation.current_node;
-      let guard = 0;
-      while (nodeId && mapping[nodeId] && guard < 2000) {
-        guard += 1;
-        if (mapping[nodeId].message) chain.push(mapping[nodeId].message);
-        nodeId = mapping[nodeId].parent;
-      }
-      const user = chain.find((entry) => entry && entry.author && entry.author.role === "user" && entry.content);
-      const text = user ? (user.content.parts || []).filter((part) => typeof part === "string").join("") : "";
-      // Long enough that two consults sharing an opening can still be told
-      // apart by the rest of the prompt; bounded so a huge --file send does
-      // not drag its whole payload back through the bridge.
-      out.push({ id: item.id, userText: text.slice(0, 4000) });
-    } catch (error) {
-      // A conversation we cannot read is simply not a match.
-    }
-  }
-  return out;
-})()`;
-}
 /**
  * Which of those conversations is the one this send posted into, if any.
  *
@@ -5449,62 +5221,19 @@ export function transcriptContainsWholeSentPrompt(userText, sentPrompt) {
         return false;
     return seen.includes(sent);
 }
-export function transcriptAnswerExpression(conversationId) {
-    return `(async () => {
-  const fail = (reason, extra) => Object.assign({ ok: false, reason, status: "", endTurn: false, isComplete: false, text: "", modelSlug: "", references: [], userText: "" }, extra || {});
-  let token = "";
-  try {
-    const session = await fetch("/api/auth/session", { credentials: "include" });
-    if (!session.ok) return fail("session_http_" + session.status);
-    const parsed = await session.json();
-    token = (parsed && parsed.accessToken) || "";
-  } catch (error) {
-    return fail("session_error");
-  }
-  let conversation;
-  try {
-    const response = await fetch("/backend-api/conversation/" + ${JSON.stringify(conversationId)}, {
-      credentials: "include",
-      headers: token ? { Authorization: "Bearer " + token } : {}
-    });
-    if (!response.ok) return fail("conversation_http_" + response.status);
-    conversation = await response.json();
-  } catch (error) {
-    return fail("conversation_error");
-  }
-  const mapping = (conversation && conversation.mapping) || {};
-  const chain = [];
-  let nodeId = conversation && conversation.current_node;
-  let guard = 0;
-  while (nodeId && mapping[nodeId] && guard < 2000) {
-    guard += 1;
-    if (mapping[nodeId].message) chain.push(mapping[nodeId].message);
-    nodeId = mapping[nodeId].parent;
-  }
-  const message = chain.find(
-    (entry) => entry && entry.author && entry.author.role === "assistant" && entry.content && entry.content.content_type === "text"
-  );
-  const userMessage = chain.find((entry) => entry && entry.author && entry.author.role === "user" && entry.content);
-  const userText = userMessage ? (userMessage.content.parts || []).filter((part) => typeof part === "string").join("") : "";
-  if (!message) return fail("no_assistant_message", { userText });
-  const parts = (message.content.parts || []).filter((part) => typeof part === "string");
-  const text = parts.join("");
-  const metadata = message.metadata || {};
-  const state = {
-    status: message.status || "",
-    endTurn: message.end_turn === true,
-    isComplete: metadata.is_complete === true,
-    text,
-    modelSlug: metadata.model_slug || "",
-    references: Array.isArray(metadata.content_references) ? metadata.content_references : [],
-    userText
-  };
-  if (state.status !== "finished_successfully" || !state.endTurn) return fail("answer_not_finished", state);
-  if (!text) return fail("answer_empty", state);
-  return Object.assign({ ok: true, reason: "" }, state);
-})()`;
-}
 const NORMALIZED_PROMPT_MATCH_CHARS = 120;
+function normalizeChatGptPromptText(value) {
+    return value.replace(/\\([\\`*_{}[\]()#+\-.!>~|])/g, "$1").replace(/\s+/g, " ").trim();
+}
+function chatGptRequestMarkerMatches(userText, requestId) {
+    const markers = [...normalizeChatGptPromptText(userText).matchAll(/\[prodex-request:([a-f0-9]{32})\]/g)];
+    return markers.at(-1)?.[1] === requestId && markers.filter((match) => match[1] === requestId).length === 1;
+}
+/** Full prompt and per-send identity; wrappers may contain tool/file labels. */
+export function chatGptRequestMatchesUserTurn(userText, sentPrompt, requestId) {
+    return chatGptRequestMarkerMatches(userText, requestId) &&
+        normalizeChatGptPromptText(userText).includes(normalizeChatGptPromptText(sentPrompt));
+}
 /**
  * Does this transcript belong to the consult that is waiting on it?
  *
@@ -5520,12 +5249,8 @@ export function transcriptMatchesSentPrompt(userText, sentPrompt) {
     // kept as "\\## File", fences as escaped backticks), so undo that before
     // comparing - otherwise every prompt carrying markdown, which is every
     // --file send, looks like a different conversation.
-    const normalize = (value) => value
-        .replace(/\\([\\`*_{}[\]()#+\-.!>~|])/g, "$1")
-        .replace(/\s+/g, " ")
-        .trim();
-    const seen = normalize(userText);
-    const sent = normalize(sentPrompt);
+    const seen = normalizeChatGptPromptText(userText);
+    const sent = normalizeChatGptPromptText(sentPrompt);
     if (seen.length === 0 || sent.length === 0)
         return false;
     const expected = sent.slice(0, NORMALIZED_PROMPT_MATCH_CHARS);
@@ -5597,60 +5322,6 @@ export function resolveTranscriptCitations(text, references = []) {
     // reach a receipt, but the words between them still belong to the answer.
     return resolved.replace(CITATION_MARKER_PATTERN, (marker) => citationMarkerText(marker));
 }
-export function deepResearchReportExpression(conversationId) {
-    return `(async () => {
-  const fail = (reason, status, userText) => ({ ok: false, reason, status: status || "", report: "", chars: 0, references: [], userText: userText || "" });
-  let token = "";
-  try {
-    const session = await fetch("/api/auth/session", { credentials: "include" });
-    if (!session.ok) return fail("session_http_" + session.status);
-    const parsed = await session.json();
-    token = (parsed && parsed.accessToken) || "";
-  } catch (error) {
-    return fail("session_error");
-  }
-  let conversation;
-  try {
-    const response = await fetch("/backend-api/conversation/" + ${JSON.stringify(conversationId)}, {
-      credentials: "include",
-      headers: token ? { Authorization: "Bearer " + token } : {}
-    });
-    if (!response.ok) return fail("conversation_http_" + response.status);
-    conversation = await response.json();
-  } catch (error) {
-    return fail("conversation_error");
-  }
-  const mapping = (conversation && conversation.mapping) || {};
-  const nodes = Object.keys(mapping).map((key) => mapping[key]);
-  const widgetNode = nodes.find(
-    (node) => node && node.message && node.message.metadata && node.message.metadata.chatgpt_sdk && node.message.metadata.chatgpt_sdk.widget_state
-  );
-  if (!widgetNode) return fail("no_widget_state");
-  let state;
-  try {
-    state = JSON.parse(widgetNode.message.metadata.chatgpt_sdk.widget_state);
-  } catch (error) {
-    return fail("widget_state_unparsable");
-  }
-  const status = (state && state.status) || "";
-  const chain = [];
-  let walkId = conversation && conversation.current_node;
-  let walkGuard = 0;
-  while (walkId && mapping[walkId] && walkGuard < 2000) {
-    walkGuard += 1;
-    if (mapping[walkId].message) chain.push(mapping[walkId].message);
-    walkId = mapping[walkId].parent;
-  }
-  const userNode = chain.find((entry) => entry && entry.author && entry.author.role === "user" && entry.content);
-  const userText = userNode ? (userNode.content.parts || []).filter((part) => typeof part === "string").join("") : "";
-  const message = (state && state.report_message) || null;
-  const parts = message && message.content && message.content.parts;
-  const report = Array.isArray(parts) ? parts.filter((part) => typeof part === "string").join("") : "";
-  const references = message && message.metadata && Array.isArray(message.metadata.content_references) ? message.metadata.content_references : [];
-  if (!report) return fail("report_not_ready", status, userText);
-  return { ok: true, reason: "", status, report, chars: report.length, references, userText };
-})()`;
-}
 /**
  * Thread urls come in a plain (`/c/<id>`) and a project (`/g/g-p-.../c/<id>`)
  * shape; both end in the conversation id the backend API is keyed by.
@@ -5721,6 +5392,13 @@ export function conversationIdFromThreadUrl(url) {
     const match = /\/c\/([0-9a-fA-F-]{16,})/.exec(url);
     return match ? match[1] : undefined;
 }
+/** Freeze a conversation id into stable result metadata, independent of later tab navigation. */
+export function canonicalChatGptThreadUrl(conversationId, observedUrl) {
+    if (observedUrl && conversationIdFromThreadUrl(observedUrl)?.toLowerCase() === conversationId.toLowerCase()) {
+        return normalizeChatGptTargetUrl(observedUrl);
+    }
+    return `https://chatgpt.com/c/${conversationId}`;
+}
 export function deepResearchStartButtonRectExpression() {
     return `(() => {${CLICK_POINT_SNIPPET}
     const buttons = [...document.querySelectorAll('button,[role="button"]')];
@@ -5851,7 +5529,10 @@ export function answerExpression() {
     // answer (a 0.21.3 fallback for deep research, which is read from the
     // transcript now) turned a tool's progress panel into a 28-character
     // "answer" that a consult returned as its result.
-    const assistant = assistantMessages.at(-1);
+    const lastUserIndex = messages.map((message) => message.role).lastIndexOf("user");
+    // Pair only within the latest user turn; a previous reply is not the
+    // answer to a new question whose assistant node has not rendered yet.
+    const assistant = lastUserIndex < 0 ? undefined : messages.slice(lastUserIndex + 1).filter((message) => message.role === "assistant").at(-1);
     const buttons = [...document.querySelectorAll('button,[role="button"]')]
       .filter((node) => !!(node.offsetWidth || node.offsetHeight || node.getClientRects().length))
       .filter((node) => !node.closest(excludedTextSelector))
@@ -5876,6 +5557,7 @@ export function answerExpression() {
       awaitingResponseChoice: Boolean(document.querySelector(${responseChoiceSelector})),
       assistantMessageCount: assistantMessages.length,
       userMessageCount: userMessages.length,
+      lastUserText: userMessages.at(-1)?.text || "",
       // ChatGPT tags each assistant message with the model that produced it -
       // the only ground truth for "did the Pro selection actually take".
       modelSlug: assistant ? assistant.modelSlug : undefined,