@youdie006/prodex 0.18.0 → 0.19.0

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 deliberately will not send into a window you cannot watch — but a dedicated Chrome window left non-minimized (even behind your editor) counts as watchable, so it sends quietly in the background without stealing focus. Just don't minimize it or switch that window to another tab. Pin per-repo defaults once - `prodex setup --model Pro --project "your-project"` - so every ask runs Pro (15-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 attach several files. 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 attach several files. 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

@@ -477,6 +477,23 @@ async function waitForFreshChatGptPage(page, timeoutMs) {
 export function hasChatGptPromptAcceptance(previous, state) {
     return state.userMessageCount > previous.userMessageCount || state.assistantMessageCount > previous.assistantMessageCount;
 }
+/**
+ * Compare the model that was ASKED for against the model that actually
+ * produced the answer (ChatGPT tags each message with data-message-model-slug).
+ * prodex used to record only the request, so a model click that silently did
+ * not take - or no model pinned at all - was invisible, and the user believed
+ * they were getting Pro reasoning when they were not.
+ */
+export function modelSelectionWarning(requestedModel, modelSlug) {
+    if (!requestedModel || !modelSlug)
+        return undefined;
+    const wantsPro = /\bpro\b/i.test(requestedModel);
+    if (!wantsPro)
+        return undefined;
+    if (/pro/i.test(modelSlug))
+        return undefined;
+    return `model_mismatch: you asked for ${requestedModel}, but the answer came from "${modelSlug}". Check the model picker in the browser; the selection did not take.`;
+}
 export function chatGptBusyBlocker(generating) {
     if (!generating)
         return undefined;
@@ -1570,6 +1587,7 @@ export async function recoverChatGptAnswerFromThread(options) {
         title: state.title,
         answer: state.answer.trim(),
         modelHints: state.modelHints,
+        ...(state.modelSlug ? { modelSlug: state.modelSlug } : {}),
         warnings: []
     };
 }
@@ -1842,7 +1860,8 @@ export async function sendChatGptPrompt(options) {
             title: completed.title,
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
-            warnings: [...sendWarnings]
+            ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
+            warnings: [...sendWarnings, modelSelectionWarning(options.model, completed.modelSlug)].filter((warning) => Boolean(warning))
         };
     }
     // Timed out while the answer was still streaming: salvage the partial text
@@ -1855,14 +1874,19 @@ export async function sendChatGptPrompt(options) {
             title: completed.title,
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
+            ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
             warnings: [
                 ...sendWarnings,
+                ...(modelSelectionWarning(options.model, completed.modelSlug) ? [modelSelectionWarning(options.model, completed.modelSlug)] : []),
                 `answer_incomplete: ChatGPT was still generating after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms), so the answer below may be truncated. Raise --timeout-ms and retry for the full response.`
             ]
         };
     }
-    throw 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.");
+    // Carry the thread the prompt landed in: ChatGPT usually finishes the answer
+    // after prodex gives up, and `pro browser recover --target-url` exists to
+    // fetch it - but only if the caller knows which thread to point at.
+    throw Object.assign(new Error(`Timed out after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms) waiting for ChatGPT to respond. ` +
+        "Pro reasoning can run many minutes. Raise --timeout-ms and retry."), completed?.url ? { thread: completed.url } : {});
 }
 export function modelMenuOptionsExpression() {
     return `(() => {
@@ -2409,10 +2433,17 @@ export function answerExpression() {
       return parts.join(String.fromCharCode(10));
     };
     const lines = text.split(String.fromCharCode(10)).map((line) => line.trim()).filter(Boolean);
-    const messages = [...document.querySelectorAll('[data-message-author-role]')].map((node) => ({
-      role: node.getAttribute('data-message-author-role'),
-      text: node.innerText || ""
-    }));
+    const messages = [...document.querySelectorAll('[data-message-author-role]')].map((node) => {
+      // ChatGPT tags each message with the model that produced it, on the
+      // message node or an ancestor depending on the build. This is the only
+      // ground truth for "did the Pro selection actually take".
+      let modelSlug = node.getAttribute('data-message-model-slug') || undefined;
+      if (!modelSlug && typeof node.closest === "function") {
+        const tagged = node.closest('[data-message-model-slug]');
+        if (tagged) modelSlug = tagged.getAttribute('data-message-model-slug') || undefined;
+      }
+      return { role: node.getAttribute('data-message-author-role'), text: node.innerText || "", modelSlug };
+    });
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     const userMessages = messages.filter((message) => message.role === "user");
     const assistant = assistantMessages.at(-1);
@@ -2436,6 +2467,9 @@ export function answerExpression() {
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || buttons.some((label) => generatingControlPattern.test(label)),
       assistantMessageCount: assistantMessages.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".
+      modelSlug: assistant ? assistant.modelSlug : undefined,
       modelHints: lines.filter((line) => /GPT|Pro|Thinking|ChatGPT|Extra High|Auto/i.test(line)).slice(0, 30)
     };
   })()`;

package/dist/cli-pro.js

@@ -962,7 +962,9 @@ export async function runAskProCommand(rest, io) {
         // after the 2026-07 update reset that to Medium, consults meant for Pro
         // quietly ran on a mid-tier model. Warn loudly and record it.
         if (!selectionModel && !selectionProMode && !selectionEffort) {
-            persistenceWarnings.push("model_selection_warning: no model/effort was selected for this send (no per-ask flag, no saved default), so it used whatever the ChatGPT UI last had selected. Pin one with `prodex setup --model Pro` or pass --model/--effort.");
+            persistenceWarnings.push("model_selection_warning: no model/effort was selected for this send (no per-ask flag, no saved default), so it used whatever the ChatGPT UI last had selected" +
+                (consult.modelSlug ? ` - it answered as "${consult.modelSlug}"` : "") +
+                ". Pin one with `prodex setup --model Pro` or pass --model/--effort.");
         }
         // In-project threads carry the project slug in their URL
         // (/g/g-p-<project>/c/<id>); a bare /c/<id> after requesting a project
@@ -976,6 +978,8 @@ export async function runAskProCommand(rest, io) {
         // would otherwise treat a cut-off answer as complete.
         for (const warning of persistenceWarnings)
             io.stderr(warning);
+        if (consult.modelSlug)
+            io.stderr(`model_used: ${consult.modelSlug}`);
         let answerArtifactPath;
         const answerArtifactBytes = Buffer.byteLength(answerArtifactText, "utf8");
         if (answerArtifactBytes > MAX_FETCHABLE_RESULT_ARTIFACT_BYTES) {
@@ -1003,6 +1007,9 @@ export async function runAskProCommand(rest, io) {
                     ...(answerArtifactPath ? { artifact_path: answerArtifactPath } : {}),
                     thread: consult.url,
                     ...(Object.keys(selectionMetadata).length > 0 ? { selection: selectionMetadata } : {}),
+                    // What actually answered, straight from ChatGPT's own tag - the
+                    // receipt used to record only what prodex asked for.
+                    ...(consult.modelSlug ? { model_used: consult.modelSlug } : {}),
                     warnings: persistenceWarnings
                 }
             });
@@ -1292,6 +1299,9 @@ export function browserSendBlockerFromError(error) {
     }
     // Match the raw ms whether the message uses the old "after 90000ms" form or
     // the newer human-readable "after 20 min (1200000ms)" form.
+    const thread = typeof error === "object" && error !== null && "thread" in error && typeof error.thread === "string"
+        ? (error.thread)
+        : 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
@@ -1302,7 +1312,11 @@ export function browserSendBlockerFromError(error) {
             code: "send_timeout",
             message,
             retryable: true,
-            next_step: `Rerun with a bigger budget (${formatDurationMs(suggestedMs)}): \`prodex pro browser ask --timeout-ms ${suggestedMs} "<same prompt>"\`.`
+            ...(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}\`.`
+                    : "")
         };
     }
     // A CDP command timeout means the page's renderer stalled, which in the

package/dist/cli.js

@@ -303,9 +303,13 @@ repo: ${cwd}
    ${cli} pro browser login${sourceCliOption}  # opens visible browser
    ${cli} pro browser login --dry-run${sourceCliOption}  # preview, no browser opens
    In an interactive terminal, login waits and narrates until your ChatGPT session is READY.
+   Sign in once, then keep the browser off your screen for good:
+   ${cli} pro browser login --virtual-display${sourceCliOption}  # no window anywhere (needs Xvfb: sudo apt install -y xvfb x11-xkb-utils xauth)
+   ${cli} pro browser login --minimized${sourceCliOption}  # no install; keeps the window minimized
+   Not --headless: Cloudflare rejects headless browsers, so ChatGPT never loads in one.
    Pin per-repo defaults first - otherwise sends silently use whatever the ChatGPT UI last had selected:
    ${cli} pro browser projects${sourceCliOption}  # read-only: exact sidebar project names
-   ${cli} setup --cwd ${quotedCwd} --model Pro --project "your-project"  # every ask: Pro (15-minute timeout) inside that project
+   ${cli} setup --cwd ${quotedCwd} --model Pro --project "your-project"  # every ask: Pro (20-minute timeout) inside that project
    cd ${quotedCwd}
    ${cli} ask --new-chat "Review this repo"${sourceCliOption}  # short form of pro browser ask
    ${proAskCommand}  # dry-run/manual preview
@@ -314,7 +318,7 @@ repo: ${cwd}
    ${cli} pro browser help${sourceCliOption}
    ${cli} pro browser check${sourceCliOption} --cwd ${quotedCwd}
    ${cli} pro browser smoke${sourceCliOption} --cwd ${quotedCwd}
-   Sharing the browser with other agents? Add --busy-wait-ms 600000 to queue behind an in-flight response instead of failing.
+   Sharing the browser with other agents? Sends queue behind an in-flight response automatically; pass --busy-wait-ms 0 to fail fast instead.
 
 2. Let coding agents consult ChatGPT (stdio MCP: Claude, Codex, Cursor, ...):
    ${cli} claude config --cwd ${quotedCwd}${sourceCliOption}

package/dist/schema.js

@@ -35,7 +35,11 @@ export const BlockerSchema = z.object({
     code: z.string(),
     message: z.string(),
     retryable: z.boolean().default(false),
-    next_step: z.string().optional()
+    next_step: z.string().optional(),
+    // The ChatGPT thread the prompt landed in, recorded on send failures so
+    // `pro browser recover --target-url` has something to point at: ChatGPT
+    // usually finishes the answer after prodex has given up waiting.
+    thread: z.string().optional()
 });
 export const TaskSchema = z.object({
     schema_version: z.literal(SCHEMA_VERSION),

package/package.json

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