@youdie006/prodex 0.21.1 → 0.21.3

package/README.md

@@ -35,7 +35,7 @@ prodex ask --file src/auth.ts "Review this for security holes"
 
 `prodex ask` is the short form of `prodex pro browser ask`; the full form and every flag work identically. In an interactive terminal, `login` keeps watching the opened window and tells you exactly which manual step is still missing (log in, clear a check, open a chat) until it reports READY. If you skip `login` and the browser is not running, an interactive `ask` recovers on its own: it launches the dedicated browser, waits for your saved session to be READY, and retries the send once (disable with `--no-auto-login`; scripts opt in with `--auto-login`). While ChatGPT thinks, `prodex` prints progress to stderr (connecting, prompt sent, elapsed seconds while generating), so a multi-minute Pro answer never looks frozen.
 
-The answer prints to your terminal and is saved under `.bridge/` for later (`prodex pro latest` re-prints it). Add `--new-chat` to send into a fresh chat (recommended for repeated consults - long threads eventually confuse send detection). For a structured second-opinion debate between your coding agent and GPT Pro, `prodex pro debate-prompt --topic "..."` prints a ready-to-paste orchestration prompt. `prodex` drives the picker you can see and will not send into a tab it cannot read, so leave the dedicated window on a ChatGPT tab; it sends quietly in the background without stealing focus. Prefer no window at all? See [virtual display](#no-window-at-all-virtual-display-recommended). Pin per-repo defaults once - `prodex setup --model Pro --project "your-project"` - so every ask runs Pro (20-minute timeout) inside that project instead of whatever the ChatGPT UI last had selected; list exact sidebar project names with `prodex pro browser projects`. Pass `--file` more than once to inline several files. `--file` puts a text file's CONTENTS into the prompt; `--attach` uploads the file itself, which is the only way to hand ChatGPT a pdf, pptx, xlsx or image and let it parse the original (`prodex ask --attach deck.pptx "Review slides 40-60"`). Both are restricted to paths inside the repo, so an agent cannot upload `~/.ssh` by asking nicely. The upload happens before the prompt is submitted and prodex waits for ChatGPT to finish accepting the file - the browser process reads the path, so the file has to live on the machine running the browser. `--tool` turns on a ChatGPT composer tool for that send: `--tool deep-research` (a browsed report - the timeout rises to 30 minutes automatically, and ChatGPT often replies with a clarifying question first, which you answer with a normal follow-up in the same thread), `--tool web-search` (current facts with sources), `--tool create-image`. Any other label the menu shows works too, so a tool ChatGPT adds later needs no prodex release. When the thread is still generating a previous answer (common right after a timed-out Pro send), the send automatically queues behind it up to the timeout budget; tune that with `--busy-wait-ms` (0 fails fast with a `response_in_progress` blocker). See [First Pro Login](#first-pro-login) for the full flow, and the [FAQ](#faq) if a send stops.
+The answer prints to your terminal and is saved under `.bridge/` for later (`prodex pro latest` re-prints it). Add `--new-chat` to send into a fresh chat (recommended for repeated consults - long threads eventually confuse send detection). For a structured second-opinion debate between your coding agent and GPT Pro, `prodex pro debate-prompt --topic "..."` prints a ready-to-paste orchestration prompt. `prodex` drives the picker you can see and will not send into a tab it cannot read, so leave the dedicated window on a ChatGPT tab; it sends quietly in the background without stealing focus. Prefer no window at all? See [virtual display](#no-window-at-all-virtual-display-recommended). Pin per-repo defaults once - `prodex setup --model Pro --project "your-project"` - so every ask runs Pro (20-minute timeout) inside that project instead of whatever the ChatGPT UI last had selected; list exact sidebar project names with `prodex pro browser projects`. Pass `--file` more than once to inline several files. `--file` puts a text file's CONTENTS into the prompt; `--attach` uploads the file itself, which is the only way to hand ChatGPT a pdf, pptx, xlsx or image and let it parse the original (`prodex ask --attach deck.pptx "Review slides 40-60"`). Both are restricted to paths inside the repo, so an agent cannot upload `~/.ssh` by asking nicely. The upload happens before the prompt is submitted and prodex waits for ChatGPT to finish accepting the file - the browser process reads the path, so the file has to live on the machine running the browser. `--tool` turns on a ChatGPT composer tool for that send: `--tool deep-research` (starts a browsed research run and hands you back the thread URL - prodex does NOT return the report, because a finished deep research report does not render in prodex's browser session even after a hard reload; read it in your own browser), `--tool web-search` (current facts with sources), `--tool create-image`. Any other label the menu shows works too, so a tool ChatGPT adds later needs no prodex release. When the thread is still generating a previous answer (common right after a timed-out Pro send), the send automatically queues behind it up to the timeout budget; tune that with `--busy-wait-ms` (0 fails fast with a `response_in_progress` blocker). See [First Pro Login](#first-pro-login) for the full flow, and the [FAQ](#faq) if a send stops.
 
 ## Core Shape
 

package/dist/chatgpt-browser.js

@@ -1932,6 +1932,11 @@ export async function sendChatGptPrompt(options) {
                 }
                 await sleep(1_000);
             }
+            // Do not wait for a report this browser will never render.
+            const threadNow = await cdp.evaluate("location.href");
+            if (typeof threadNow === "string" && threadNow.length > 0) {
+                throw new ChatGptBrowserBlockerError(deepResearchUnreadableBlocker(threadNow));
+            }
             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.");
             }
@@ -1998,13 +2003,38 @@ export async function sendChatGptPrompt(options) {
         }
         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;
+    let recoveredNavigations = 0;
     const answerIsStable = createChatGptAnswerStabilityTracker();
     while (Date.now() - started < timeoutMs) {
         await sleep(1000);
         try {
             finalState = await evaluateOnPage(page, answerExpression());
+            if (pinnedThreadUrl && finalState?.url && !chatGptUrlsReferToSameTarget(finalState.url, pinnedThreadUrl)) {
+                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;
+            }
         }
-        catch {
+        catch (error) {
+            if (error instanceof ChatGptBrowserBlockerError)
+                throw error;
             // Transient CDP failure while the answer is streaming: retry. A throw here
             // would discard an already-streamed partial answer and skip the salvage
             // path below, so keep the last good state and poll again until timeout.
@@ -2852,6 +2882,24 @@ export function chunkComposerText(text, size = COMPOSER_INSERT_CHUNK_CHARS) {
  * on that: a run left waiting produced zero assistant messages for 30+ minutes
  * (measured live), because nothing pressed it.
  */
+/**
+ * Deep research reports are not readable from prodex's browser session.
+ * Measured against a run the user finished themselves: the SAME thread, same
+ * account, hard-reloaded here, renders only the prompt turn and an empty
+ * result turn (roles ["user"], 72 characters of page) while their own browser
+ * shows the completed report. Rather than spend a 30-minute budget waiting for
+ * text that never arrives, prodex hands back the thread and says where to read
+ * it.
+ */
+export function deepResearchUnreadableBlocker(threadUrl) {
+    return {
+        code: "deep_research_not_readable",
+        message: "The deep research run was started, but prodex cannot read deep research reports from its browser session - they do not render there.",
+        retryable: false,
+        next_step: `Open the run in your own browser and read it there: ${threadUrl}`,
+        thread: threadUrl
+    };
+}
 export function deepResearchStartButtonRectExpression() {
     return `(() => {${CLICK_POINT_SNIPPET}
     const buttons = [...document.querySelectorAll('button,[role="button"]')];
@@ -2977,7 +3025,17 @@ export function answerExpression() {
     });
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     const userMessages = messages.filter((message) => message.role === "user");
-    const assistant = assistantMessages.at(-1);
+    // Deep research renders no assistant-role node at all: the thread is
+    // conversation-turn sections, the prompt in the first and the report in a
+    // later one (measured live - roles were ["user"] only while a research ran).
+    // Fall back to the last turn that is NOT the user's, so such an answer is
+    // readable instead of looking like "no answer" forever.
+    const turnAnswers = assistantMessages.length > 0 ? [] : [...document.querySelectorAll('[data-testid^="conversation-turn"]')]
+      .filter((turn) => !turn.querySelector('[data-message-author-role="user"]'))
+      .map((turn) => ({ role: "assistant", text: (turn.innerText || "").trim(), modelSlug: undefined }))
+      .filter((turn) => turn.text.length > 0);
+    const effectiveAssistants = assistantMessages.length > 0 ? assistantMessages : turnAnswers;
+    const assistant = effectiveAssistants.at(-1);
     const buttons = [...document.querySelectorAll('button,[role="button"]')]
       .filter((node) => !!(node.offsetWidth || node.offsetHeight || node.getClientRects().length))
       .filter((node) => !node.closest(excludedTextSelector))
@@ -2996,7 +3054,7 @@ export function answerExpression() {
       blockerScanTextSample: visibleTextOutsideMessages(blockerScanExcludedSelector).slice(0, 12000),
       visibleButtonLabels: buttons,
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || buttons.some((label) => generatingControlPattern.test(label)),
-      assistantMessageCount: assistantMessages.length,
+      assistantMessageCount: effectiveAssistants.length,
       userMessageCount: userMessages.length,
       // ChatGPT tags each assistant message with the model that produced it -
       // the only ground truth for "did the Pro selection actually take".

package/dist/cli-pro.js

@@ -948,6 +948,10 @@ export async function runAskProCommand(rest, io) {
                 const name = selectionMetadata.project;
                 return name ? text.split(name).join("<project>") : text;
             };
+            // Where the prompt actually landed beats where the caller aimed: with
+            // --new-chat there is no target url, and a blocker that started a run
+            // still has a thread worth handing back.
+            const blockedThread = blocker.thread ?? normalizedTargetUrl;
             const persistedBlocker = {
                 ...blocker,
                 message: redactProject(blocker.message),
@@ -965,7 +969,7 @@ export async function runAskProCommand(rest, io) {
                     direction: "codex_to_chatgpt",
                     backend: "chatgpt-control",
                     task_id: task.id,
-                    thread: normalizedTargetUrl,
+                    thread: blockedThread,
                     status: "blocked",
                     blocker: persistedBlocker,
                     warnings: []
@@ -977,7 +981,7 @@ 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: normalizedTargetUrl ?? null, answer: null, warnings: [], blocker }, null, 2));
+                io.stdout(JSON.stringify({ task_id: task.id, status: "blocked", thread: blockedThread ?? null, answer: null, warnings: [], blocker }, null, 2));
             }
             throw new Error(formatBlockedConsultRecordedMessage(message, task.id, sourceCli, { cwd: targetCwd }));
         }
@@ -1313,7 +1317,10 @@ export function browserSendBlockerFromError(error) {
             code: blocker.code,
             message: blocker.message,
             retryable: blocker.retryable,
-            ...("next_step" in blocker && typeof blocker.next_step === "string" ? { next_step: blocker.next_step } : {})
+            ...("next_step" in blocker && typeof blocker.next_step === "string" ? { next_step: blocker.next_step } : {}),
+            // A blocker that knows which thread the prompt landed in is the only
+            // place that URL exists - keep it so callers get a link, not prose.
+            ...("thread" in blocker && typeof blocker.thread === "string" ? { thread: blocker.thread } : {})
         };
     }
     const message = errorMessage(error);

package/package.json

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