@youdie006/prodex 0.40.49 → 0.40.51

package/dist/browser-send-lock.js

@@ -24,9 +24,10 @@ export function sendPacingMarkerPath() {
  * Serialize visible-browser sends across processes. Waits up to waitMs for a
  * live holder to finish (0 = fail fast); a lock whose holder process is dead
  * is reaped immediately. budgetFlag is the option that sets waitMs for the
- * command that is waiting, named when the wait runs out.
+ * command that is waiting, named when the wait runs out. A waiter whose signal
+ * aborts leaves the queue with cancelledError.
  */
-export async function withBrowserSendLock(waitMs, onWait, fn, budgetFlag = "--timeout-ms") {
+export async function withBrowserSendLock(waitMs, onWait, fn, budgetFlag = "--timeout-ms", cancel = {}) {
     const file = lockPath();
     const reapClaim = path.join(path.dirname(file), `.${path.basename(file)}.reap`);
     return withCrossProcessFileLock(file, {
@@ -35,6 +36,8 @@ export async function withBrowserSendLock(waitMs, onWait, fn, budgetFlag = "--ti
         privateParent: true,
         onWait: (holder) => onWait(`another prodex send holds the browser (pid ${holder.pid ?? "unknown"}); waiting`),
         busyError: (holder) => new Error(`Another prodex browser send is in progress (pid ${holder.pid ?? "unknown"}) and did not finish within the wait budget. Retry once it finishes, or raise ${budgetFlag} (which is also the queue budget).`),
-        unavailableError: () => new Error(`A prodex browser send lock at ${file} is held by nothing and could not be removed, so no send can start. Stop all prodex senders and verify no request is active before deleting that file and the abandoned reaper claim at ${reapClaim}, then retry.`)
+        unavailableError: () => new Error(`A prodex browser send lock at ${file} is held by nothing and could not be removed, so no send can start. Stop all prodex senders and verify no request is active before deleting that file and the abandoned reaper claim at ${reapClaim}, then retry.`),
+        ...(cancel.signal ? { signal: cancel.signal } : {}),
+        ...(cancel.cancelledError ? { abortedError: cancel.cancelledError } : {})
     }, fn);
 }

package/dist/bundle.js

@@ -66,7 +66,9 @@ export async function buildDryRunBundle(root, input) {
     }
     return {
         schema_version: SCHEMA_VERSION,
-        id: makeBridgeId("sess", `${randomUUID().slice(0, 8)}-${input.prompt}`),
+        // The id is listed wherever sessions are (MCP bridge_list_sessions among
+        // them), so it carries no words from the prompt.
+        id: makeBridgeId("sess", randomUUID().slice(0, 8)),
         mode: "manual_copy",
         prompt: input.prompt,
         files,

package/dist/chatgpt-browser.js

@@ -568,15 +568,26 @@ export const CHATGPT_RENDERED_MESSAGE_TEXT_JS = `
  * and the request marker (measured 2026-10-07: 179 saved answers in one test
  * repo carried a project name). They now come only from the model selector
  * and the visible composer form, matched on word boundaries.
+ *
+ * Measured 2026-11-03, a page can hold more than the composer: a new chat keeps
+ * the home page's composer, with its own trigger, mounted but hidden ahead of
+ * the conversation's, and an "Edit message" editor is a visible form inside
+ * the user turn. Taking the first trigger and every visible form reported the
+ * hidden composer's model and the prompt being edited, so only the visible
+ * composer outside the messages counts, and not the text typed into it.
  */
 export const CHATGPT_MODEL_HINTS_JS = `
     const modelHintLines = () => {
       const sources = [];
-      const trigger = document.querySelector('button[aria-label="Select ChatGPT model"],[data-testid="model-switcher-dropdown-button"]');
+      const shown = (el) => el.getClientRects().length > 0 && !(el.parentElement && el.parentElement.closest('[data-message-author-role],[data-chatgpt-search-unit-key]'));
+      const trigger = [...document.querySelectorAll('button[aria-label="Select ChatGPT model"],[data-testid="model-switcher-dropdown-button"]')].find(shown);
       // The trigger's text names the model; its aria-label only names the control.
       if (trigger) sources.push(trigger.innerText || "");
-      for (const form of [...document.querySelectorAll("form")]) {
-        if (form.getClientRects().length > 0) sources.push(form.innerText || "");
+      const editor = [...document.querySelectorAll('#prompt-textarea,[contenteditable="true"],textarea')].find(shown);
+      const form = editor && editor.closest("form");
+      if (form) {
+        const typed = (editor.innerText || editor.value || "").split(String.fromCharCode(10)).map((line) => line.trim());
+        sources.push((form.innerText || "").split(String.fromCharCode(10)).filter((line) => !typed.includes(line.trim())).join(String.fromCharCode(10)));
       }
       const modelish = /\\b(?:ChatGPT|GPT(?:-[\\w.]+)?|Pro|Plus|Thinking|Instant|Extra High|High|Medium|Auto|Latest)\\b/i;
       const seen = [];
@@ -2713,12 +2724,19 @@ export function focusPowerSliderExpression() {
  * only (the exact "Select ChatGPT model" control first, the older heuristic
  * second), and an unrendered composer is reported as not found, which the
  * caller's poll waits out.
+ *
+ * An open "Edit message" editor is a form inside the transcript, ahead of the
+ * composer in the document, and has no trigger. Measured 2026-11-03: taking it
+ * refused every follow-up that selected a model until the page was reloaded,
+ * so editors inside a message are skipped. Only message ancestors exclude one
+ * here, not aria-hidden as in the typing lookup: an open menu aria-hides the
+ * composer itself.
  */
 export function modelButtonRectExpression() {
     return `(() => {${CLICK_POINT_SNIPPET}
     const composer = [...document.querySelectorAll('#prompt-textarea,[contenteditable="true"],textarea')].find((el) => {
       const r = el.getBoundingClientRect();
-      return r.width > 0 && r.height > 0;
+      return r.width > 0 && r.height > 0 && !(el.parentElement && el.parentElement.closest('[data-message-author-role],[data-chatgpt-search-unit-key]'));
     });
     if (!composer) return { ok: false, reason: "model selector button not found: the composer has not rendered" };
     const scope = composer.closest('form');
@@ -4581,6 +4599,7 @@ export async function sendChatGptPrompt(options) {
       if (last && expandCollapsedUserTurn(last.textNode)) return false;
       return Boolean(last && userMessageText(last.textNode).includes(${JSON.stringify(`[prodex-request:${requestId}]`)}));
     })()`;
+        await options.beforePromptSubmit?.();
         // A dispatch can reach Chrome even if its acknowledgement is lost.
         submissionAttempted = true;
         await cdp.send("Input.dispatchKeyEvent", enterKeyEvent("keyDown"));
@@ -6103,9 +6122,11 @@ export function composerToolsButtonRectExpression() {
     return `(() => {${CLICK_POINT_SNIPPET}
     const legacy = document.querySelector('[data-testid="composer-plus-btn"]');
     if (legacy) return clickPoint(legacy);
+    // An open "Edit message" editor sits in the transcript ahead of the
+    // composer, in a form without this button; see modelButtonRectExpression.
     const composer = [...document.querySelectorAll('#prompt-textarea,[contenteditable="true"],textarea')].find((el) => {
       const r = el.getBoundingClientRect();
-      return r.width > 0 && r.height > 0;
+      return r.width > 0 && r.height > 0 && !(el.parentElement && el.parentElement.closest('[data-message-author-role],[data-chatgpt-search-unit-key]'));
     });
     const form = composer && composer.closest('form');
     if (!form) return { ok: false, reason: "composer tools button not found: the composer has not rendered" };
@@ -6154,11 +6175,15 @@ export function composerToolEntryRectExpression(label) {
 /** Tool tokens currently sitting in the composer. */
 export function activeComposerToolsExpression(labels) {
     const labelsJson = JSON.stringify(labels);
-    return `(() => {
+    return `(() => {${composerExpressionHelpers()}
     // The token normally lands inside the editor, but some builds render it as
     // a pill in the surrounding composer form - check both before deciding a
     // selection did not take.
-    const el = document.querySelector('#prompt-textarea,[contenteditable="true"]');
+    // Read the composer a send types into. Measured 2026-11-03: a new chat
+    // leaves the home page's composer mounted in a hidden workspace ahead of
+    // the conversation's, and the first editor in the document was that one,
+    // so a follow-up's tool was on but read as off.
+    const el = findChatGptComposerCandidate();
     const form = el ? (el.closest("form") || el.parentElement) : null;
     const text = ((el ? el.innerText || "" : "") + String.fromCharCode(10) + (form ? form.innerText || "" : "")).toLowerCase();
     // Case-insensitively: prodex carries the label as the menu spells it

package/dist/cli-args.js

@@ -31,6 +31,33 @@ export function findHelpFlagIndexBeforePromptDelimiter(args) {
     const limit = delimiterIndex === -1 ? args.length : delimiterIndex;
     return args.findIndex((arg, index) => index < limit && isHelpSubcommand(arg));
 }
+/**
+ * Where a help request is, or -1. In a command whose unquoted words are its
+ * prompt, the word "help" asks for help only on its own: found 2026-11-09,
+ * `prodex ask can you help me fix this` was taken for a help request and
+ * failed with "Unexpected argument for ask: can". --help and -h always ask.
+ */
+export function findHelpRequestIndex(args, options = {}) {
+    const delimiterIndex = args.indexOf("--");
+    const limit = delimiterIndex === -1 ? args.length : delimiterIndex;
+    const valueFlagSet = new Set(options.valueFlags ?? []);
+    const words = [];
+    for (let index = 0; index < limit; index += 1) {
+        const arg = args[index];
+        if (arg === "--help" || arg === "-h")
+            return index;
+        if (valueFlagSet.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith("-"))
+            words.push(index);
+    }
+    const helpWord = words.find((index) => args[index] === "help");
+    if (helpWord === undefined)
+        return -1;
+    return !options.promptWords || words.length === 1 ? helpWord : -1;
+}
 export function assertHelpRequestArgs(args, command, options) {
     const delimiterIndex = args.indexOf("--");
     const commandArgs = delimiterIndex === -1 ? args : args.slice(0, delimiterIndex);
@@ -397,7 +424,7 @@ export function readNumberFlag(args, flag) {
 }
 export const RECEIPT_KINDS = ReceiptKindSchema.options;
 export function printHelpIfRequested(args, command, stdout, printHelp, options = {}) {
-    const helpIndex = findHelpFlagIndexBeforePromptDelimiter(args);
+    const helpIndex = options.promptWords ? findHelpRequestIndex(args, options) : findHelpFlagIndexBeforePromptDelimiter(args);
     if (helpIndex === -1)
         return false;
     assertHelpRequestArgs(args, command, options);

package/dist/cli-ledger.js

@@ -92,7 +92,7 @@ export async function runTasksCommand(rest, io) {
             status: "done",
             summary,
             commands: readRepeatedFlag(taskArgs, "--command"),
-            artifacts: await writeTaskCompleteArtifacts(targetStore, readRepeatedFlag(taskArgs, "--artifact"))
+            artifacts: await writeTaskCompleteArtifacts(targetStore, taskId, readRepeatedFlag(taskArgs, "--artifact"))
         });
         io.stdout(`${result.task_id}\t${result.status}\t${result.summary}`);
         return 0;
@@ -355,7 +355,7 @@ export function receiptInspectionListSuffix(receipt) {
     }
     return "";
 }
-export async function writeTaskCompleteArtifacts(store, values) {
+export async function writeTaskCompleteArtifacts(store, taskId, values) {
     const parsed = [];
     const seen = new Set();
     for (const value of values) {
@@ -377,12 +377,7 @@ export async function writeTaskCompleteArtifacts(store, values) {
         seen.add(key);
         parsed.push({ artifactPath, content });
     }
-    const artifacts = [];
-    for (const { artifactPath, content } of parsed) {
-        const storedPath = await store.writeArtifactText(artifactPath, content);
-        artifacts.push({ path: storedPath, role: "result" });
-    }
-    return artifacts;
+    return store.writeResultArtifactTexts(taskId, parsed.map(({ artifactPath, content }) => ({ path: artifactPath, content })));
 }
 export async function listTasksForInspection(store, status) {
     return store.listTasksReadOnly(status);

package/dist/cli-pro.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { BrowserProcessInspectionError } from "./browser-process.js";
 import { buildDryRunBundle } from "./bundle.js";
 import { ChatGptBrowserBlockerError, DEFAULT_CDP_PORT, resolveCdpPort, resolveConversationToDelete, resolveProjectToDelete, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, formatModelMenuOption, listChatGptModelOptions, deleteChatGptConversation, endWedgedBrowser, browserRecoveryPlan, findWedgedBrowser, wedgedBrowserBlocker, deleteChatGptProject, listChatGptProjectsWithIds, listRecentChatGptConversations, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, openChatGptTab, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveBrowserWindowMode, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt, statusMeansBrowserDead, namesPro, sendWarningsFromError, destinationVerification, chatGptProjectIdFromUrl, chatStepNamedAsModel, normalizeChatGptThreadUrl } from "./chatgpt-browser.js";
-import { ASK_PRO_BOOLEAN_FLAGS, ASK_PRO_PREVIEW_VALUE_FLAGS, ASK_PRO_VALUE_FLAGS, assertHelpRequestArgs, assertNoExtraArgs, assertOnlyOptions, findHelpFlagIndexBeforePromptDelimiter, formatCliCommand, hasAskProDryRunMode, hasAskProMode, hasAskProSendMode, isHelpSubcommand, parseAskProArgs, printHelpIfRequested, readFlag, readPortFlag, readPositionalsWithOptions, readNonNegativeIntegerFlag, readPositiveIntegerFlag, readRepeatedFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError, assertProjectName } from "./cli-args.js";
+import { ASK_PRO_BOOLEAN_FLAGS, ASK_PRO_PREVIEW_VALUE_FLAGS, ASK_PRO_VALUE_FLAGS, assertHelpRequestArgs, assertNoExtraArgs, assertOnlyOptions, findHelpFlagIndexBeforePromptDelimiter, findHelpRequestIndex, formatCliCommand, hasAskProDryRunMode, hasAskProMode, hasAskProSendMode, isHelpSubcommand, parseAskProArgs, printHelpIfRequested, readFlag, readPortFlag, readPositionalsWithOptions, readNonNegativeIntegerFlag, readPositiveIntegerFlag, readRepeatedFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError, assertProjectName } from "./cli-args.js";
 import { printProBrowserHelp, printProHelp } from "./cli-help.js";
 import { listRawResultsForInspection, listTasksForInspection } from "./cli-ledger.js";
 import { formatBrowserDefaults, redactServerUrl } from "./cli-server.js";
@@ -14,7 +14,7 @@ import { getTokenExpiryStatus, loadBrowserDefaults, loadLocalConfig } from "./co
 import { sendPacingMarkerPath, withBrowserSendLock } from "./browser-send-lock.js";
 import { blockerCause, buildBlockerReport, CATCH_ALL_CODES } from "./blocker-report.js";
 import { isChatGptConversationUrl, projectIdFromSidebar, resolveContinuationThread } from "./continue-thread.js";
-import { FollowupApprovalRequired, reserveFollowup, resolveMaxAutoFollowups } from "./followup-budget.js";
+import { assertFollowupAvailable, FollowupApprovalRequired, reserveFollowup, resolveMaxAutoFollowups } from "./followup-budget.js";
 import { readBridgeRoots } from "./registry.js";
 import { ProdexRequestIdSchema, SessionKeySchema } from "./schema.js";
 import { BridgeStore, MAX_FETCHABLE_RESULT_ARTIFACT_BYTES } from "./store.js";
@@ -158,7 +158,8 @@ export async function runProCommand(rest, io, runCliFn) {
     if (subcommand === "ask") {
         if (printHelpIfRequested(proArgs, "pro ask", io.stdout, printProHelp, {
             valueFlags: [...ASK_PRO_PREVIEW_VALUE_FLAGS],
-            booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS]
+            booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS],
+            promptWords: true
         })) {
             return 0;
         }
@@ -187,7 +188,9 @@ export async function runProCommand(rest, io, runCliFn) {
             "--continue-task",
             "--auto-login",
             "--no-auto-login"
-        ].find((flag) => proArgs.includes(flag));
+            // Only before --: the words after it are the prompt, which may well
+            // mention an option (found 2026-11-09: "what does --project do").
+        ].find((flag) => (proArgs.includes("--") ? proArgs.slice(0, proArgs.indexOf("--")) : proArgs).includes(flag));
         if (straySendFlag) {
             throw new Error(`${straySendFlag} only applies when sending; \`prodex pro ask\` is a dry-run preview. Use \`prodex pro browser ask\` (or \`prodex ask\`) to send.`);
         }
@@ -497,7 +500,8 @@ export async function runProCommand(rest, io, runCliFn) {
         if (browserSubcommand === "ask") {
             if (printProBrowserHelpIfRequested(browserArgs, "pro browser ask", io, {
                 valueFlags: [...ASK_PRO_VALUE_FLAGS],
-                booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS]
+                booleanFlags: [...ASK_PRO_BOOLEAN_FLAGS],
+                promptWords: true
             })) {
                 return 0;
             }
@@ -1170,7 +1174,10 @@ export function createBrowserSendProgressPrinter(write, heartbeatMs = 10_000) {
         write(`progress: ${PROGRESS_PHASE_LABELS[event.phase]}${event.detail ? ` (${event.detail})` : ""}`);
     };
 }
-export async function runAskProCommand(rest, io, beforeSend) {
+export async function runAskProCommand(rest, io, 
+// Runs before any task is created. The step it returns runs once the prompt
+// is typed, right before it is submitted.
+beforeSend) {
     const parsedAskPro = parseAskProArgs(rest);
     const hasDryRunMode = parsedAskPro.optionArgs.includes("--dry-run");
     const hasSendMode = parsedAskPro.optionArgs.includes("--send");
@@ -1472,11 +1479,23 @@ export async function runAskProCommand(rest, io, beforeSend) {
     if (hasSendMode) {
         // MCP approval checkpoints run after target validation but before any
         // task creation, pacing, browser recovery, or prompt send.
-        await beforeSend?.({
+        const beforeSubmitStep = (await beforeSend?.({
             store: targetStore,
             ...(normalizedTargetUrl ? { thread: normalizedTargetUrl } : {}),
             ...(continuedFromTaskId ? { continuedFrom: continuedFromTaskId } : {})
-        });
+        })) || undefined;
+        // A cancelled call is stopped before its prompt is submitted: here, in
+        // the send queue, instead of a browser recovery, and right before the
+        // submit. After the submit it is not: an answer already on its way is
+        // waited for and recorded as usual. The last check runs ahead of the
+        // step, so a cancelled follow-up does not spend the budget it reserves.
+        throwIfConsultCancelled(io.signal);
+        const beforePromptSubmit = io.signal || beforeSubmitStep
+            ? async () => {
+                throwIfConsultCancelled(io.signal);
+                await beforeSubmitStep?.();
+            }
+            : undefined;
         const browserCommandOptions = {
             cwd: targetCwd,
             port: parsedAskPro.optionArgs.includes("--port") ? browserPort : undefined
@@ -1555,9 +1574,10 @@ export async function runAskProCommand(rest, io, beforeSend) {
                 proMode: selectionProMode,
                 effort: selectionEffort,
                 ...(allowSelectionFallback ? { allowSelectionFallback: true } : {}),
+                ...(beforePromptSubmit ? { beforePromptSubmit } : {}),
                 onProgress: createBrowserSendProgressPrinter(io.stderr)
             });
-        });
+        }, "--timeout-ms", { ...(io.signal ? { signal: io.signal } : {}), cancelledError: consultCancelledError });
         // One-command recovery: interactive terminals (or explicit --auto-login)
         // launch the dedicated browser and retry once when no browser runs.
         // Scripts and agents keep the plain blocker unless they opt in.
@@ -1576,8 +1596,9 @@ export async function runAskProCommand(rest, io, beforeSend) {
             catch (error) {
                 const firstBlocker = browserSendBlockerFromError(error);
                 // Loss while reading an already-submitted prompt must not send it again.
+                // Nor is a browser launched for a call that has been cancelled.
                 if (!["browser_unreachable", "chatgpt_page_missing"].includes(firstBlocker.code) ||
-                    !firstBlocker.retryable || firstBlocker.thread || !autoLoginAllowed)
+                    !firstBlocker.retryable || firstBlocker.thread || !autoLoginAllowed || io.signal?.aborted)
                     throw error;
                 const recover = firstBlocker.code === "chatgpt_page_missing" ? attemptMissingChatGptTabRecovery : attemptBrowserAutoRecovery;
                 const recovered = await recover(io.stderr, {
@@ -1592,7 +1613,11 @@ export async function runAskProCommand(rest, io, beforeSend) {
             }
         }
         catch (error) {
-            const blocker = await withManualStepForWindowMode(sourceAwareBrowserBlocker(browserSendBlockerFromError(error), sourceCli, browserCommandOptions), resolveCdpPort(browserPort), sourceCli, browserCommandOptions);
+            // Another follow-up spent the budget while this one waited for the
+            // browser. Nothing was submitted; the caller asks the user instead.
+            const blocker = error instanceof FollowupApprovalRequired
+                ? { code: "followup_approval_required", message: error.message, retryable: false }
+                : await withManualStepForWindowMode(sourceAwareBrowserBlocker(browserSendBlockerFromError(error), sourceCli, browserCommandOptions), resolveCdpPort(browserPort), sourceCli, browserCommandOptions);
             const message = blocker.next_step ? `${blocker.message} Next: ${blocker.next_step}` : errorMessage(error);
             // The blocker text can quote the requested/default project name (e.g. a
             // "project not found" error). Local stdout/stderr keep it (useful to the
@@ -1659,6 +1684,8 @@ export async function runAskProCommand(rest, io, beforeSend) {
                     blocker
                 }, null, 2));
             }
+            if (error instanceof FollowupApprovalRequired)
+                throw error;
             throw new Error(formatBlockedConsultRecordedMessage(message, task.id, sourceCli, { cwd: targetCwd }));
         }
         const answerArtifactText = formatProConsultArtifact(consult);
@@ -1930,6 +1957,18 @@ export async function performBrowserRecoverForMcp(cwd, input) {
         notes: stderrLines
     };
 }
+function consultCancelledError() {
+    return new ChatGptBrowserBlockerError({
+        code: "consult_cancelled",
+        message: "The client cancelled this consult before its prompt was submitted, so nothing was sent to ChatGPT.",
+        retryable: true,
+        next_step: "Nothing to recover. Send the consult again if it is still wanted."
+    });
+}
+function throwIfConsultCancelled(signal) {
+    if (signal?.aborted)
+        throw consultCancelledError();
+}
 /** The marker the send prints before throwing, when the answer outlived its record. */
 const ANSWER_NOT_SAVED_MARKER = "consult_answer_received_but_not_saved:";
 /**
@@ -1983,7 +2022,7 @@ export function mcpBlockedConsultOutcome(stdoutLines, error) {
         ...(thread && requestId ? { recover: { tool: "pro_recover", arguments: { thread, request_id: requestId } } } : {})
     };
 }
-export async function performBrowserConsultForMcp(cwd, input, onProgress) {
+export async function performBrowserConsultForMcp(cwd, input, onProgress, signal) {
     const stdoutLines = [];
     const stderrLines = [];
     const sessionKey = resolveProdexSessionKey(input.session_key);
@@ -2031,17 +2070,23 @@ export async function performBrowserConsultForMcp(cwd, input, onProgress) {
                 if (onProgress && line.startsWith("progress:"))
                     onProgress(line);
             },
-            allowAskProBrowserSend: true
+            allowAskProBrowserSend: true,
+            ...(signal ? { signal } : {})
         }, async ({ store, thread, continuedFrom }) => {
             if (!thread || !continuedFrom)
                 return;
             continuationTarget = { taskId: continuedFrom, thread };
-            followupBudget = await reserveFollowup(store, {
-                thread,
-                taskId: continuedFrom,
-                userApproved: input.user_approved === true,
-                limit
-            });
+            const reservation = { thread, taskId: continuedFrom, userApproved: input.user_approved === true, limit };
+            await assertFollowupAvailable(store, reservation);
+            // Spent only when the prompt is about to be submitted, and once: a retry
+            // after browser recovery is the same follow-up.
+            let reserved = false;
+            return async () => {
+                if (reserved)
+                    return;
+                followupBudget = await reserveFollowup(store, reservation);
+                reserved = true;
+            };
         });
     }
     catch (error) {
@@ -3400,7 +3445,7 @@ export function printBrowserLoginGuide(stdout, input) {
     }
 }
 export function printProBrowserHelpIfRequested(args, command, io, options) {
-    const helpIndex = findHelpFlagIndexBeforePromptDelimiter(args);
+    const helpIndex = options.promptWords ? findHelpRequestIndex(args, options) : findHelpFlagIndexBeforePromptDelimiter(args);
     if (helpIndex === -1)
         return false;
     assertHelpRequestArgs(args, command, options);

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { execFile } from "node:child_process";
 import { realpathSync } from "node:fs";
+import http from "node:http";
 import { lstat, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
@@ -280,7 +281,7 @@ export async function runCli(args, io = defaultIo()) {
         // pro_consult is stdio-only: the HTTP MCP surface is exposed to ChatGPT
         // itself (and possibly a tunnel) and must never drive the user's browser.
         await runMcpServer(mcpCwd, {
-            browserConsult: (input, onProgress) => performBrowserConsultForMcp(mcpCwd, input, onProgress),
+            browserConsult: (input, onProgress, signal) => performBrowserConsultForMcp(mcpCwd, input, onProgress, signal),
             browserRecover: (input) => performBrowserRecoverForMcp(mcpCwd, input)
         });
         return 0;
@@ -288,31 +289,75 @@ export async function runCli(args, io = defaultIo()) {
     throw unknownTopLevelCommandError(command);
 }
 /**
- * Whether something other than prodex is sitting on the configured port.
+ * Whether something other than this repo's prodex server is sitting on the
+ * configured port, which `prodex start` then cannot bind.
  *
- * A prodex HTTP server answers /mcp - with 401 when the token is missing,
- * which is still an answer. Anything else holding the port means `prodex
- * start` cannot bind it, and the configured URL points at a stranger.
- * Silence (nothing listening) is the healthy case.
+ * A prodex server names itself on /health, without a token. Found
+ * 2026-11-09: the check used to take any server answering /mcp with 200, 400
+ * or 401 for prodex, and a program that does not speak HTTP, or accepts the
+ * connection and says nothing, for a free port. Another repo's prodex server
+ * is the likeliest holder, since every repo's setup defaults to port 8787; it
+ * refuses this repo's token. A refused connection is the healthy case.
  */
-export async function describeConfiguredPortHolder(host, port) {
-    let response;
-    try {
-        response = await fetch(`http://${host}:${port}/mcp`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: "{}",
-            signal: AbortSignal.timeout(1_500)
+export async function describeConfiguredPortHolder(host, port, token) {
+    const cannotBind = "so `prodex start` cannot bind it";
+    const health = await probeHttpEndpoint(host, port, "/health", { method: "GET" });
+    if (health.kind === "free")
+        return undefined;
+    if (health.kind === "not-http")
+        return `port ${port} on ${host} is held by a program that does not answer HTTP, ${cannotBind}.`;
+    if (!isProdexHealth(health.body)) {
+        return `port ${port} on ${host} is held by something that is not a prodex server (it answered /health with HTTP ${health.status}), ${cannotBind}.`;
+    }
+    if (token === undefined)
+        return undefined;
+    const mcp = await probeHttpEndpoint(host, port, "/mcp", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+        body: "{}"
+    });
+    if (mcp.kind === "http" && mcp.status === 401) {
+        return `port ${port} on ${host} is held by another prodex server, one that refuses this repo's token (another repo's \`prodex start\`, or one started before this token was set), ${cannotBind} here.`;
+    }
+    return undefined;
+}
+function probeHttpEndpoint(host, port, requestPath, options) {
+    return new Promise((resolve) => {
+        let connected = false;
+        const request = http.request({ host, port, path: requestPath, method: options.method, headers: options.headers, timeout: 1_500, agent: false }, (response) => {
+            let body = "";
+            response.setEncoding("utf8");
+            response.on("data", (chunk) => {
+                if (body.length < 4_096)
+                    body += chunk;
+            });
+            response.on("end", () => resolve({ kind: "http", status: response.statusCode ?? 0, body }));
+            response.on("error", () => resolve({ kind: "http", status: response.statusCode ?? 0, body }));
         });
+        request.on("socket", (socket) => socket.once("connect", () => (connected = true)));
+        // A connection accepted and then left silent is a program holding the
+        // port. One never accepted is not: on WSL a free loopback port does not
+        // refuse a connection, it lets the attempt time out.
+        request.on("timeout", () => {
+            request.destroy();
+            resolve({ kind: connected ? "not-http" : "free" });
+        });
+        request.on("error", (error) => {
+            request.destroy();
+            const nothingListening = !connected || ["ECONNREFUSED", "EADDRNOTAVAIL", "EHOSTUNREACH", "ENETUNREACH"].includes(error.code ?? "");
+            resolve({ kind: nothingListening ? "free" : "not-http" });
+        });
+        request.end(options.body);
+    });
+}
+function isProdexHealth(body) {
+    try {
+        const parsed = JSON.parse(body);
+        return parsed.name === "prodex";
     }
     catch {
-        // Nothing is listening, or it refused the connection: the port is free for
-        // prodex to take, which is what this check is about.
-        return undefined;
+        return false;
     }
-    if (response.status === 401 || response.status === 200 || response.status === 400)
-        return undefined;
-    return `port ${port} on ${host} is held by something that is not a prodex server (it answered /mcp with HTTP ${response.status}), so \`prodex start\` cannot bind it.`;
 }
 function defaultIo() {
     return {
@@ -1046,7 +1091,7 @@ async function runDoctor(store, io, sourceCli, setupHintCwd) {
             // Measured here: the configured port was held by an unrelated program,
             // so `prodex start` could never bind it - and doctor called the config
             // ok anyway, which is the one line someone reads before believing it.
-            const portHolder = await describeConfiguredPortHolder(config.host, config.port);
+            const portHolder = await describeConfiguredPortHolder(config.host, config.port, config.token);
             if (portHolder) {
                 io.stdout(`config_warning: ${portHolder} \`${formatSetupCommand(sourceCli, { cwd: setupHintCwd })} --port <free port>\` moves prodex off it.`);
             }

package/dist/followup-budget.js

@@ -33,7 +33,24 @@ export function resolveMaxAutoFollowups(envValue = process.env.PRODEX_MAX_AUTO_F
     }
     return value;
 }
+/**
+ * Refuse a follow-up the budget no longer covers, without spending any of it.
+ *
+ * The follow-up is reserved only once its prompt is about to be submitted.
+ * Measured 2026-11-02 in the browser container: two follow-ups in one
+ * conversation, refused as composer_not_ready before anything was typed, were
+ * recorded as its follow-ups 3 and 4 of 5. This check keeps an exhausted budget
+ * from creating a task or touching the browser at all.
+ */
+export async function assertFollowupAvailable(store, input) {
+    await withFollowupBudgetLock(store, input, async (conversationKey) => {
+        await readConversationLedger(store, { conversationKey, ...input });
+    });
+}
 export async function reserveFollowup(store, input) {
+    return withFollowupBudgetLock(store, input, async (conversationKey) => reserveFollowupUnderLock(store, { ...input, conversationKey }));
+}
+async function withFollowupBudgetLock(store, input, run) {
     assertFollowupLimit(input.limit);
     const conversationKey = conversationKeyFromThread(input.thread);
     await store.ensure();
@@ -44,9 +61,10 @@ export async function reserveFollowup(store, input) {
         privateParent: true,
         busyError: (holder) => new Error(`Another follow-up reservation is in progress (pid ${holder.pid ?? "unknown"})`),
         unavailableError: () => new Error("The follow-up budget lock could not be recovered. Stop all prodex processes before removing the lock and its matching .reap claim, then retry.")
-    }, async () => reserveFollowupUnderLock(store, { ...input, conversationKey }));
+    }, async () => run(conversationKey));
 }
-async function reserveFollowupUnderLock(store, input) {
+/** The conversation's ledger so far; throws when the budget does not cover another follow-up. */
+async function readConversationLedger(store, input) {
     const reservations = await readTrustedReservations(store);
     const conversationReservations = reservations
         .filter((reservation) => reservation.metadata.conversation_key === input.conversationKey)
@@ -59,6 +77,10 @@ async function reserveFollowupUnderLock(store, input) {
             remaining: 0
         });
     }
+    return previous;
+}
+async function reserveFollowupUnderLock(store, input) {
+    const previous = await readConversationLedger(store, input);
     const budget = input.userApproved === true
         ? { limit: input.limit, used: 0, remaining: input.limit }
         : {