@youdie006/prodex 0.40.8 → 0.40.9

package/README.md

@@ -71,13 +71,14 @@ prodex pro latest                 # re-print the last answer
 
 While Pro thinks, progress goes to stderr: connecting, prompt sent, elapsed time while generating. A Pro selection raises the send budget to twenty minutes on its own; `--timeout-ms` overrides it. Answers are read from the rendered page, so formatting can differ from the original message. If the dedicated browser is not running, an interactive `ask` starts it, waits for your saved session, and retries once (`--no-auto-login` turns that off; scripts opt in with `--auto-login`).
 
-If the browser stops responding after your question was sent, prodex stops without sending it again. Reopen it with `prodex pro browser login`, then use `prodex pro browser recover --target-url <thread-url>` with the conversation URL in the error (MCP: `pro_recover`). If no URL was captured, inspect the original chat before asking again.
+If the browser stops responding after your question was sent, prodex stops without sending it again. Use the `thread` and `request_id` from the error with `prodex pro browser recover --target-url <thread-url> --request-id <32hex>` (MCP: `pro_recover`). The request ID verifies that the recovered assistant answer follows that exact marked user turn. Legacy recovery without it remains available but returns `request_verified: false` and a warning.
 
 Useful flags on every send:
 
 | Flag | What it does |
 |---|---|
-| `--new-chat` | Send into a fresh chat. Recommended for repeated consults; very long threads eventually confuse send detection. |
+| `--new-chat` | Explicitly request the default: ordinary consults start in a fresh chat. The shared current tab is never an implicit destination. |
+| `--session-key id` | Identify one caller for scoped `--continue`. Falls back to `PRODEX_SESSION_KEY`, then `CODEX_THREAD_ID`. |
 | `--file path` | Inline a text file's contents into the prompt. Repeatable. |
 | `--attach path` | Upload the file itself: the only way to hand ChatGPT a pdf, pptx, xlsx or image. Paths must live inside the repo. |
 | `--tool web-search` | Select a rendered composer tool. Automatic deep-research report retrieval is currently unsupported and is blocked before sending. |
@@ -104,7 +105,9 @@ prints a token-free config that points Claude at `prodex mcp --cwd /absolute/pat
 { "mcpServers": { "prodex": { "command": "prodex", "args": ["mcp", "--cwd", "/absolute/path/to/your/repo"] } } }
 ```
 
-The server exposes `pro_consult` (a visible-browser send, with the same model, effort, project and tool choices as the CLI), `pro_recover` (fetch an answer that finished after a timeout), the bridge ledger tools (`bridge_create_task`, `bridge_list_tasks`, `bridge_fetch_result`, receipts, sessions), bounded `repo_read_file` and `repo_search`, and a receipt-gated write path: `repo_write_file_dry_run` first, `repo_write_file_apply` only while git HEAD and the file's preimage hash still match, `repo_stage_reviewed_paths` for applied receipts only. No shell tool, no ungated write. `prodex claude prompt` prints a paste-ready prompt that verifies the wiring. [docs/claude.md](docs/claude.md) covers Claude Desktop and Claude Code; [docs/clients.md](docs/clients.md) covers the others, including the per-call approval and `tool_timeout_sec` Codex needs.
+The server exposes `pro_consult` (a visible-browser send, with the same model, effort, project and tool choices as the CLI), `pro_recover` (fetch an answer that finished after a timeout), the bridge ledger tools (`bridge_create_task`, `bridge_list_tasks`, `bridge_fetch_result`, receipts, sessions), bounded `repo_read_file` and `repo_search`, and a receipt-gated write path: `repo_write_file_dry_run` first, `repo_write_file_apply` only while git HEAD and the file's preimage hash still match, `repo_stage_reviewed_paths` for applied receipts only. Each stdio MCP connection receives one default session key, ordinary consults start fresh, and `continue_thread` only searches that key and project. Logical agents sharing one MCP connection should pass distinct explicit `session_key` values and preserve them for follow-ups; an explicit key also preserves continuity across an MCP restart. No shell tool, no ungated write. `prodex claude prompt` prints a paste-ready prompt that verifies the wiring. [docs/claude.md](docs/claude.md) covers Claude Desktop and Claude Code; [docs/clients.md](docs/clients.md) covers the others, including the per-call approval and `tool_timeout_sec` Codex needs.
+
+Updating the installed npm package does not reload an MCP process that is already running. Reconnect the MCP server or restart the Codex/Claude client to load the new build. The dedicated browser profile is separate and remains signed in, so this does not require ChatGPT authentication again.
 
 An MCP server usually starts without `--cwd`, so a per-repo default can be missed. For defaults that apply from any directory, set `PRODEX_DEFAULT_PROJECT`, `PRODEX_DEFAULT_MODEL`, `PRODEX_DEFAULT_EFFORT` or `PRODEX_DEFAULT_PRO_MODE` in the agent's MCP `env` block; a per-repo config still wins field by field.
 
@@ -240,9 +243,9 @@ Reports are deduplicated by blocker code, so something that stays broken adds to
 
 **Why the pause before sending?** Pacing: `send_pacing: waiting Ns` on stderr. `PRODEX_MIN_SEND_INTERVAL_MS=0` disables it.
 
-**The answer timed out.** Pro can take many minutes; incomplete send results are marked rather than presented as finished. If the thread finished after the timeout, `prodex pro browser recover --target-url <thread>` reads its rendered answer without sending again. Deep-research widget reports are not supported by this recovery path.
+**The answer timed out.** Pro can take many minutes. Do not resend automatically. Recover the original marked turn with `prodex pro browser recover --target-url <thread> --request-id <request_id>` after it finishes.
 
-**Sends started failing after many consults in one chat.** Long threads confuse prompt-acceptance detection. Use `--new-chat` (`new_chat: true` on the MCP tool).
+**A consult returned an unrelated answer.** Current sends append a unique visible request marker and accept only the assistant turn following that marker. Ordinary calls also start fresh. A `request_mismatch` blocker is not retryable; inspect the named request instead of treating the returned page's last answer as the consult.
 
 **Every send says "still generating" and nothing is being written.** ChatGPT parked the thread on "which response do you prefer?". prodex reports `response_choice_pending` and names the buttons; pick one, or send with `--new-chat`.
 

package/dist/chatgpt-browser.js

@@ -714,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;
@@ -2558,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
@@ -3037,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);
@@ -3049,6 +3081,14 @@ 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;
@@ -3060,7 +3100,8 @@ export async function recoverChatGptAnswerFromThread(options) {
         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)})`);
+        if (!alreadyOnTarget)
+            await navigateIdleChatGptPage(page.page, url);
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             await sleep(500);
@@ -3084,6 +3125,15 @@ export async function recoverChatGptAnswerFromThread(options) {
                 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.
@@ -3139,7 +3189,9 @@ export async function recoverChatGptAnswerFromThread(options) {
         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."]
     };
 }
 export async function sendChatGptPrompt(options) {
@@ -3149,6 +3201,16 @@ export async function sendChatGptPrompt(options) {
     }
     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();
@@ -3184,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);
@@ -3245,6 +3286,8 @@ export async function sendChatGptPrompt(options) {
             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.
@@ -3334,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
@@ -3439,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
@@ -3464,7 +3543,7 @@ export async function sendChatGptPrompt(options) {
         }
         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
@@ -3489,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);
@@ -3535,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) {
@@ -3583,7 +3669,6 @@ export async function sendChatGptPrompt(options) {
     let pinnedThreadUrl = pinnedConversationId
         ? canonicalChatGptThreadUrl(pinnedConversationId, normalizedTargetUrl ?? finalState?.url)
         : undefined;
-    let recoveredNavigations = 0;
     let consecutiveReadFailures = 0;
     let answerSettled = false;
     const answerIsStable = createChatGptAnswerStabilityTracker();
@@ -3595,6 +3680,8 @@ export async function sendChatGptPrompt(options) {
             // 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;
@@ -3602,21 +3689,16 @@ export async function sendChatGptPrompt(options) {
                 }
             }
             if (shouldRecoverThreadNavigation({ pinnedThreadUrl, currentUrl: observedState.url })) {
-                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;
+                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;
@@ -3660,6 +3742,8 @@ export async function sendChatGptPrompt(options) {
             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))
         };
     }
@@ -3675,10 +3759,12 @@ export async function sendChatGptPrompt(options) {
             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's answer did not reach a stable completed state 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.`
             ])
         };
     }
@@ -3686,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."), pinnedThreadUrl ?? completed?.url ? { thread: pinnedThreadUrl ?? 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`.
@@ -5136,6 +5222,18 @@ export function transcriptContainsWholeSentPrompt(userText, sentPrompt) {
     return seen.includes(sent);
 }
 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?
  *
@@ -5151,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);
@@ -5435,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))
@@ -5460,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,

package/dist/cli-args.js

@@ -271,6 +271,7 @@ export const ASK_PRO_BOOLEAN_FLAGS = new Set([
 export const ASK_PRO_SELECTION_VALUE_FLAGS = ["--project", "--project-new", "--model", "--pro-mode", "--effort"];
 export const ASK_PRO_VALUE_FLAGS = new Set([
     "--cwd",
+    "--session-key",
     // Continue one NAMED past consult, when "the last one" is not the one meant.
     "--continue-task",
     "--file",
@@ -287,6 +288,7 @@ export const ASK_PRO_VALUE_FLAGS = new Set([
 ]);
 export const ASK_PRO_PREVIEW_VALUE_FLAGS = new Set([
     "--cwd",
+    "--session-key",
     "--file",
     "--port",
     "--timeout-ms",

package/dist/cli-help.js

@@ -25,8 +25,8 @@ Ask / consult commands:
   prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of model menu options
   prodex pro browser projects [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of sidebar project names (for --project)
-  prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # recover a finished answer from a thread whose send timed out
-  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"] "prompt"  # explicit visible-browser send
+  prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--request-id 32hex] [--timeout-ms 60000]  # recover a finished answer from a timed-out request
+  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--session-key id] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"] "prompt"  # explicit visible-browser send
   prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro blockers [--cwd /absolute/path/to/repo] [--since 7d] [--limit 10] [--json]  # what actually blocks consults, ranked, across every bridge root on this machine
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
@@ -170,7 +170,7 @@ Commands:
   prodex pro browser check [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js]
-  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"] "prompt"
+  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--session-key id] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"] "prompt"
   prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro blockers [--cwd /absolute/path/to/repo] [--since 7d] [--limit 10] [--json]  # what actually blocks consults, ranked, across every bridge root on this machine
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
@@ -261,8 +261,8 @@ export function printProBrowserHelp(stdout, sourceCli) {
         : "prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]";
     const selectionUsage = '[--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"]';
     const askUsage = sourceCli
-        ? `${cli} pro browser ask${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`
-        : `prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`;
+        ? `${cli} pro browser ask${sourceCliOption} [--cwd /absolute/path/to/repo] [--session-key id] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`
+        : `prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--session-key id] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`;
     const modelsUsage = sourceCli
         ? `${cli} pro browser models${sourceCliOption} [--port 9333] [--timeout-ms 15000]`
         : "prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]";
@@ -282,8 +282,8 @@ export function printProBrowserHelp(stdout, sourceCli) {
         ? `${cli} pro browser reset${sourceCliOption} [--port 9333] [--confirm]  # end a browser that runs but stopped answering; previews unless --confirm`
         : "prodex pro browser reset [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--confirm]  # end a browser that runs but stopped answering; previews unless --confirm";
     const recoverUsage = sourceCli
-        ? `${cli} pro browser recover${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # read a stable, finished answer rendered in the requested thread`
-        : "prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # read a stable, finished answer rendered in the requested thread";
+        ? `${cli} pro browser recover${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--request-id 32hex] [--timeout-ms 60000]  # read the stable answer for one marked request`
+        : "prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--request-id 32hex] [--timeout-ms 60000]  # read the stable answer for one marked request";
     stdout(`${cli} pro browser
 
 Commands:
@@ -311,9 +311,12 @@ Model/project selection (ask):
   --project    Enter an existing sidebar project before sending. Cannot be combined with --target-url.
 
 Continuing a conversation (ask):
-  --continue        Send into the conversation a previous consult is already in: the newest FINISHED consult of the same project, read from this repo's own .bridge records. The browser tab is shared and a pinned project starts a new chat on every send, so the tab is not what decides this. A --project here scopes the search rather than navigating. Refuses instead of guessing when this project has no finished consult yet.
-  --continue-task   Continue one named past consult by its task_id, when the newest is not the conversation meant. List them with \`${cli} pro list\`.
+  Ordinary sends start a fresh chat by default, including inside a saved project. new_chat:false never opts into the shared current tab.
+  --session-key     Stable caller id for --continue. Falls back to PRODEX_SESSION_KEY, then CODEX_THREAD_ID.
+  --continue        Continue this session key's newest FINISHED consult in the same project. Refuses when no caller key or matching consult exists.
+  --continue-task   Continue one named past consult by its task_id, deliberately crossing session boundaries. List them with \`${cli} pro list\`.
 Cannot be combined with --new-chat, --target-url, --project-new or --temporary.
+Recovery should use the request_id returned by the original send: --request-id verifies the answer follows that exact marked user turn. Omitting it keeps legacy recovery but reports request_verified=false.
 --pro-mode and --effort cannot be combined. Labels are matched in both the Korean and English (US) ChatGPT UI (e.g. 높음/High, Pro 확장/Pro Extended).
 Run \`${cli} pro browser models${sourceCliOption}\` to list the labels your account currently shows.
 Persist defaults with \`${cli} setup${sourceCliOption}\`; per-ask flags override them.

package/dist/cli-pro.js

@@ -13,6 +13,7 @@ import { withBrowserSendLock } from "./browser-send-lock.js";
 import { blockerCause, buildBlockerReport, CATCH_ALL_CODES } from "./blocker-report.js";
 import { projectIdFromSidebar, resolveContinuationThread } from "./continue-thread.js";
 import { readBridgeRoots } from "./registry.js";
+import { ProdexRequestIdSchema, SessionKeySchema } from "./schema.js";
 import { BridgeStore, MAX_FETCHABLE_RESULT_ARTIFACT_BYTES } from "./store.js";
 import { CLI_VERSION } from "./cli-help.js";
 import { PRODEX_ISSUE_REPO, buildIssueReport, fileGitHubIssue } from "./issue-report.js";
@@ -571,9 +572,9 @@ export async function runProCommand(rest, io, runCliFn) {
             return 0;
         }
         if (browserSubcommand === "recover") {
-            if (printProBrowserHelpIfRequested(browserArgs, "pro browser recover", io, { valueFlags: ["--cwd", "--port", "--timeout-ms", "--target-url", "--source-cli"] }))
+            if (printProBrowserHelpIfRequested(browserArgs, "pro browser recover", io, { valueFlags: ["--cwd", "--port", "--timeout-ms", "--target-url", "--request-id", "--source-cli"] }))
                 return 0;
-            assertOnlyOptions(browserArgs, "pro browser recover", ["--cwd", "--port", "--timeout-ms", "--target-url", "--source-cli"]);
+            assertOnlyOptions(browserArgs, "pro browser recover", ["--cwd", "--port", "--timeout-ms", "--target-url", "--request-id", "--source-cli"]);
             const recoverCwd = resolveCwdFlag(io.cwd, browserArgs);
             const recoverSourceCli = resolveOptionalFileFlag(io.cwd, browserArgs, "--source-cli");
             const targetUrl = readFlag(browserArgs, "--target-url");
@@ -582,6 +583,10 @@ export async function runProCommand(rest, io, runCliFn) {
             }
             const recoverPort = readPortFlag(browserArgs, "--port");
             const recoverTimeoutMs = readPositiveIntegerFlag(browserArgs, "--timeout-ms");
+            const recoverRequestIdRaw = readFlag(browserArgs, "--request-id");
+            const recoverRequestId = recoverRequestIdRaw === undefined
+                ? undefined
+                : validatedProdexRequestId(recoverRequestIdRaw, "--request-id");
             const recoverResolvedPort = resolveCdpPort(recoverPort);
             let consult;
             try {
@@ -590,7 +595,12 @@ export async function runProCommand(rest, io, runCliFn) {
                 // send is streaming into, which is the consult it would destroy - and
                 // recovery is exactly what gets run after a send appears to hang, so
                 // the two meeting is a when rather than an if.
-                consult = await withBrowserSendLock(recoverTimeoutMs ?? 60_000, (detail) => io.stderr(`progress: ${detail}`), () => recoverChatGptAnswerFromThread({ port: recoverPort, targetUrl, timeoutMs: recoverTimeoutMs }));
+                consult = await withBrowserSendLock(recoverTimeoutMs ?? 60_000, (detail) => io.stderr(`progress: ${detail}`), () => recoverChatGptAnswerFromThread({
+                    port: recoverPort,
+                    targetUrl,
+                    timeoutMs: recoverTimeoutMs,
+                    ...(recoverRequestId ? { requestId: recoverRequestId } : {})
+                }));
             }
             catch (error) {
                 const blocker = sourceAwareBrowserBlocker(browserSendBlockerFromError(error), recoverSourceCli, {
@@ -616,6 +626,12 @@ export async function runProCommand(rest, io, runCliFn) {
             catch (error) {
                 io.stderr(`answer_artifact_warning: ${errorMessage(error)}`);
             }
+            for (const warning of consult.warnings)
+                io.stderr(warning);
+            if (consult.requestId)
+                io.stderr(`request_id: ${consult.requestId}`);
+            if (consult.requestVerified !== undefined)
+                io.stderr(`request_verified: ${consult.requestVerified ? "yes" : "no"}`);
             await recoverStore.completeTask(recoveredTask.id, {
                 status: "done",
                 summary: consult.answer,
@@ -623,8 +639,8 @@ export async function runProCommand(rest, io, runCliFn) {
                     ? [{ path: recoveredArtifactPath, role: "result", bytes: Buffer.byteLength(recoveredArtifactText, "utf8") }]
                     : [],
                 commands: ["recovered ChatGPT answer from thread"],
-                warnings: [],
-                provenance: { thread: consult.url, warnings: [] }
+                warnings: consult.warnings,
+                provenance: { thread: consult.url, warnings: consult.warnings }
             });
             io.stdout(`${recoveredTask.id}\tdone\t${consult.url}`);
             io.stdout("");
@@ -985,6 +1001,27 @@ function autoLoginDisabledByEnv(env = process.env) {
     const raw = (env.PRODEX_NO_AUTO_LOGIN ?? "").trim().toLowerCase();
     return raw === "1" || raw === "true" || raw === "yes";
 }
+function validatedSessionKey(value, source) {
+    const parsed = SessionKeySchema.safeParse(value);
+    if (parsed.success)
+        return parsed.data;
+    throw new Error(`${source} must be a non-empty identifier of at most 128 characters using letters, digits, '.', '_', ':', '@', '/', or '-'.`);
+}
+export function resolveProdexSessionKey(explicit, env = process.env) {
+    if (explicit !== undefined)
+        return validatedSessionKey(explicit, "--session-key");
+    if (env.PRODEX_SESSION_KEY !== undefined)
+        return validatedSessionKey(env.PRODEX_SESSION_KEY, "PRODEX_SESSION_KEY");
+    if (env.CODEX_THREAD_ID !== undefined)
+        return validatedSessionKey(env.CODEX_THREAD_ID, "CODEX_THREAD_ID");
+    return undefined;
+}
+function validatedProdexRequestId(value, source) {
+    const parsed = ProdexRequestIdSchema.safeParse(value);
+    if (parsed.success)
+        return parsed.data;
+    throw new Error(`${source} must be the 32-character lowercase hex request identifier returned by prodex.`);
+}
 // Retired browser subcommands map to the one that replaced them. Every value
 // here must be a subcommand that actually exists, so the error is a single hop
 // to a runnable command.
@@ -1136,6 +1173,7 @@ export async function runAskProCommand(rest, io) {
         promptText = prompt ? `${prompt}\n\n--- piped input (stdin) ---\n${piped}` : piped;
     }
     const browserDefaults = await loadBrowserDefaults(targetCwd);
+    const sessionKey = resolveProdexSessionKey(readFlag(parsedAskPro.optionArgs, "--session-key"));
     const explicitProject = readFlag(parsedAskPro.optionArgs, "--project");
     const explicitProjectNew = readFlag(parsedAskPro.optionArgs, "--project-new");
     // Opt out of a pinned default project for one send. Without this a repo
@@ -1159,6 +1197,9 @@ export async function runAskProCommand(rest, io) {
     const continueRequested = parsedAskPro.optionArgs.includes("--continue");
     const continueTaskId = readFlag(parsedAskPro.optionArgs, "--continue-task");
     if (continueRequested || continueTaskId !== undefined) {
+        if (continueTaskId === undefined && sessionKey === undefined) {
+            throw new Error("--continue needs --session-key <id> (or PRODEX_SESSION_KEY/CODEX_THREAD_ID) so it cannot use another client's conversation. Use --continue-task <task_id> to name one explicitly.");
+        }
         const conflict = [
             parsedAskPro.optionArgs.includes("--new-chat") ? "--new-chat" : undefined,
             targetUrl !== undefined ? "--target-url" : undefined,
@@ -1188,12 +1229,14 @@ export async function runAskProCommand(rest, io) {
         const resolved = resolveContinuationThread({
             consults: (await targetStore.listSessionsReadOnly()).map((session) => ({
                 taskId: session.task_id ?? "",
+                ...(session.session_key ? { sessionKey: session.session_key } : {}),
                 ...(session.thread ? { thread: session.thread } : {}),
                 status: session.status,
                 ...(session.created_at ? { createdAt: session.created_at } : {})
             })),
             ...(continuationProject ? { project: continuationProject } : {}),
             ...(continuationProjectId ? { projectId: continuationProjectId } : {}),
+            ...(sessionKey ? { sessionKey } : {}),
             ...(continueTaskId !== undefined ? { taskId: continueTaskId } : {})
         });
         if ("error" in resolved)
@@ -1205,7 +1248,8 @@ export async function runAskProCommand(rest, io) {
         normalizedTargetUrl = normalizeChatGptTargetUrl(resolved.target.thread);
         io.stderr(`progress: continuing ${resolved.target.taskId}`);
     }
-    const newChat = parsedAskPro.optionArgs.includes("--new-chat");
+    const explicitlyRequestedNewChat = parsedAskPro.optionArgs.includes("--new-chat");
+    const newChat = explicitlyRequestedNewChat || normalizedTargetUrl === undefined;
     // A temporary chat is not saved, so there is nothing to come back to: the
     // recovery path every timeout message points at cannot fetch it later.
     // Requiring --new-chat keeps that explicit rather than quietly turning a
@@ -1220,7 +1264,7 @@ export async function runAskProCommand(rest, io) {
     if (temporary && !newChat) {
         throw new Error("--temporary starts a throwaway chat, so it needs --new-chat. A temporary chat cannot be continued or recovered later.");
     }
-    if (newChat && normalizedTargetUrl) {
+    if (explicitlyRequestedNewChat && normalizedTargetUrl) {
         throw new Error("ask-pro cannot combine --new-chat with --target-url: --new-chat navigates to a fresh chat while --target-url pins the confirmed tab.");
     }
     const explicitModel = readFlag(parsedAskPro.optionArgs, "--model");
@@ -1335,6 +1379,7 @@ export async function runAskProCommand(rest, io) {
                 id: bundle.id,
                 direction: "codex_to_chatgpt",
                 backend: "chatgpt-control",
+                ...(sessionKey ? { session_key: sessionKey } : {}),
                 task_id: task.id,
                 thread: normalizedTargetUrl,
                 status: "running",
@@ -1464,6 +1509,7 @@ export async function runAskProCommand(rest, io) {
                     id: bundle.id,
                     direction: "codex_to_chatgpt",
                     backend: "chatgpt-control",
+                    ...(sessionKey ? { session_key: sessionKey } : {}),
                     task_id: task.id,
                     thread: blockedThread,
                     status: "blocked",
@@ -1477,7 +1523,15 @@ export async function runAskProCommand(rest, io) {
             // Keep stdout machine-parseable for --json consumers on the blocked
             // path too; the human-readable error still goes to stderr via throw.
             if (jsonOutput) {
-                io.stdout(JSON.stringify({ task_id: task.id, status: "blocked", thread: blockedThread ?? null, answer: null, warnings: blockedWarnings, blocker }, null, 2));
+                io.stdout(JSON.stringify({
+                    task_id: task.id,
+                    status: "blocked",
+                    thread: blockedThread ?? null,
+                    answer: null,
+                    ...(sessionKey ? { session_key: sessionKey } : {}),
+                    warnings: blockedWarnings,
+                    blocker
+                }, null, 2));
             }
             throw new Error(formatBlockedConsultRecordedMessage(message, task.id, sourceCli, { cwd: targetCwd }));
         }
@@ -1514,6 +1568,10 @@ export async function runAskProCommand(rest, io) {
             io.stderr(warning);
         if (consult.modelSlug)
             io.stderr(`model_used: ${consult.modelSlug}`);
+        if (consult.requestId)
+            io.stderr(`request_id: ${consult.requestId}`);
+        if (consult.requestVerified !== undefined)
+            io.stderr(`request_verified: ${consult.requestVerified ? "yes" : "no"}`);
         // Which conversation this followed, and where the answer actually landed.
         // The progress line that says it is filtered out of MCP notes, so an
         // agent asking for a follow-up had no way to know which thread it got -
@@ -1562,6 +1620,8 @@ export async function runAskProCommand(rest, io) {
                     // receipt used to record only what prodex asked for.
                     ...(consult.modelSlug ? { model_used: consult.modelSlug } : {}),
                     ...(proVerified !== undefined ? { pro_verified: proVerified } : {}),
+                    ...(consult.requestId ? { request_id: consult.requestId } : {}),
+                    ...(consult.requestVerified !== undefined ? { request_verified: consult.requestVerified } : {}),
                     // Intent and evidence, kept apart. `selection` is what was asked
                     // for; this is where the answer turned out to be, and whether
                     // anything actually confirmed it.
@@ -1606,6 +1666,7 @@ export async function runAskProCommand(rest, io) {
             id: bundle.id,
             direction: "codex_to_chatgpt",
             backend: "chatgpt-control",
+            ...(sessionKey ? { session_key: sessionKey } : {}),
             task_id: task.id,
             thread: consult.url,
             status: "done",
@@ -1617,6 +1678,9 @@ export async function runAskProCommand(rest, io) {
                 status: result.status,
                 thread: consult.url,
                 answer: result.summary,
+                ...(sessionKey ? { session_key: sessionKey } : {}),
+                ...(consult.requestId ? { request_id: consult.requestId } : {}),
+                ...(consult.requestVerified !== undefined ? { request_verified: consult.requestVerified } : {}),
                 ...(continuedFromTaskId ? { continued_from: continuedFromTaskId } : {}),
                 destination: {
                     observed: destination.destination,
@@ -1640,6 +1704,7 @@ export async function runAskProCommand(rest, io) {
             id: bundle.id,
             direction: "codex_to_chatgpt",
             backend: "manual",
+            ...(sessionKey ? { session_key: sessionKey } : {}),
             status: "preview",
             warnings: []
         }, io);
@@ -1692,6 +1757,14 @@ Rules:
 
 Write the debate in the language of the topic.`;
 }
+function browserMetadataFromNotes(notes) {
+    const requestId = notes.find((line) => line.startsWith("request_id: "))?.slice("request_id: ".length).trim();
+    const verified = notes.find((line) => line.startsWith("request_verified: "))?.slice("request_verified: ".length).trim();
+    return {
+        ...(requestId ? { request_id: requestId } : {}),
+        ...(verified === "yes" ? { request_verified: true } : verified === "no" ? { request_verified: false } : {})
+    };
+}
 /**
  * MCP-side counterpart to `pro browser recover`. A consult that outlives its
  * budget hands back the thread it landed in, but until now the only way to act
@@ -1706,6 +1779,7 @@ export async function performBrowserRecoverForMcp(cwd, input) {
         "recover",
         "--target-url",
         input.thread,
+        ...(input.request_id !== undefined ? ["--request-id", input.request_id] : []),
         ...(input.timeout_ms !== undefined ? ["--timeout-ms", String(input.timeout_ms)] : [])
     ];
     await runProCommand(argv, {
@@ -1715,11 +1789,13 @@ export async function performBrowserRecoverForMcp(cwd, input) {
     }, async () => 0);
     const header = stdoutLines[0] ?? "";
     const [taskId = "", status = "", thread = ""] = header.split("\t");
+    const metadata = browserMetadataFromNotes(stderrLines);
     return {
         task_id: taskId,
         status,
         thread,
         answer: stdoutLines.slice(2).join("\n"),
+        ...metadata,
         notes: stderrLines
     };
 }
@@ -1750,6 +1826,7 @@ export function answerRescuedFromFailedPersistence(stdoutLines) {
 export async function performBrowserConsultForMcp(cwd, input, onProgress) {
     const stdoutLines = [];
     const stderrLines = [];
+    const sessionKey = resolveProdexSessionKey(input.session_key);
     const argv = [
         "--send",
         // MCP callers have no terminal, so the interactive auto-recovery gate
@@ -1762,6 +1839,7 @@ export async function performBrowserConsultForMcp(cwd, input, onProgress) {
         ...(input.pro_mode !== undefined ? ["--pro-mode", input.pro_mode] : []),
         ...(input.effort !== undefined ? ["--effort", input.effort] : []),
         ...(input.project !== undefined ? ["--project", input.project] : []),
+        ...(sessionKey !== undefined ? ["--session-key", sessionKey] : []),
         ...(input.timeout_ms !== undefined ? ["--timeout-ms", String(input.timeout_ms)] : []),
         ...(input.files ?? []).flatMap((file) => ["--file", file]),
         ...(input.attach ?? []).flatMap((file) => ["--attach", file]),
@@ -1794,25 +1872,31 @@ export async function performBrowserConsultForMcp(cwd, input, onProgress) {
         const rescued = answerRescuedFromFailedPersistence(stdoutLines);
         if (!rescued)
             throw error;
+        const notes = [
+            ...stderrLines.filter((line) => !line.startsWith("progress:")),
+            `answer_not_saved: ${errorMessage(error)}`
+        ];
         return {
             task_id: rescued.taskId,
             status: "answered_not_saved",
             thread: rescued.thread,
             answer: rescued.answer,
-            notes: [
-                ...stderrLines.filter((line) => !line.startsWith("progress:")),
-                `answer_not_saved: ${errorMessage(error)}`
-            ]
+            ...(sessionKey ? { session_key: sessionKey } : {}),
+            ...browserMetadataFromNotes(notes),
+            notes
         };
     }
     const header = stdoutLines[0] ?? "";
     const [taskId = "", status = "", thread = ""] = header.split("\t");
+    const notes = stderrLines.filter((line) => !line.startsWith("progress:"));
     return {
         task_id: taskId,
         status,
         thread,
         answer: stdoutLines.slice(2).join("\n"),
-        notes: stderrLines.filter((line) => !line.startsWith("progress:"))
+        ...(sessionKey ? { session_key: sessionKey } : {}),
+        ...browserMetadataFromNotes(notes),
+        notes
     };
 }
 /**
@@ -2222,10 +2306,17 @@ export function browserSendBlockerFromError(error) {
     const thread = typeof error === "object" && error !== null && "thread" in error && typeof error.thread === "string"
         ? (error.thread)
         : undefined;
+    const requestId = typeof error === "object" &&
+        error !== null &&
+        "requestId" in error &&
+        typeof error.requestId === "string" &&
+        ProdexRequestIdSchema.safeParse(error.requestId).success
+        ? error.requestId
+        : undefined;
     const timedOut = message.match(/Timed out after [\s\S]*?(\d+)\s*ms/);
     if (timedOut) {
-        // Suggest a concrete doubled budget so the user can paste a rerun command
-        // instead of guessing what "raise --timeout-ms" means in milliseconds.
+        // Marked sends recover the exact request. Legacy timeout errors retain a
+        // concrete doubled budget so the user need not guess one.
         const usedMs = Number(timedOut[1]);
         const suggestedMs = Number.isFinite(usedMs) && usedMs > 0 ? usedMs * 2 : 600_000;
         return {
@@ -2233,10 +2324,12 @@ export function browserSendBlockerFromError(error) {
             message,
             retryable: true,
             ...(thread ? { thread } : {}),
-            next_step: `Rerun with a bigger budget (${formatDurationMs(suggestedMs)}): \`prodex pro browser ask --timeout-ms ${suggestedMs} "<same prompt>"\`.` +
-                (thread
-                    ? ` ChatGPT often finishes after prodex gives up - fetch that answer instead of re-asking: \`prodex pro browser recover --target-url ${thread}\`.`
-                    : "")
+            next_step: thread && requestId
+                ? `Do not resend automatically. ChatGPT often finishes after prodex gives up; recover that exact request instead: \`prodex pro browser recover --target-url ${thread} --request-id ${requestId}\`.`
+                : `Rerun with a bigger budget (${formatDurationMs(suggestedMs)}): \`prodex pro browser ask --timeout-ms ${suggestedMs} "<same prompt>"\`.` +
+                    (thread
+                        ? ` ChatGPT often finishes after prodex gives up - fetch that answer instead of re-asking: \`prodex pro browser recover --target-url ${thread}\`.`
+                        : "")
         };
     }
     // A CDP command timeout means the page's renderer stalled, which in the

package/dist/continue-thread.js

@@ -125,8 +125,8 @@ export function projectIdFromSidebar(projects, name) {
  *
  * Naming a task wins over the search, because the caller who names one knows
  * which conversation they mean. Otherwise it is the most recent consult that
- * finished, in this project - fail-closed when there is none, since guessing
- * the conversation is the failure this exists to prevent.
+ * finished for this caller, in this project - fail-closed when there is none,
+ * since guessing the conversation is the failure this exists to prevent.
  */
 export function resolveContinuationThread(input) {
     const withThread = input.consults.filter((consult) => consult.thread && isChatGptConversationUrl(consult.thread));
@@ -147,10 +147,17 @@ export function resolveContinuationThread(input) {
         }
         return { target: { taskId: named.taskId, thread: named.thread } };
     }
+    if (!input.sessionKey) {
+        return {
+            error: "--continue needs a caller session key so it cannot select another client's conversation. " +
+                "Pass --session-key <id> (or PRODEX_SESSION_KEY/CODEX_THREAD_ID), or name the intended consult with --continue-task <task_id>."
+        };
+    }
     const knownProjectIds = new Set(input.project ? projectIdsByName(withThread.map((consult) => consult.thread)).get(chatGptProjectSlug(input.project)) ?? [] : []);
     if (input.projectId)
         knownProjectIds.add(input.projectId.toLowerCase());
     const candidates = withThread
+        .filter((consult) => consult.sessionKey === input.sessionKey)
         .filter((consult) => consult.status === "done")
         .filter((consult) => threadMatchesProject(consult.thread, input.project, knownProjectIds))
         .sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));

package/dist/mcp.js

@@ -1,4 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import process from "node:process";
@@ -6,7 +7,7 @@ import { serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
 import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { createMcpToolHandlers, MAX_MCP_BRIDGE_TEXT_BYTES, MAX_MCP_SHORT_TEXT_BYTES, staleServerWarning, withServerVersionNotice } from "./mcp-tools.js";
-import { ReceiptKindSchema } from "./schema.js";
+import { ProdexRequestIdSchema, ReceiptKindSchema, SessionKeySchema } from "./schema.js";
 const McpBridgeTextSchema = z.string().max(MAX_MCP_BRIDGE_TEXT_BYTES);
 const McpShortTextSchema = z.string().max(MAX_MCP_SHORT_TEXT_BYTES);
 const BridgeFileInputSchema = z.object({
@@ -51,6 +52,7 @@ function serverVersionNotice() {
 }
 export function createServer(cwd = process.cwd(), options = {}) {
     const server = new McpServer({ name: "prodex", version: mcpPackageJson.version ?? "0.0.0" });
+    const mcpSessionKey = `mcp-${randomUUID()}`;
     const handlers = createMcpToolHandlers({
         cwd,
         source: options.source,
@@ -167,9 +169,10 @@ export function createServer(cwd = process.cwd(), options = {}) {
     const browserConsult = options.browserConsult;
     if (browserConsult) {
         server.registerTool("pro_consult", {
-            description: "Ask the user's logged-in ChatGPT (Pro) in the visible browser and wait for the full answer. This drives a real browser send: it can take minutes (Pro extended reasoning), is human-paced, and records a durable receipt under .bridge/. Requires a running `prodex pro browser login` session. By default the consult continues in whatever thread the browser tab is showing - EXCEPT when a project applies (passed here, or pinned as a saved default), because entering a project starts a new chat in it. To follow up on a previous consult, pass continue_thread:true: it resolves the thread from prodex's own records - the newest finished consult of the same project - instead of trusting the shared tab, and continue_task with a task_id names one exactly. Pass new_chat:true to start a fresh thread for a genuinely new topic. If the thread is still generating a previous answer, the send automatically queues behind it (up to the timeout budget) - long 'tab busy' progress is normal, not stuck. `project` and `model` come from saved defaults (per-repo config, or PRODEX_DEFAULT_PROJECT / PRODEX_DEFAULT_MODEL env vars) when omitted - do NOT pass them per-call unless deliberately overriding. Returns task_id, thread URL, and the answer text.",
+            description: "Ask the user's logged-in ChatGPT (Pro) in the visible browser and wait for the full answer. This drives a real browser send: it can take minutes (Pro extended reasoning), is human-paced, and records a durable receipt under .bridge/. Requires a running `prodex pro browser login` session. Every ordinary consult starts a fresh chat, including inside a passed or saved default project; new_chat:false never opts into the shared current tab. To follow up, pass continue_thread:true: it resolves only the newest finished consult with this caller's session_key and project. Each MCP connection gets one default session_key. Logical agents sharing one connection must pass distinct explicit keys and preserve them for follow-ups; an explicit key also preserves identity across MCP restarts. continue_task deliberately names one task across session boundaries. If the thread is still generating a previous answer, the send queues behind it up to the timeout budget. `project` and `model` come from saved defaults when omitted. Returns task_id, thread URL, session_key, request correlation evidence, and the answer text.",
             inputSchema: {
                 prompt: McpBridgeTextSchema.min(1),
+                session_key: SessionKeySchema.optional().describe("Stable logical-caller identifier for scoped continue_thread lookup. Omit to share this MCP connection's default key; logical agents sharing one connection should pass distinct keys and preserve them for follow-ups."),
                 model: McpShortTextSchema.optional(),
                 // pro_mode is deliberately NOT advertised: ChatGPT's 2026-07 update
                 // removed Pro sub-modes, and agents that saw the field passed
@@ -192,11 +195,11 @@ export function createServer(cwd = process.cwd(), options = {}) {
                 new_chat: z
                     .boolean()
                     .optional()
-                    .describe("Start a fresh thread for a new topic."),
+                    .describe("Start a fresh thread. Ordinary consults already do this by default; false does not reuse the shared tab."),
                 continue_thread: z
                     .boolean()
                     .optional()
-                    .describe("Follow up inside the conversation a previous consult is already in, resolved from prodex's records: the newest finished consult of the same project. This is the reliable way to keep a follow-up in one conversation - the tab is shared, and a project default starts a new chat on every send. Fails rather than guessing when this project has no finished consult yet."),
+                    .describe("Follow up inside this caller session_key's newest finished consult of the same project. Fails rather than using another MCP/Codex session or the shared browser tab."),
                 continue_task: z
                     .string()
                     .min(1)
@@ -227,15 +230,16 @@ export function createServer(cwd = process.cwd(), options = {}) {
                         // Progress delivery must never break the consult.
                     });
                 };
-            return asText(withServerVersionNotice(await browserConsult(input, onProgress), serverVersionNotice()));
+            return asText(withServerVersionNotice(await browserConsult({ ...input, session_key: input.session_key ?? mcpSessionKey }, onProgress), serverVersionNotice()));
         });
     }
     const browserRecover = options.browserRecover;
     if (browserRecover) {
         server.registerTool("pro_recover", {
-            description: "Read a stable, finished assistant answer rendered in the requested ChatGPT thread after a consult stopped waiting, and record a receipt. It sends no prompt and acquires the shared send lock before navigating. Wrong-thread, generating, missing, or changing answers are refused. Hidden transcripts and deep-research report retrieval are unsupported; inspect those manually in ChatGPT.",
+            description: "Read a stable, finished assistant answer rendered in the requested ChatGPT thread after a consult stopped waiting, and record a receipt. Pass the request_id returned by pro_consult to verify the answer follows that exact marked user turn. Without it, legacy recovery returns request_verified:false and an explicit warning. It sends no prompt and acquires the shared send lock before navigating. Wrong-thread, wrong-request, generating, missing, or changing answers are refused.",
             inputSchema: {
                 thread: McpShortTextSchema.min(1).describe("The ChatGPT conversation URL from the blocker (its `thread` field)."),
+                request_id: ProdexRequestIdSchema.optional().describe("The 32-character request_id returned by the original pro_consult."),
                 timeout_ms: z.number().int().positive().max(600_000).optional()
             }
         }, async (input) => asText(withServerVersionNotice(await browserRecover(input), serverVersionNotice())));

package/dist/schema.js

@@ -1,5 +1,12 @@
 import { z } from "zod";
 export const SCHEMA_VERSION = 1;
+export const SessionKeySchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/, "Session key must be an identifier, not prompt text");
+export const ProdexRequestIdSchema = z.string().regex(/^[a-f0-9]{32}$/);
 export const AdapterSchema = z.enum(["cli", "mcp", "manual", "oracle", "chatgpt-control"]);
 export const TaskStatusSchema = z.enum(["new", "claimed", "done", "blocked"]);
 export const ResultStatusSchema = z.enum(["done", "blocked"]);
@@ -83,6 +90,7 @@ export const SessionSchema = z.object({
     id: z.string().regex(/^sess_\d{8}_\d{6}_[a-z0-9-]+$/),
     direction: z.enum(["codex_to_chatgpt", "chatgpt_to_codex", "claude_to_codex"]),
     backend: AdapterSchema,
+    session_key: SessionKeySchema.optional(),
     project: z.string().optional(),
     thread: z.string().optional(),
     task_id: z.string().optional(),

package/dist/store.js

@@ -442,6 +442,7 @@ export class BridgeStore {
                 id,
                 direction: input.direction,
                 backend: input.backend,
+                session_key: input.session_key,
                 project: input.project,
                 thread: input.thread,
                 task_id: input.task_id,
@@ -458,6 +459,7 @@ export class BridgeStore {
             id: input.id,
             direction: input.direction,
             backend: input.backend,
+            session_key: input.session_key ?? existing?.session_key,
             project: input.project,
             thread: input.thread,
             task_id: input.task_id,
@@ -482,6 +484,7 @@ export class BridgeStore {
             id: existing.id,
             direction: existing.direction,
             backend: existing.backend,
+            session_key: existing.session_key,
             project: existing.project,
             thread: existing.thread,
             task_id: existing.task_id,

package/docs/claude.md

@@ -105,9 +105,11 @@ The server currently exposes ledger-first tools:
 
 Write tools are narrow and receipt-gated, and they require a git worktree with a committed HEAD. Claude must first call `repo_write_file_dry_run` with an existing repo-relative text file, replacement content, and the expected git HEAD. The file is not changed; the receipt stores hashes/diff and points at a replacement-text artifact under `.bridge/artifacts/repo-writes/`. To apply it, Claude must call `repo_write_file_apply` with the dry-run receipt id, the same expected HEAD, and the reported preimage hash. If git HEAD, file content, or artifact content changed, apply fails. To stage the result, Claude must call `repo_stage_reviewed_paths` with applied write receipt ids and the same expected HEAD; staging fails if any file changed after apply.
 
-`pro_consult` lets Claude ask your logged-in ChatGPT (Pro) directly: it drives the same explicit visible-browser consult as `prodex pro browser ask` (human-paced, blocker-gated, receipt-recorded, answer saved under `.bridge/artifacts/pro-consults/`) and can take minutes for Pro extended reasoning. It requires a prior `prodex pro browser login` session and is registered only on the local stdio MCP server — the HTTP MCP surface never exposes it, so nothing reachable through a tunnel or ChatGPT itself can drive your browser.
+`pro_consult` lets Claude ask your logged-in ChatGPT (Pro) directly: it drives the same explicit visible-browser consult as `prodex pro browser ask` (human-paced, blocker-gated, receipt-recorded, answer saved under `.bridge/artifacts/pro-consults/`) and can take minutes for Pro extended reasoning. Ordinary calls start fresh. Each stdio MCP connection gets one default `session_key`, and `continue_thread` only resolves that key's latest finished consult in the same project. Logical agents sharing one connection should pass distinct explicit keys and preserve them for follow-ups. An explicit key also keeps continuity across an MCP process restart. It requires a prior `prodex pro browser login` session and is registered only on the local stdio MCP server; the HTTP MCP surface never exposes it, so nothing reachable through a tunnel or ChatGPT itself can drive your browser.
 
-`pro_recover` reads a finished, rendered answer after a consult stopped waiting. It verifies the requested conversation and refuses still-generating or unstable content. It sends nothing. Deep-research widget reports are not supported; current builds block automated deep-research sends before posting. Like `pro_consult`, recovery is registered only on the local stdio MCP server.
+`pro_recover` reads a finished, rendered answer after a consult stopped waiting. Pass the original `request_id` with its `thread` to verify the answer follows that exact marked user turn. Omitting it supports old records but returns `request_verified: false` and a warning. It sends nothing and refuses wrong-request, wrong-thread, still-generating, or unstable content. Deep-research widget reports remain unsupported, and this tool is also registered only on the local stdio MCP server.
+
+Updating the installed package does not reload an already-running MCP process. Reconnect the MCP server or restart the Codex/Claude agent client to load the new build. The dedicated browser profile remains signed in, so no ChatGPT reauthentication is needed.
 
 Generic bridge result/session/task tools redact ChatGPT thread metadata, including nested blockers; local `pro_consult` recovery information remains available. A legacy result artifact with no saved hash returns `legacy_artifact_unverified` rather than implying its bytes were verified. `sessions cancel` only clears stale bookkeeping after a send was interrupted; it does not stop an active consult.
 

package/docs/cli-reference.md

@@ -131,9 +131,9 @@ prodex results artifact latest
 prodex sessions show latest
 ```
 
-This uses the currently available ChatGPT web session and model selection. It is not a hidden API client, and it does not read cookies, tokens, localStorage, or sessionStorage.
+This uses the currently available ChatGPT web session and model selection. Each ordinary ask starts a fresh chat, including inside a configured project. Use `--session-key <id> --continue` for a follow-up scoped to one caller, or `--continue-task <task_id>` to deliberately name a consult across sessions. `PRODEX_SESSION_KEY` and then `CODEX_THREAD_ID` are the CLI fallbacks. It is not a hidden API client, and it does not read cookies, tokens, localStorage, or sessionStorage.
 
-Current builds read rendered page content only. Project/conversation listings are limited to entries exposed by the UI. Automatic chat/project deletion and deep-research report retrieval are unsupported; those commands stop rather than call internal endpoints. A recovered answer must belong to the requested thread and be stable and finished. Formatting may differ from ChatGPT's rendered message.
+Current builds read rendered page content only. Project/conversation listings are limited to entries exposed by the UI. Automatic chat/project deletion and deep-research report retrieval are unsupported; those commands stop rather than call internal endpoints. Every send carries a visible request marker; success requires the returned assistant turn to follow that marker. Recover a timeout with `--target-url <thread> --request-id <request_id>` so recovery verifies the same turn. Omitting the request ID is legacy, unverified recovery. Formatting may differ from ChatGPT's rendered message.
 
 Locks fail closed if a process is killed while reclaiming an abandoned lock. A leftover `.reap` claim then needs manual cleanup: first stop every prodex process using that resource and confirm no request/write/startup is active; only then remove the affected lock and its matching `.reap` file. Browser locks live beside the recorded send lock, repo-write locks under `.bridge`, and virtual-display allocation locks under `~/.local/share/prodex/xvfb`. Do not remove a live request's lock to shorten a wait.
 

package/docs/clients.md

@@ -20,6 +20,18 @@ Install the `prodex` binary with `npm install -g @youdie006/prodex` (note the sc
 The same operating rules apply to every client: manual-first, explicit `pro browser ...`
 sends only, stop on blockers, no bypass, low volume, local only (see the README).
 
+Each stdio MCP connection gets one default `session_key`. An ordinary `pro_consult`
+starts a fresh chat; `new_chat: false` does not reuse whichever conversation another
+session left in the shared tab. A `continue_thread: true` call searches only the same
+session key and project. Logical agents sharing one connection should use distinct
+explicit keys and preserve them for follow-ups. An explicit key also keeps continuity
+across an MCP process restart; `continue_task` deliberately names a recorded consult.
+
+After updating the installed package, reconnect the MCP server or restart the agent
+client. A running stdio process keeps the old code until it exits. The dedicated
+browser profile is unchanged, so restarting Codex/Claude does not require signing in
+to ChatGPT again.
+
 ## Claude Code
 
 See [claude.md](claude.md), or:
@@ -51,7 +63,9 @@ or a per-server `"timeout"`.
 Keep the client budget longer than the ordinary consult budget. Current
 browser-only builds block `tools: ["deep-research"]` before sending because
 automatic report retrieval depended on an internal API. Run research manually
-in ChatGPT; `pro_recover` only accepts a finished, rendered conversation answer.
+in ChatGPT. Recover a timed-out ordinary answer with both the returned `thread` and
+`request_id`; recovery without a request ID is retained for old records but is marked
+unverified.
 
 Approval gate (verified on Codex 0.142.5): Codex asks for per-call approval
 before invoking prodex MCP tools. In interactive `codex` sessions you simply

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.40.8",
+  "version": "0.40.9",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",