@youdie006/prodex 0.40.48 → 0.40.50

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

@@ -1150,7 +1150,8 @@ export function shouldRecoverThreadNavigation(args) {
     return !chatGptUrlsReferToSameTarget(currentUrl, pinnedThreadUrl);
 }
 export function hasFreshChatGptAnswer(previousAssistantMessageCount, state) {
-    return state.assistantMessageCount > previousAssistantMessageCount && isUsableChatGptAnswer(state.answer) && !state.generating;
+    return state.assistantMessageCount > previousAssistantMessageCount && isUsableChatGptAnswer(state.answer) && !state.generating &&
+        state.answerRenderFailed !== true;
 }
 // The acceptance phase waits for the prompt to POST (a new user/assistant
 // message), not for the answer. So a timeout here almost never means "slow
@@ -1193,7 +1194,8 @@ export function acceptanceTimeoutError(ctx) {
     });
 }
 export function hasPartialChatGptAnswer(previousAssistantMessageCount, state) {
-    return state.assistantMessageCount > previousAssistantMessageCount && isUsableChatGptAnswer(state.answer);
+    return state.assistantMessageCount > previousAssistantMessageCount && isUsableChatGptAnswer(state.answer) &&
+        state.answerRenderFailed !== true;
 }
 /**
  * True when the tab is on a fresh, empty ChatGPT chat: the root URL (not a
@@ -1590,6 +1592,21 @@ export function chatGptBlockerErrorFromAnswerState(state) {
 export function chatGptBlockerFromAnswerState(state) {
     return detectChatGptPageBlocker(state);
 }
+/**
+ * The answer exists, but the page shows "This response couldn’t load" in
+ * its place. Measured 2026-10-30 in the browser container, where Chromium could
+ * not start threads: the conversation held the finished answer, and loading
+ * the thread again drew it.
+ */
+export function answerRenderFailedBlocker(thread) {
+    return {
+        code: "answer_render_failed",
+        message: "ChatGPT answered, but the page could not display the answer (it shows \"This response couldn’t load\"). No answer was returned.",
+        retryable: false,
+        next_step: "Recovery loads the conversation again and reads the answer.",
+        ...(thread ? { thread } : {})
+    };
+}
 function submittedRequestBlocker(blocker, requestId, thread) {
     return {
         ...blocker,
@@ -2696,12 +2713,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');
@@ -2884,6 +2908,64 @@ export function sidebarProjectRowPointExpression(name) {
     return { ok: true, x: Math.round(r.x + Math.min(r.width / 3, 60)), y: Math.round(r.y + r.height / 2) };
   })()`;
 }
+/**
+ * Show the projects the sidebar keeps behind "Show more".
+ *
+ * Measured 2026-10-30 on WSL: the sidebar listed 9 project rows (4 pinned, 5
+ * under Projects) and a "Show more" button under the Projects section;
+ * pressing it added 16 more rows that were not in the page at all before. A
+ * --project send for any of them failed as "project not found in sidebar (9
+ * projects visible)". The button has no label of its own, so it is found as
+ * the ghost button of a section that lists projects, outside every row, and
+ * not the section's toggle; its English text is the fallback. The sidebar
+ * offers nothing to fold the list again, so it stays shown.
+ */
+export function expandSidebarProjectsExpression() {
+    return `(async () => {
+    const projectRows = (root) => root.querySelectorAll("[data-app-action-sidebar-project-row]").length;
+    const before = projectRows(document);
+    const showMore = (button) =>
+      !button.closest("[data-app-action-sidebar-project-row],[data-sidebar-project-container-id^='project:']") &&
+      !button.hasAttribute("data-app-action-sidebar-section-toggle") &&
+      !button.getAttribute("aria-label") &&
+      (button.getAttribute("data-variant") === "ghost" || /^show more$/i.test((button.innerText || "").trim())) &&
+      button.getClientRects().length > 0;
+    const sections = [...document.querySelectorAll("section[data-app-action-sidebar-section]")].filter((section) => projectRows(section) > 0);
+    const more = sections.flatMap((section) => [...section.querySelectorAll("button")]).find(showMore);
+    if (!more) return { clicked: false, before, after: before };
+    more.click();
+    for (let waited = 0; waited < 3000 && projectRows(document) <= before; waited += 100) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return { clicked: true, before, after: projectRows(document) };
+  })()`;
+}
+/**
+ * The sidebar row of an existing project, shown first if it is behind "Show
+ * more". Polls, because right after a --new-chat navigation the sidebar's
+ * Projects section has not hydrated yet (measured live: "0 projects visible"
+ * on the first read, rows appear moments later) - the same class of race as
+ * the model-selector button after new-chat (0.15.7).
+ */
+export async function findSidebarProjectRow(cdp, project, timeoutMs = 6_000) {
+    let hit = { ok: false };
+    let expanded = false;
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        hit = await cdp.evaluate(projectItemRectExpression(project));
+        if (hit.ok && hit.x !== undefined && hit.y !== undefined)
+            return hit;
+        if (!expanded && /project not found in sidebar/.test(hit.reason ?? "")) {
+            const shown = await cdp.evaluate(expandSidebarProjectsExpression());
+            expanded = shown?.clicked === true;
+            if (expanded)
+                continue;
+        }
+        if (Date.now() >= deadline)
+            return hit;
+        await sleep(300);
+    }
+}
 /** Hover a project row so its hover-only controls can be clicked. A no-op on the older sidebar. */
 async function revealSidebarProjectControls(cdp, name) {
     const point = await cdp.evaluate(sidebarProjectRowPointExpression(name));
@@ -3775,21 +3857,7 @@ async function waitForComposerProjectBinding(cdp, project, timeoutMs) {
 // question, not this one's.
 async function navigateToExistingProject(cdp, project) {
     const hrefBefore = await cdp.evaluate("location.href");
-    // Poll for the project row instead of a single check: right after a
-    // --new-chat navigation the sidebar's Projects section has not hydrated yet
-    // (measured live: "0 projects visible" on the first read, rows appear
-    // moments later) - the same class of race as the model-selector button
-    // after new-chat (0.15.7).
-    let hit = { ok: false };
-    const projectDeadline = Date.now() + 6_000;
-    for (;;) {
-        hit = await cdp.evaluate(projectItemRectExpression(project));
-        if (hit.ok && hit.x !== undefined && hit.y !== undefined)
-            break;
-        if (Date.now() >= projectDeadline)
-            break;
-        await sleep(300);
-    }
+    const hit = await findSidebarProjectRow(cdp, project);
     if (!hit.ok || hit.x === undefined || hit.y === undefined) {
         const detail = hit.reason && hit.reason !== "project not found in sidebar" ? ` (${hit.reason})` : "";
         throw new Error(`ChatGPT project not found in sidebar: ${project}${detail} List the visible names with \`prodex pro browser projects\`.`);
@@ -3981,6 +4049,8 @@ export async function recoverChatGptAnswerFromThread(options) {
     let lastAnswer = "";
     let lastObservedUrl = "";
     let completed = false;
+    let renderFailed = false;
+    let reloadedForRenderFailure = false;
     try {
         await cdp.send("Runtime.enable");
         // In-tab navigation (location.assign, not Page.navigate which has crashed the
@@ -4033,6 +4103,21 @@ export async function recoverChatGptAnswerFromThread(options) {
                     thread: url
                 });
             }
+            // The tab may already be on the thread with the page's error in place
+            // of the answer, so recovery loads the thread once more to draw it.
+            if (state.answerRenderFailed && !state.generating && state.assistantMessageCount > 0) {
+                renderFailed = true;
+                stableRuns = 0;
+                lastAnswer = "";
+                if (!reloadedForRenderFailure) {
+                    reloadedForRenderFailure = true;
+                    await evaluateOnPage(page.page, markDocumentForReloadExpression());
+                    await navigateIdleChatGptPage(page.page, url);
+                    await waitForReloadedDocument(page.page, deadline);
+                }
+                continue;
+            }
+            renderFailed = false;
             // 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.
@@ -4057,6 +4142,13 @@ export async function recoverChatGptAnswerFromThread(options) {
     }
     if (!completed) {
         const targetMatched = Boolean(state && chatGptUrlsReferToSameTarget(state.url, url));
+        if (targetMatched && renderFailed) {
+            throw new ChatGptBrowserBlockerError({
+                ...answerRenderFailedBlocker(url),
+                retryable: true,
+                next_step: "The page still could not display the answer after loading the conversation again. Check that the browser is not short of memory or processes, then rerun recovery."
+            });
+        }
         const hasUsableAnswer = Boolean(state && state.assistantMessageCount > 0 && isUsableChatGptAnswer(state.answer));
         const code = !targetMatched
             ? "thread_target_mismatch"
@@ -4496,6 +4588,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"));
@@ -4609,6 +4702,7 @@ export async function sendChatGptPrompt(options) {
     expandingPolls = 0;
     let nonTextPolls = 0;
     let nonTextSettled = false;
+    let renderFailedPolls = 0;
     const answerIsStable = createChatGptAnswerStabilityTracker();
     while (Date.now() - started < timeoutMs) {
         await sleep(1000);
@@ -4680,6 +4774,16 @@ export async function sendChatGptPrompt(options) {
             continue;
         }
         nonTextPolls = 0;
+        // Two reads in a row, so a failure the renderer is about to replace does
+        // not end the send.
+        if (finalState.answerRenderFailed && !finalState.generating && finalState.assistantMessageCount > beforeSubmit.assistantMessageCount) {
+            renderFailedPolls += 1;
+            if (renderFailedPolls >= 2) {
+                throw attachSendWarnings(new ChatGptBrowserBlockerError(submittedRequestBlocker(answerRenderFailedBlocker(pinnedThreadUrl), requestId, pinnedThreadUrl)), sendWarnings);
+            }
+            continue;
+        }
+        renderFailedPolls = 0;
         if (!hasFreshChatGptAnswer(beforeSubmit.assistantMessageCount, finalState))
             continue;
         // A "fresh" answer must also be stable: ChatGPT can momentarily look done
@@ -5012,7 +5116,10 @@ export function resolveProjectToDelete(projects, request) {
     return { ok: true, id: matches[0].id, name: matches[0].name };
 }
 export async function listChatGptProjectsWithIds(input = {}) {
-    return listVisibleChatGptNavigation(input, projectsWithIdsExpression());
+    return listVisibleChatGptNavigation(input, `(async () => {
+    await ${expandSidebarProjectsExpression()};
+    return ${projectsWithIdsExpression()};
+  })()`);
 }
 /** Project deletion has no bounded visible-DOM implementation. */
 export async function deleteChatGptProject(_input) {
@@ -5064,6 +5171,11 @@ export async function listChatGptSidebarProjects(input = {}) {
             break;
         await sleep(300);
     }
+    if (projects.length > 0) {
+        const shown = await evaluateOnPage(page, expandSidebarProjectsExpression());
+        if (shown?.clicked)
+            projects = await evaluateOnPage(page, sidebarProjectNamesExpression());
+    }
     return { url: status.url, projects };
 }
 /**
@@ -5999,9 +6111,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" };
@@ -6050,11 +6164,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
@@ -6780,6 +6898,12 @@ export function answerExpression() {
           return Boolean(lastUser.node.compareDocumentPosition(img) & Node.DOCUMENT_POSITION_FOLLOWING);
         });
       })(),
+      // The newer answer renderer, when it cannot draw an answer, puts
+      // div[role=status][data-dil-render-failed] reading "This response
+      // couldn’t load" in its place (measured 2026-10-30, while ChatGPT
+      // held the finished answer), and that sentence was saved as the answer.
+      answerRenderFailed: Boolean(assistant && [assistant.textNode, assistant.node].some((node) =>
+        node && typeof node.querySelector === "function" && node.querySelector("[data-dil-render-failed]"))),
       // 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-pro.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";
@@ -1170,7 +1170,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");
@@ -1236,6 +1239,11 @@ export async function runAskProCommand(rest, io, beforeSend) {
     // --tool turns on a composer tool (deep-research, web-search,
     // create-image, or any label the menu shows) for this send.
     const tools = readRepeatedFlag(parsedAskPro.optionArgs, "--tool");
+    // A tool is opened by its label, so a value that is only spaces names none:
+    // the prompt went out with no tool and nothing said so.
+    if (tools.some((tool) => !tool.trim())) {
+        throw new Error("--tool is blank; name a composer tool (web-search, create-image), or leave the option out.");
+    }
     if (tools.length > 0 && !hasSendMode) {
         throw new Error("--tool only applies when sending (`prodex pro browser ask`); the dry-run preview cannot open ChatGPT's tools menu.");
     }
@@ -1467,11 +1475,11 @@ 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 beforePromptSubmit = (await beforeSend?.({
             store: targetStore,
             ...(normalizedTargetUrl ? { thread: normalizedTargetUrl } : {}),
             ...(continuedFromTaskId ? { continuedFrom: continuedFromTaskId } : {})
-        });
+        })) || undefined;
         const browserCommandOptions = {
             cwd: targetCwd,
             port: parsedAskPro.optionArgs.includes("--port") ? browserPort : undefined
@@ -1550,6 +1558,7 @@ export async function runAskProCommand(rest, io, beforeSend) {
                 proMode: selectionProMode,
                 effort: selectionEffort,
                 ...(allowSelectionFallback ? { allowSelectionFallback: true } : {}),
+                ...(beforePromptSubmit ? { beforePromptSubmit } : {}),
                 onProgress: createBrowserSendProgressPrinter(io.stderr)
             });
         });
@@ -1587,7 +1596,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
@@ -1654,6 +1667,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);
@@ -2031,12 +2046,17 @@ export async function performBrowserConsultForMcp(cwd, input, onProgress) {
             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) {

package/dist/continue-thread.js

@@ -94,9 +94,11 @@ export function threadMatchesProject(threadUrl, project, knownProjectIds) {
     // of them slug to "". The id is the only thing that identifies those, and
     // the caller reads it off the live sidebar.
     const slug = chatGptProjectSlug(project);
-    // The id comes first and the name follows it, so an exact suffix match keeps
-    // "notes" from answering for "notes-archive".
-    if (slug && projectSegment.toLowerCase().endsWith(`-${slug}`))
+    // The segment is "g-p-", the id, a dash and the name, so the name has to be
+    // all that follows the id. A suffix test let "notes" answer for "my-notes";
+    // a prefix test would let it answer for "notes-archive".
+    const named = /^g-p-[0-9a-f]+-(.+)$/i.exec(projectSegment)?.[1]?.toLowerCase();
+    if (slug && named === slug)
         return true;
     // No name in the URL: fall back to the id this project has been seen using.
     // Nothing is guessed - the id came from another record of the same project -

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 }
         : {

package/docs/clients.md

@@ -52,12 +52,17 @@ follow-up checkpoint (integer 0-1000; default 5). For example:
 PRODEX_MAX_AUTO_FOLLOWUPS = "8"
 ```
 
-The initial fresh consult is not a follow-up. Reservations are counted before sends
-and persist across reconnects, older task references, and different session keys in
-the same bridge and conversation. Failed/uncertain attempts count too. At the limit,
+The initial fresh consult is not a follow-up. A follow-up is reserved once its prompt
+is typed, right before it is submitted, and reservations persist across reconnects,
+older task references, and different session keys in the same bridge and
+conversation. A send refused before that point, such as `composer_not_ready`, does
+not count; an attempt that fails or is uncertain after submitting does. At the limit,
 the tool returns `status: "awaiting_user"`, `task_id: null`, the intended continuation
 arguments, and `followup_budget: {limit, used, remaining}` without creating a consult
-task or sending a prompt. This response-only status is not a ledger task status.
+task or sending a prompt. This response-only status is not a ledger task status. If
+another follow-up in the same conversation uses the last of the budget while this one
+waits for the browser, this one stops before submitting with the same response, and
+its consult task is recorded as blocked with `followup_approval_required`.
 
 Ask the user whether to continue. Only after an explicit user request/approval may
 the caller send that continuation with `user_approved: true`. This human-directed

package/docs/releasing.md

@@ -16,6 +16,125 @@ Release target: `v0.40.13` on `main`. The GitHub Release records the resolved co
 
 The release adds a guarded, opt-in transition and more accurate blocker reporting. It does not claim that headless Pro consultation is verified on either deployment target or that authentication can be retained indefinitely.
 
+## 0.40.49 Release Record
+
+Release commit `74b9c4d` on `main` (cut after PRs #79-#83, last merge `be947df`, docs `7b6a3bd`); tag `v0.40.49`, published 2026-11-01. Released on the user's go-ahead as a batch: #79 (the page's render error saved as the answer), #80 (blank `--tool`), #81 (`--continue` matching a project by the end of its name) and #83 (projects behind the sidebar's "Show more"). #82 changed a test only and has no changelog entry.
+
+**Before the cut**
+- `main` CI on `7b6a3bd` (docs only) failed on macOS Intel: `npm test` ran past the release check's 15-minute budget on a slow runner, with no failing test. On the four runs before it that step took 10.5 to 11.8 minutes. The failed job was rerun and passed.
+
+**Publishing**
+- `npm run release:verify` passed on the release commit after a build.
+- `publish.yml` run 41283791768 passed all six platforms, then npm publish with SLSA v1 provenance and the GitHub Release, which lists the four entries from `CHANGELOG.md`.
+
+**Installed**
+- WSL, M3, Mac mini: `prodex --version` reports 0.40.49.
+- The maintainer watchdog checkout was pulled to `74b9c4d` and rebuilt.
+- MacBook M4 (`m4`), added to the install targets this release. It had two copies:
+  - `~/.local/bin/prodex`, which its Codex MCP entry runs directly, links into `~/.gemini/harness-antigravity/runtime-prodex` (an npm project, 0.40.32). It was updated there with `npm i @youdie006/prodex@0.40.49`.
+  - A global copy under `/opt/homebrew` (0.40.0) was updated with `npm i -g --prefix /opt/homebrew`.
+  - The link pointed at `dist/cli.js`, which is not executable in the new install, because the package's executable has been `prodex.mjs` since 0.40.18. Run directly, it failed with "permission denied", so Codex could not have started the MCP server again. The link now points at the runtime's `node_modules/.bin/prodex`. Through it, `--version` reports 0.40.49 and `prodex mcp` answers `initialize` as 0.40.49.
+- Running services were not restarted. They keep the old code until their client starts them again:
+  - M4: Codex's `prodex mcp`, started before the install.
+  - M3: a `prodex mcp` running since 2026-09-15.
+  - Mac mini and WSL: none on the host. WSL's MCP entry goes through the browser container.
+
+**Verified live on installed 0.40.49 (WSL host browser, scratch repo)**
+- `pro browser projects` listed 25 projects; 0.40.48 listed 9 of the same 25.
+- `pro browser smoke` returned `requestVerified: true`.
+
+**After the release**
+- PR #84 (merge `b7b5d61`, unreleased): session ids no longer carry the start of the prompt.
+
+**Container**
+- `container/redesign-patches` `f2d13e6` ports #84 on top of the ports of #79-#83 (`f93b63f`, `661b2c6`, `106bd0a`, `facd4fd`) and the 1024 process limit (`55f2f3e`). tsc, the full suite (2161 tests) and `release:verify` pass on it.
+- The agent's permission classifier refused the WSL `docker compose build`, so the user ran the build-and-swap scripts. Both images were built from `f2d13e6`. Both swaps waited for the container's send lock to be free.
+- M3 (colima `prodex-check`): image `4bc8fac19752`, started 07:57 UTC.
+  - It came up healthy with the 1024 process limit, using 146.
+  - `pro browser check` reported logged in with a composer.
+  - `pro browser smoke` answered `PRODEX_PRO_SMOKE_OK` with its request verified.
+  - A dry-run `pro ask "Draft the payroll memo"` (nothing sent) got the id `sess_20261101_075935_93598ff4`, with no prompt words in it.
+- WSL: image `e2e3523b640a`.
+  - The first run built the image but did not swap, because a Pro consult from another session had held the send lock since 07:54 UTC.
+  - The swap waited for that consult, which finished `done`. The lock cleared at 08:06:32, and the container was recreated at 08:06:35.
+  - It came up healthy with the 1024 process limit, using 177, and logged no thread errors.
+  - `pro browser check`, `smoke` and the dry-run id check gave the same results as on M3 (id `sess_20261101_080804_33e445d8`).
+  - The swap dropped every MCP client of the WSL container, so each WSL Claude Code session needs `/mcp`.
+- Both containers' `prodex --version` still prints 0.40.18, because the container branch never bumps its version.
+
+**MCP clients kept connected across container swaps (2026-11-01, after the swaps)**
+- Both swaps had dropped every MCP client of their container: `scripts/container-client.mjs mcp` piped the client into `docker exec` and ended with it, so each Claude Code session needed `/mcp` typed by hand.
+- `container/redesign-patches` `964b847` turns that command into a relay that reconnects:
+  - it answers requests in flight with an error that names `pro_recover`;
+  - it runs `docker exec` again until the container is back, holding new requests for up to 60 seconds;
+  - it replays the client's handshake, tells the client its tools may have changed, and then passes the held requests on.
+- Verified:
+  - 6 new tests; suite 2167 passed; `release:verify` ok.
+  - On a throwaway container from the same image, one client connection listed 20 tools, survived a restart and then a delete-and-recreate, and listed 20 tools again each time.
+- WSL deployment:
+  - The prodex MCP entries used to run the script from `/mnt/d/myproject/gptprouse`, a checkout another task keeps on its own branch.
+  - Three Claude configs now run it from a checkout pinned for this purpose, `~/.local/share/prodex-maint/container-src` at `964b847`: `~/.claude.json` and the two swapdex slot configs that had the entry.
+  - The Codex config (`~/.codex/config.toml`) was changed the same way.
+  - `claude mcp get prodex` reports Connected. A handshake through it reached the WSL container (server 0.40.18, 20 tools).
+- M3 deployment:
+  - Its Claude and Codex configs run an installed copy, `~/.local/share/prodex/container-installed-8d7a094-wP3RK2/container-client.mjs`.
+  - That file was replaced in place with `964b847`'s; the old one is kept beside it as `container-client.mjs.8d7a094.bak`. The configs are unchanged.
+  - A handshake through it reached the M3 container.
+- Sessions that were open during the swaps still need one `/mcp`. After that, a container restart or swap no longer disconnects them.
+- When `container-client.mjs` changes again, both copies must be updated:
+  - WSL: move the pinned checkout to the new commit;
+  - M3: replace the installed copy.
+
+## Container consults ran on the last model selected (2026-11-01)
+
+**What happened**
+- The user reported that some sessions' consults did not use Pro but whatever model the browser last had.
+- In the WSL container's results, 20 consults since 2026-10-10 carry `model_selection_warning: no model/effort was selected`. Today's 07:54 UTC Pro consult from another session is one of them.
+- Cause: a consult that names no model, with no saved or environment default, keeps the picker's current selection. That is the designed fallback, but in a shared browser the current selection is whatever another session (or an Instant smoke test) picked last.
+  - The container's MCP server had neither default. `container-client.mjs mcp` passed no variables into the container, so an MCP entry's env block could not reach it, and the bridge in the container had no saved config.
+  - The host entries on WSL that run `prodex mcp` directly set `PRODEX_DEFAULT_MODEL=Pro` and were not affected.
+
+**Fixes**
+- `container/redesign-patches` `cd3b671`: `mcp` passes the client's `PRODEX_DEFAULT_MODEL`, `_EFFORT`, `_PRO_MODE` and `_PROJECT` into the container, and adds `PRODEX_DEFAULT_MODEL=Pro` when none of them names a model or a reasoning step. A consult's own `model` or `effort` still wins.
+  - Verified: 3 new tests, suite 2170 passed, `release:verify` ok.
+  - In the container, the resolved defaults went from `null` to `{"model":"Pro"}`.
+  - A consult that named no model, sent through the new client, came back done.
+- Deployed to the WSL pinned checkout (`~/.local/share/prodex-maint/container-src` at `cd3b671`) and to the M3 installed copy.
+- The 16 WSL sessions had reconnected (17:35-17:37 KST) before `cd3b671` was in place, so their relays still run the version without the default.
+  - So the bridge inside each container now saves Pro: `setup --cwd /home/node/bridge --model Pro` on WSL and M3. That writes `.bridge/config.local.json` with a loopback HTTP profile; no HTTP server runs there.
+  - Each consult reads this default, so it applies to connected clients at once. A consult through one of the old relays, naming no model, came back done from Pro.
+- Each such consult carries the warning `model_is_now_an_effort`, because the current picker has Pro as an effort step. The model default is kept because a model or effort the consult names itself overrides it. A saved effort default would be applied on top of a model the consult names.
+
+**M4 and Mac mini (host `prodex mcp`, 2026-11-03)**
+- Neither machine's Claude or Codex entry set `PRODEX_DEFAULT_MODEL`. On M4, `.bridge/results` held one consult of five with the no-model warning (`~/.gemini/harness-antigravity/verification`).
+- M4:
+  - `~/.claude.json` now has `env: {PRODEX_DEFAULT_MODEL: Pro}`, set with `claude mcp remove` and `add-json`.
+  - `~/.codex/config.toml` `[mcp_servers.prodex]` now has `env = { PRODEX_DEFAULT_MODEL = "Pro" }`. A backup is kept as `config.toml.bak-prodex-default-20261103`, and `codex mcp get prodex` parses it.
+  - The three running `prodex mcp` processes keep their old environment until their clients restart them.
+- Mac mini: the same change, made on the user's explicit request after the first attempt was refused:
+  - Claude `~/.claude.json` now carries `env: {PRODEX_DEFAULT_MODEL: Pro}`.
+  - Codex `~/.codex/config.toml` has the same `env` line, with the backup `config.toml.bak-prodex-default-20261103`. `codex mcp get prodex` shows the variable set.
+  - No `prodex mcp` was running there, so the next client start uses it.
+- A WSL Codex session started on 2026-10-28 still runs the client from the old path until it restarts. Its config, `~/.codex/config.toml` (linked from every swapdex slot), already points at the pinned checkout.
+
+## Browser Incident 2026-10-30: WSL browser container out of threads
+
+**What happened**
+- A probe consult through the WSL container (`prodex-browser-browser-1`, branch build reporting 0.40.18) came back `done`, request verified, with the answer "This response couldn’t load". The conversation held the real answer ("OK"). The page had drawn its own error in its place (`div[role=status][data-dil-render-failed]`).
+- Cause: the container allowed 256 processes and threads. Chromium and the service used about 171 with one ChatGPT tab, and 17 stdio MCP servers (16 Claude Code sessions on the host, about 7 threads each) took the rest. Chromium logged `pthread_create: Resource temporarily unavailable` during the send.
+- A reload of that thread while diagnosing it failed the same way, and then `Zygote could not fork`. After that Chromium could start no renderer at all. The tab stayed `browser_tab_crashed`, and prodex's one same-address reload before a send crashed again within 300 ms, so every consult through the container failed.
+- M3's container was checked the same day: 151 of 256 in use, with 1 MCP server and no thread errors in 72 hours.
+
+**Recovery (maintainer approved each step)**
+- `docker update --pids-limit 1024 prodex-browser-browser-1` raised the limit in place. The thread errors stopped, but the browser still could not start renderers.
+- `docker restart prodex-browser-browser-1`, after the container's send lock was confirmed free. The limit stays 1024 across restarts. Health was `healthy` within seconds, `container-client.mjs status` reported `ready: true`, and a fresh-chat consult with markdown in its prompt answered "OK" with its request verified. No thread errors were logged after the restart.
+- The restart dropped every client's MCP connection to the container. Each WSL Claude Code session needs `/mcp` to reconnect.
+
+**Fixes**
+- `main` PR #79 (merge `eab9340`, not yet released): a send no longer saves the page's render error as the answer, and recovery loads the thread again to draw it. It was ported to `container/redesign-patches` as `f93b63f`.
+- `container/redesign-patches` `55f2f3e`: `compose.json` sets `pids_limit` to 1024. The running WSL container already has it through `docker update`. M3's container gets it on its next rebuild.
+- Neither container image has been rebuilt with these commits yet.
+
 ## Browser Incident 2026-10-20: M3 headless browser behind Cloudflare
 
 **What happened**
@@ -35,6 +154,26 @@ The release adds a guarded, opt-in transition and more accurate blocker reportin
 **Open**
 - A long-running headless browser ends up behind Cloudflare's check (also noted on WSL, where the Xvfb display is used instead). On macOS there is no virtual display, and a minimized window counts as hidden, so the remaining no-headless option there is a window kept behind others. Changing the headless preference is a design decision that was not made here.
 
+## 0.40.48 Release Record
+
+Release commit `406ae25` on `main` (cut after PRs #74-#78, last merge `7a88f85`); tag `v0.40.48`. Released on the user's go-ahead, promptly because of #76: on 0.40.47, with the machine under load, the page often ignored the press on the model selector and the send was blocked as "ChatGPT model menu did not open after clicking the selector" (9 of 23 sends across five runs, every one starting from a conversation; also twice the same day without added load). #74 (horizontal rules), #75 (block content inside list items), #77 (inline code holding backticks) and #78 (table column alignment), found comparing live answers with the page, went out with it.
+
+**Publishing**
+- `npm run release:verify` passed on the release commit after a build, with nothing else running on the machine.
+- `publish.yml` run 40819980786 passed all six platforms, then npm publish with SLSA v1 provenance and the GitHub Release, which lists the five entries from `CHANGELOG.md`.
+
+**Installed**
+- WSL, M3, Mac mini: `prodex --version` reports 0.40.48. Running services were not restarted: no host stdio MCP servers on WSL, 1 on M3, none on the Mac mini.
+- The maintainer watchdog checkout was pulled to `406ae25` and rebuilt.
+
+**Container**
+- `container/redesign-patches` `7f1a7b9` ports #74, `e8b970d` #75, `4f1670e` #76, `3b947c7` #77 and `e30e649` #78. That branch recognises the picker only through its trigger, so #76's test case for a stray picker beside a closed trigger is left out there. tsc, build, the full suite (2144 tests) and `release:verify` pass on `e30e649`.
+- The images were not rebuilt: the WSL container still runs the `facbd9d` image (`c03be48c060d`) and the M3 container `cfaf881d2fd6`.
+
+**Verified live on installed 0.40.48 (WSL, scratch repo, Instant)**
+- One answer holding a numbered step with a code block, the inline code ``a`b``, a rule and a table aligned left and right came back as written: the code block indented under its step, ``a`b`` intact, `---`, and `| :--- | ---: |`.
+- Six sends with two test suites running on the machine (load average up to 9.4) all went through; a read-only page watcher showed one of them pressing the model selector twice before its menu opened.
+
 ## 0.40.47 Release Record
 
 Release commit `609b1c9` on `main` (cut after PRs #71-#73, last merge `40d7eee`); tag `v0.40.47`. Released promptly because of #72: on 0.40.46 any prompt carrying a url with "&" (a query string, bare or in a markdown link) was answered and then refused as `request_mismatch`, so the answer was not returned. #71 (italic and strikethrough in the newer renderer) and #73 (the `utm_source=chatgpt.com` parameter ChatGPT appends to rendered links) went out with it.

package/package.json

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