@youdie006/prodex 0.40.4 → 0.40.5

package/dist/blocker-report.js

@@ -12,7 +12,7 @@
  * reports "the catch-all is biggest" and names nothing to fix - measured, one
  * of them held 165 of 267 blockers - so their message decides the group.
  */
-const CATCH_ALL_CODES = new Set(["browser_send_failed", "consult_failed", "unknown_error"]);
+export const CATCH_ALL_CODES = new Set(["browser_send_failed", "consult_failed", "unknown_error"]);
 /**
  * The part of a message that identifies the failure, with the varying parts
  * removed: the same picker failure is written once with "Pro" and once with a

package/dist/bundle.js

@@ -1,6 +1,37 @@
 import { randomUUID } from "node:crypto";
 import { makeBridgeId, nowIso, SCHEMA_VERSION } from "./schema.js";
 import { readRepoFile } from "./repo.js";
+/**
+ * Whether a file prodex was asked to INLINE is text at all.
+ *
+ * `--file` puts a file's text into the prompt and `--attach` uploads the file
+ * itself; pointing `--file` at a binary used to inline the bytes. Measured:
+ * `--file` on an executable produced a prompt carrying an ELF header and NUL
+ * bytes inside a text fence - 535 control bytes in a 798-byte preview - which
+ * costs tokens, answers nothing, and sends control characters through the
+ * composer and the prompt-identity check.
+ *
+ * A NUL byte is the classic test and the one that never false-positives on
+ * real source; a high share of other control bytes catches the rest without
+ * tripping on text that merely has tabs and newlines.
+ */
+export function looksLikeBinaryFileContent(content) {
+    if (content.includes("\u0000"))
+        return true;
+    const sample = content.slice(0, 4096);
+    if (sample.length === 0)
+        return false;
+    let control = 0;
+    for (const ch of sample) {
+        const code = ch.codePointAt(0) ?? 0;
+        // Tab, newline and carriage return are ordinary text.
+        if (code === 9 || code === 10 || code === 13)
+            continue;
+        if (code < 32 || code === 0xfffd)
+            control += 1;
+    }
+    return control / sample.length > 0.1;
+}
 export async function buildDryRunBundle(root, input) {
     const sections = [
         "# prodex consult dry run",
@@ -16,6 +47,10 @@ export async function buildDryRunBundle(root, input) {
     const sendSections = [input.prompt.trim()];
     for (const file of input.files) {
         const content = await readRepoFile(root, file, { maxLines: 500 });
+        if (looksLikeBinaryFileContent(content.content)) {
+            throw new Error(`--file ${file} is not a text file, and --file inlines a file's TEXT into the prompt. ` +
+                `Upload it instead: --attach ${file}.`);
+        }
         files.push({ path: file, role: "context", bytes: Buffer.byteLength(content.content, "utf8") });
         const fileSection = ["", `## File: ${file}`, "", "```text", content.content, "```"];
         sections.push(...fileSection);

package/dist/chatgpt-browser.js

@@ -1414,6 +1414,23 @@ async function openChatGptThread(cdp, url) {
  * cause was named in the message and then thrown away by the catch-all next
  * step underneath it.
  */
+/**
+ * The composer's model selector never rendered.
+ *
+ * Always transient in the field: the composer is still being built, which is
+ * why the poll above exists at all. The catch-all it used to fall into said
+ * "resolve the visible browser issue manually" - there is no issue to resolve,
+ * and the next send usually works.
+ */
+export function chatGptComposerNotReadyBlocker(reason) {
+    return {
+        code: "composer_not_ready",
+        message: `ChatGPT's composer did not finish rendering its model selector${reason ? ` (${reason})` : ""}, so the model could not be chosen.`,
+        retryable: true,
+        next_step: "Nothing was sent. Retry - the composer is usually a moment behind a page that has just navigated, and a send right " +
+            "after another one lands on it mid-render."
+    };
+}
 export function chatGptThreadUnavailableBlocker(url) {
     return {
         code: "thread_unavailable",
@@ -2461,8 +2478,15 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
     // new-chat navigation the composer form (and the selector inside it) has not
     // finished rendering yet, so a single check throws "model selector button not
     // found" even though the button appears a moment later.
+    //
+    // Four seconds was not enough for the case this browser exists for: two
+    // agents sending one after the other. Measured - a send that started two
+    // seconds behind another, queued on the lock, and entered a page the first
+    // one had only just finished with, failed here once in three attempts while
+    // the same pattern succeeded either side of it. The neighbouring waits for
+    // the same kind of render already allow six to eight.
     let button = { ok: false };
-    const buttonDeadline = Date.now() + 4_000;
+    const buttonDeadline = Date.now() + PROJECT_NAVIGATION_TIMEOUT_MS;
     for (;;) {
         button = await cdp.evaluate(modelButtonRectExpression());
         if (button.ok && button.x !== undefined && button.y !== undefined)
@@ -2472,7 +2496,7 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
         await sleep(200);
     }
     if (!button.ok || button.x === undefined || button.y === undefined) {
-        throw new Error(button.reason ?? "Could not open the ChatGPT model selector");
+        throw new ChatGptBrowserBlockerError(chatGptComposerNotReadyBlocker(button.reason));
     }
     // Skip the menu entirely when the picker already shows the requested model:
     // it is the same end state, and it survives ChatGPT reshuffling the menu
@@ -3535,7 +3559,7 @@ export async function sendChatGptPrompt(options) {
         // looks the way it looked when it refused, and the selection failures this
         // project keeps hitting are invisible in the error text alone.
         await captureOnFailure(`send-${new Date().toISOString().replace(/[:.]/g, "-")}`);
-        throw error;
+        throw attachSendWarnings(error, sendWarnings);
     }
     finally {
         cdp.close();
@@ -4456,6 +4480,39 @@ export function portAccepts(port, timeoutMs = 250) {
 }
 /** True when a fetch failed because its AbortSignal.timeout fired, not because nothing was listening. */
 /** Whether an error is a DevTools command that got no answer in time - the one failure that has closed the socket. */
+/**
+ * Carry the warnings a failed send collected out with its error.
+ *
+ * They are attached to the RESULT, so a send that throws loses them - and the
+ * one that explains the failure is exactly the kind that gets lost: a send
+ * that had to move off ChatGPT's Work surface, or that recovered a browser,
+ * and then died at the next step reported nothing about either. The error
+ * already carries `thread` this way and the classifier already reads it off,
+ * so this follows the same road.
+ */
+export function attachSendWarnings(error, warnings) {
+    if (warnings.length === 0)
+        return error;
+    if (typeof error !== "object" || error === null)
+        return error;
+    const carrier = error;
+    if (Array.isArray(carrier.warnings))
+        return error;
+    try {
+        carrier.warnings = [...warnings];
+    }
+    catch {
+        // A frozen error is still the error; the warnings are a bonus, not a duty.
+    }
+    return error;
+}
+/** The warnings a failed send carried out with it, if any survived. */
+export function sendWarningsFromError(error) {
+    if (typeof error !== "object" || error === null)
+        return [];
+    const carried = error.warnings;
+    return Array.isArray(carried) ? carried.filter((entry) => typeof entry === "string") : [];
+}
 export function cdpCommandTimedOut(error) {
     return error instanceof Error && /Chrome DevTools command timed out/.test(error.message);
 }
@@ -5003,11 +5060,33 @@ export function composerToolsButtonRectExpression() {
   })()`;
 }
 /** Click point for a tools-menu entry, matched by its visible label. */
+/**
+ * Where a tool's name must NOT be taken from.
+ *
+ * The lookup searches the document for the tool's name, because the menu this
+ * ChatGPT build renders is not reachable by any container selector that was
+ * tried - it carries no menu role, no aria-controls, and no floating popover
+ * node. That search is fine until the sidebar holds a CHAT titled like a tool:
+ * measured, the first `--tool create-image` send of an account succeeds and
+ * leaves a conversation called "Create Image", and every send after it matched
+ * that chat row, clicked it, navigated to the old conversation, and then
+ * reported that the composer never showed the tool as active.
+ *
+ * Scoping the search to an open menu instead looked right and broke every tool
+ * - web-search included, which had just been measured working - because
+ * nothing matched the container. Excluding the places a tool name can only be
+ * a coincidence keeps the search that works and removes the match that lies.
+ */
+const COMPOSER_TOOL_LOOKUP_EXCLUDED_ANCESTORS = 'nav,aside,[role="navigation"],[data-sidebar-item],[data-testid="conversation-turn"],[data-message-author-role]';
 export function composerToolEntryRectExpression(label) {
     const candidatesJson = JSON.stringify(composerToolMenuTexts(label).map((text) => text.toLowerCase()));
+    const excludedJson = JSON.stringify(COMPOSER_TOOL_LOOKUP_EXCLUDED_ANCESTORS);
     return `(() => {${CLICK_POINT_SNIPPET}
     const candidates = ${candidatesJson};
-    const leaves = [...document.querySelectorAll("div,span,button,a")].filter((el) => el.children.length === 0);
+    const excluded = ${excludedJson};
+    const leaves = [...document.querySelectorAll("div,span,button,a")].filter(
+      (el) => el.children.length === 0 && !el.closest(excluded)
+    );
     const leaf = leaves.find((el) => candidates.includes((el.textContent || "").trim().toLowerCase()));
     if (!leaf) {
       const available = [...new Set(leaves.map((el) => (el.textContent || "").trim()).filter((t) => t.length > 1 && t.length < 30))].slice(0, 20);
@@ -5029,9 +5108,7 @@ export function activeComposerToolsExpression(labels) {
     const text = ((el ? el.innerText || "" : "") + String.fromCharCode(10) + (form ? form.innerText || "" : "")).toLowerCase();
     // Case-insensitively: prodex carries the label as the menu spells it
     // ("Create image") while the page has been measured using "Create Image"
-    // for the same tool. This is hardening, not a fix for a failure anyone has
-    // seen - the create-image activation failure measured on this account
-    // survives it, and its cause is still open.
+    // for the same tool.
     return { ok: true, active: ${labelsJson}.filter((label) => text.includes(String(label).toLowerCase())) };
   })()`;
 }

package/dist/cli-help.js

@@ -89,7 +89,7 @@ Optional visible-browser send defaults (applied by \`pro browser ask\` when the
   --model      Composer model by its exact menu label. Only Pro applies on the current picker: it is a slider step, and the model rows cannot be clicked
   --pro-mode   Pro sub-mode: 기본 (standard) or 확장 (extended)
   --effort     Reasoning effort: 즉시 / 중간 / 높음 / 매우 높음 / Max / Ultra / Pro. Max and Ultra are rungs of ChatGPT's Work surface and only apply when the browser is already on Work (prodex does not switch to Work for them); every other value is sent on Chat, whose top step is Pro
-  --allow-model-fallback  Send even when the requested model/effort could not be applied. Off by default: a send that could not reach what was asked for stops instead, because an answer from a step nobody asked for is usually unusable
+  --allow-model-fallback  Send even when the requested EFFORT step could not be applied. Off by default: a send that could not reach the step it asked for stops instead, because an answer from a step nobody asked for is usually unusable. It does not gate the model axis - this picker's model rows cannot be driven at all, so a model it will not provide is always a warning and the send goes out on whatever the composer had; model_used and pro_verified say what actually replied
   --project    Sidebar project to enter before sending
 Clear a saved default with --clear-model / --clear-pro-mode / --clear-effort / --clear-project.
 --pro-mode and --effort are different model axes and cannot be combined. View saved defaults with \`prodex status\`.`);

package/dist/cli-pro.js

@@ -2,7 +2,7 @@ import { existsSync, statSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { buildDryRunBundle } from "./bundle.js";
-import { 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, resolveVirtualDisplayPreference, resolveBrowserWindowMode, resolveHeadlessPreference, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt, statusMeansBrowserDead, namesPro, destinationVerification, chatGptProjectIdFromUrl } from "./chatgpt-browser.js";
+import { 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, resolveVirtualDisplayPreference, resolveBrowserWindowMode, resolveHeadlessPreference, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt, statusMeansBrowserDead, namesPro, sendWarningsFromError, destinationVerification, chatGptProjectIdFromUrl } 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 } from "./cli-args.js";
 import { printProBrowserHelp, printProHelp } from "./cli-help.js";
 import { listRawResultsForInspection, listTasksForInspection } from "./cli-ledger.js";
@@ -10,8 +10,8 @@ import { formatBrowserDefaults, redactServerUrl } from "./cli-server.js";
 import { errorMessage, firstLine, formatBlockedConsultRecordedMessage, formatProLatestCommand, formatBrowserCheckCommand, formatBrowserLoginCommand, formatBrowserSmokeCommand, formatBrowserTargetAskCommand, formatInitCommand, formatSetupCommand, isMissingFileError, computeSendPacingWaitMs, isUntrustedResultError, resolveMinSendIntervalMs, sourceAwareBrowserBlocker, sourceAwareBrowserNextStep, sourceAwareResultError, sourceAwareResultMessage, sourceAwareSetupMessage } from "./cli-shared.js";
 import { getTokenExpiryStatus, loadBrowserDefaults, loadLocalConfig } from "./config.js";
 import { withBrowserSendLock } from "./browser-send-lock.js";
-import { blockerCause, buildBlockerReport } from "./blocker-report.js";
-import { resolveContinuationThread } from "./continue-thread.js";
+import { blockerCause, buildBlockerReport, CATCH_ALL_CODES } from "./blocker-report.js";
+import { projectIdFromSidebar, resolveContinuationThread } from "./continue-thread.js";
 import { readBridgeRoots } from "./registry.js";
 import { BridgeStore, MAX_FETCHABLE_RESULT_ARTIFACT_BYTES } from "./store.js";
 import { CLI_VERSION } from "./cli-help.js";
@@ -759,7 +759,7 @@ export async function runProCommand(rest, io, runCliFn) {
                     consults.push({
                         repo: path.basename(root),
                         createdAt: result.created_at,
-                        ...(result.blocker ? { blocker: { code: result.blocker.code, message: result.blocker.message } } : {})
+                        ...(result.blocker ? { blocker: reclassifyRecordedBlocker(result.blocker) } : {})
                     });
                 }
             }
@@ -1129,6 +1129,20 @@ export async function runAskProCommand(rest, io) {
         // Scope by the project this send would have used, so a follow-up cannot
         // land in another project's conversation.
         const continuationProject = explicitProject ?? (suppressProject ? undefined : browserDefaults?.project);
+        // The name alone cannot identify a project written in another script -
+        // measured, two of this account's projects slug to nothing - so the id
+        // is read off the live sidebar. A sidebar that cannot be read leaves
+        // the name matching to do what it can; the send would fail on the same
+        // browser anyway.
+        let continuationProjectId;
+        if (continuationProject) {
+            try {
+                continuationProjectId = projectIdFromSidebar(await listChatGptProjectsWithIds({ port: resolveCdpPort(readPortFlag(parsedAskPro.optionArgs, "--port")) }), continuationProject);
+            }
+            catch {
+                continuationProjectId = undefined;
+            }
+        }
         const resolved = resolveContinuationThread({
             consults: (await targetStore.listSessionsReadOnly()).map((session) => ({
                 taskId: session.task_id ?? "",
@@ -1137,6 +1151,7 @@ export async function runAskProCommand(rest, io) {
                 ...(session.created_at ? { createdAt: session.created_at } : {})
             })),
             ...(continuationProject ? { project: continuationProject } : {}),
+            ...(continuationProjectId ? { projectId: continuationProjectId } : {}),
             ...(continueTaskId !== undefined ? { taskId: continueTaskId } : {})
         });
         if ("error" in resolved)
@@ -1369,6 +1384,12 @@ export async function runAskProCommand(rest, io) {
             // --new-chat there is no target url, and a blocker that started a run
             // still has a thread worth handing back.
             const blockedThread = blocker.thread ?? normalizedTargetUrl;
+            // What the send had already noticed before it died. These used to go
+            // out with the result, so a failure dropped them - including the note
+            // that would explain it, like having just moved off the Work surface.
+            const blockedWarnings = sendWarningsFromError(error).map(redactProject);
+            for (const warning of blockedWarnings)
+                io.stderr(warning);
             const persistedBlocker = {
                 ...blocker,
                 message: redactProject(blocker.message),
@@ -1379,7 +1400,17 @@ export async function runAskProCommand(rest, io) {
                     status: "blocked",
                     summary: redactProject(message),
                     commands: ["visible ChatGPT browser consult"],
-                    blocker: persistedBlocker
+                    warnings: blockedWarnings,
+                    blocker: persistedBlocker,
+                    // What was asked for, on the record that failed. Without it a
+                    // timeout cannot be read back against the budget it was given.
+                    provenance: {
+                        ...(blockedThread ? { thread: blockedThread } : {}),
+                        ...(Object.keys(selectionMetadata).length > 0
+                            ? { selection: redactSelectionForRecord(selectionMetadata, redactProject) }
+                            : {}),
+                        warnings: blockedWarnings
+                    }
                 });
                 await writeSessionBestEffort(targetStore, {
                     id: bundle.id,
@@ -1398,7 +1429,7 @@ export async function runAskProCommand(rest, io) {
             // Keep stdout machine-parseable for --json consumers on the blocked
             // path too; the human-readable error still goes to stderr via throw.
             if (jsonOutput) {
-                io.stdout(JSON.stringify({ task_id: task.id, status: "blocked", thread: blockedThread ?? null, answer: null, warnings: [], blocker }, null, 2));
+                io.stdout(JSON.stringify({ task_id: task.id, status: "blocked", thread: blockedThread ?? null, answer: null, warnings: blockedWarnings, blocker }, null, 2));
             }
             throw new Error(formatBlockedConsultRecordedMessage(message, task.id, sourceCli, { cwd: targetCwd }));
         }
@@ -1510,6 +1541,9 @@ export async function runAskProCommand(rest, io) {
                 warnings: persistenceWarnings,
                 provenance: {
                     thread: consult.url,
+                    ...(Object.keys(selectionMetadata).length > 0
+                        ? { selection: redactSelectionForRecord(selectionMetadata, redactProjectNamesForRecord(selectionMetadata)) }
+                        : {}),
                     warnings: persistenceWarnings
                 }
             });
@@ -1641,6 +1675,30 @@ export async function performBrowserRecoverForMcp(cwd, input) {
         notes: stderrLines
     };
 }
+/** The marker the send prints before throwing, when the answer outlived its record. */
+const ANSWER_NOT_SAVED_MARKER = "consult_answer_received_but_not_saved:";
+/**
+ * Pull an answer out of a send that got one and then failed to record it.
+ *
+ * The CLI prints `consult_answer_received_but_not_saved: <task> <thread>`,
+ * a blank line, and the answer, then throws - so a person still has the text.
+ * An agent calling through MCP only saw the throw, which discarded exactly the
+ * answer that was most expensive to get.
+ */
+export function answerRescuedFromFailedPersistence(stdoutLines) {
+    const index = stdoutLines.findIndex((line) => line.startsWith(ANSWER_NOT_SAVED_MARKER));
+    if (index === -1)
+        return undefined;
+    const [taskId = "", thread = ""] = stdoutLines[index].slice(ANSWER_NOT_SAVED_MARKER.length).trim().split(/\s+/);
+    const answer = stdoutLines
+        .slice(index + 1)
+        .join("\n")
+        .replace(/^\n+/, "")
+        .trim();
+    if (!answer)
+        return undefined;
+    return { taskId, thread, answer };
+}
 export async function performBrowserConsultForMcp(cwd, input, onProgress) {
     const stdoutLines = [];
     const stderrLines = [];
@@ -1667,16 +1725,38 @@ export async function performBrowserConsultForMcp(cwd, input, onProgress) {
         "--",
         input.prompt
     ];
-    await runAskProCommand(argv, {
-        cwd,
-        stdout: (line) => stdoutLines.push(line),
-        stderr: (line) => {
-            stderrLines.push(line);
-            if (onProgress && line.startsWith("progress:"))
-                onProgress(line);
-        },
-        allowAskProBrowserSend: true
-    });
+    try {
+        await runAskProCommand(argv, {
+            cwd,
+            stdout: (line) => stdoutLines.push(line),
+            stderr: (line) => {
+                stderrLines.push(line);
+                if (onProgress && line.startsWith("progress:"))
+                    onProgress(line);
+            },
+            allowAskProBrowserSend: true
+        });
+    }
+    catch (error) {
+        // A send whose ANSWER arrived and whose recording then failed prints the
+        // answer and throws, so the CLI caller still has it. Rethrowing here threw
+        // it away instead - the one case where that costs the most, since the
+        // answer is usually a Pro run someone waited minutes for. Hand it back
+        // with the failure attached rather than losing it.
+        const rescued = answerRescuedFromFailedPersistence(stdoutLines);
+        if (!rescued)
+            throw error;
+        return {
+            task_id: rescued.taskId,
+            status: "answered_not_saved",
+            thread: rescued.thread,
+            answer: rescued.answer,
+            notes: [
+                ...stderrLines.filter((line) => !line.startsWith("progress:")),
+                `answer_not_saved: ${errorMessage(error)}`
+            ]
+        };
+    }
     const header = stdoutLines[0] ?? "";
     const [taskId = "", status = "", thread = ""] = header.split("\t");
     return {
@@ -1955,6 +2035,35 @@ export function redactProjectNames(text, names) {
     }
     return redacted;
 }
+/** The project name is scrubbed in records; the rest of a selection is not. */
+export function redactSelectionForRecord(selection, redact) {
+    const recorded = {};
+    for (const [key, value] of Object.entries(selection)) {
+        recorded[key] = key === "project" || key === "project_new" ? redact(value) : value;
+    }
+    return recorded;
+}
+/** The redactor a record needs when it has only the selection to go on. */
+function redactProjectNamesForRecord(selection) {
+    return (text) => redactProjectNames(text, [selection.project, selection.project_new]);
+}
+/**
+ * A recorded blocker, read with what the classifier knows NOW.
+ *
+ * Records keep the code they were written with. Most of the failures that
+ * recur were the catch-all when they were recorded - 178 of 296 in this
+ * machine's ledger - and only got their own codes afterwards, so a report
+ * grouped by the recorded code kept showing "browser_send_failed: ..." rows
+ * for causes that have names. Re-reading the message through the classifier
+ * names them; a message it still cannot place keeps its recorded code, and a
+ * record that was never the catch-all is left exactly as written.
+ */
+export function reclassifyRecordedBlocker(recorded) {
+    if (!CATCH_ALL_CODES.has(recorded.code))
+        return { code: recorded.code, message: recorded.message };
+    const live = browserSendBlockerFromError(new Error(recorded.message));
+    return { code: CATCH_ALL_CODES.has(live.code) ? recorded.code : live.code, message: recorded.message };
+}
 export function browserSendBlockerFromError(error) {
     const blocker = typeof error === "object" && error !== null && "blocker" in error ? error.blocker : undefined;
     if (typeof blocker === "object" &&
@@ -2032,6 +2141,100 @@ export function browserSendBlockerFromError(error) {
             next_step: "Nothing was sent, so nothing landed in the wrong project. Retry - the composer normally binds on the next navigation - or open the project once in the visible browser and send again."
         };
     }
+    // Everything below came out of the ledger rather than out of the code: 178
+    // of 296 recorded blockers were the catch-all, and replaying their messages
+    // through this function showed 109 still landing there - each one told to
+    // "resolve the visible browser issue manually", which is advice for a
+    // problem nobody has. These are the recurring ones that are still reachable,
+    // in the order they actually happen.
+    //
+    // All of them fail BEFORE the prompt is submitted: the selection steps and
+    // the post-insertion check all run ahead of the send, so "nothing was sent"
+    // is a fact here and not a hope.
+    if (/Refusing to click/.test(message)) {
+        return {
+            code: "click_blocked",
+            message,
+            retryable: true,
+            next_step: "Something on the page was sitting over the control prodex needed, so nothing was sent. Retry - these covers are " +
+                "usually a banner or a menu that goes away on its own - or clear it in the visible browser."
+        };
+    }
+    if (/Composer text did not match the prompt after insertion|Composer stayed empty after text insertion/.test(message)) {
+        return {
+            code: "composer_text_mismatch",
+            message,
+            retryable: true,
+            next_step: "The composer did not end up holding the prompt, so nothing was sent. Clear whatever is in it in the visible " +
+                "browser and retry, or send into a fresh chat with --new-chat."
+        };
+    }
+    if (/did not finish accepting .* within the upload budget/.test(message)) {
+        return {
+            code: "attachment_upload_timeout",
+            message,
+            retryable: true,
+            next_step: "ChatGPT was still ingesting the attachment when the budget ran out, so nothing was sent. Retry with a longer " +
+                "--timeout-ms, or inline a text file with --file instead of uploading it."
+        };
+    }
+    if (/composer tools menu has no "/.test(message)) {
+        return {
+            code: "tool_not_offered",
+            message,
+            // The menu was read and the tool is not in it; asking again reads the
+            // same menu.
+            retryable: false,
+            next_step: "Nothing was sent. This account's composer does not offer that tool - drop --tool and ask for the same thing in the prompt."
+        };
+    }
+    if (/model selector button not found|did not expose its power slider|Could not open the ChatGPT model selector|model menu is not open|power slider not found/.test(message)) {
+        return {
+            code: "composer_not_ready",
+            message,
+            retryable: true,
+            next_step: "The composer had not finished rendering its picker, so nothing was sent. Retry - it is usually a moment behind " +
+                "a page that has just navigated, and a send right after another one lands on it mid-render."
+        };
+    }
+    if (/but the composer never showed it as active/.test(message)) {
+        return {
+            code: "tool_not_applied",
+            message,
+            retryable: true,
+            next_step: "The composer tool was chosen but never turned on, so nothing was sent. Retry, or drop --tool and ask for the " +
+                "same thing in the prompt."
+        };
+    }
+    if (/ChatGPT project not found in sidebar/.test(message)) {
+        return {
+            code: "project_not_found",
+            message,
+            // prodex already waits for the sidebar to hydrate before saying this, so
+            // the name is genuinely not there; asking again asks the same sidebar.
+            retryable: false,
+            next_step: "Nothing was sent. The sidebar has no project by that name - list the exact spellings with " +
+                "`prodex pro browser projects`, then pass one of those, or send without --project."
+        };
+    }
+    if (/Clicking project "[^"]*" did not navigate/.test(message)) {
+        return {
+            code: "project_navigation_failed",
+            message,
+            retryable: true,
+            next_step: "The sidebar click did not move the tab into the project, so nothing was sent. Retry, or open the project once " +
+                "in the visible browser and send again."
+        };
+    }
+    if (/Pro option not found in the model menu/.test(message)) {
+        return {
+            code: "selection_not_applied",
+            message,
+            retryable: false,
+            next_step: "Nothing was sent. This account's picker does not offer Pro as a menu option - ask for it on the effort axis " +
+                "with `--effort Pro`, or send without a model and check `model_used` in the answer."
+        };
+    }
     // The picker could not provide the step that was asked for. Retrying asks
     // the same picker the same question, so this is not retryable; the caller
     // either picks a step it offers or opts into whatever the slider is on.
@@ -2117,6 +2320,15 @@ async function recordedModelUsed(store, taskId) {
         return undefined;
     }
 }
+/** One line naming the model, effort and project a send asked for, or nothing. */
+export function formatAskedFor(selection) {
+    if (!selection)
+        return undefined;
+    const parts = ["model", "pro_mode", "effort", "project", "project_new"]
+        .filter((key) => selection[key])
+        .map((key) => `${key}=${selection[key]}`);
+    return parts.length > 0 ? `asked_for: ${parts.join(" ")}` : undefined;
+}
 export function formatProAnswer(consult, sourceCli, options = {}) {
     const blocker = sourceAwareProAnswerBlocker(consult, sourceCli, options);
     const summary = sourceAwareProAnswerSummary(consult.result.summary, consult.result.blocker, blocker);
@@ -2124,6 +2336,10 @@ export function formatProAnswer(consult, sourceCli, options = {}) {
         `task_id: ${consult.task.id}`,
         `status: ${consult.result.status}`,
         consult.task.provenance.thread ? `thread: ${consult.task.provenance.thread}` : undefined,
+        // What the send asked for. Recorded on failures as well as answers now,
+        // and a person reading a timeout needs it on the same screen as the
+        // budget it used up.
+        formatAskedFor(consult.task.provenance.selection),
         `created_at: ${consult.result.created_at}`,
         "",
         summary

package/dist/cli.js

@@ -289,6 +289,33 @@ export async function runCli(args, io = defaultIo()) {
     }
     throw unknownTopLevelCommandError(command);
 }
+/**
+ * Whether something other than prodex is sitting on the configured port.
+ *
+ * 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.
+ */
+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)
+        });
+    }
+    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;
+    }
+    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 {
         // PRODEX_CWD wins over a working directory prodex cannot use (a /dev/fd
@@ -1020,6 +1047,14 @@ async function runDoctor(store, io, sourceCli, setupHintCwd) {
             const warningLine = formatConfigWarningLine(tokenStatus, sourceCli, setupHintCwd);
             if (warningLine)
                 io.stdout(warningLine);
+            // "ok" has to mean the configured endpoint can actually be served.
+            // 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);
+            if (portHolder) {
+                io.stdout(`config_warning: ${portHolder} \`${formatSetupCommand(sourceCli, { cwd: setupHintCwd })} --port <free port>\` moves prodex off it.`);
+            }
         }
     }
     catch (error) {
@@ -1082,7 +1117,9 @@ async function runHttpMcpCatalogSmoke() {
             cwd,
             host: "127.0.0.1",
             port: 0,
-            token: "doctor-token"
+            token: "doctor-token",
+            // A smoke bridge in a temp directory is not a place anyone works.
+            registerRoot: false
         });
         client = new Client({ name: "prodex-doctor", version: CLI_VERSION });
         await withTimeout(client.connect(new StreamableHTTPClientTransport(new URL(running.mcp_url))), 20_000, "timed out connecting to HTTP MCP server");
@@ -1353,7 +1390,7 @@ async function runMcpWriteSmoke() {
         await execFileAsync("git", ["commit", "-m", "initial"], { cwd });
         const { stdout: headOut } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd });
         const head = headOut.trim();
-        const handlers = createMcpToolHandlers({ cwd });
+        const handlers = createMcpToolHandlers({ cwd, registerRoot: false });
         const dryRun = await handlers.repo_write_file_dry_run({
             path: "notes.md",
             content: "new\n",

package/dist/continue-thread.js

@@ -39,7 +39,16 @@ export function chatGptProjectSlug(name) {
  * exists to remove rather than reproduce.
  */
 export function isChatGptConversationUrl(threadUrl) {
-    return /\/c\/[^/?#]+/.test(threadUrl);
+    const id = /\/c\/([^/?#]+)/.exec(threadUrl)?.[1];
+    if (!id)
+        return false;
+    // ChatGPT shows a provisional id - measured as "/c/WEB:<uuid>" - between the
+    // prompt posting and the server naming the conversation. It is not a
+    // conversation anyone can return to, and the id parser elsewhere already
+    // refuses it; accepting it here would let a follow-up pick a thread that
+    // then fails to open with an error about the URL rather than about the
+    // conversation.
+    return !/^web:/i.test(id);
 }
 /**
  * The project ids these recorded threads have been seen using, by project name.
@@ -76,6 +85,11 @@ export function threadMatchesProject(threadUrl, project, knownProjectIds) {
         return projectSegment === undefined;
     if (!projectSegment)
         return false;
+    // The slug is the name with everything but ASCII letters and digits turned
+    // to dashes, which for a name written in another script is nothing at all:
+    // measured, four of this account's five projects have Korean names and two
+    // 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".
@@ -87,6 +101,25 @@ export function threadMatchesProject(threadUrl, project, knownProjectIds) {
     const id = /^g-p-([0-9a-f]+)/i.exec(projectSegment)?.[1]?.toLowerCase();
     return Boolean(id && knownProjectIds?.has(id));
 }
+/**
+ * The id of the project a name refers to, from the sidebar as it is now.
+ *
+ * Same rules as the sidebar click: the exact name first, then a
+ * case-insensitive match when it is the only one - never a guess between two.
+ * The id comes back without its "g-p-" prefix, which is how thread URLs are
+ * read everywhere else here.
+ */
+export function projectIdFromSidebar(projects, name) {
+    const wanted = name.trim();
+    const strip = (id) => id.replace(/^g-p-/i, "").toLowerCase();
+    const exact = projects.filter((project) => project.name.trim() === wanted);
+    if (exact.length === 1)
+        return strip(exact[0].id);
+    if (exact.length > 1)
+        return undefined;
+    const loose = projects.filter((project) => project.name.trim().toLowerCase() === wanted.toLowerCase());
+    return loose.length === 1 ? strip(loose[0].id) : undefined;
+}
 /**
  * The thread a follow-up should continue, or why it cannot be resolved.
  *
@@ -114,9 +147,9 @@ export function resolveContinuationThread(input) {
         }
         return { target: { taskId: named.taskId, thread: named.thread } };
     }
-    const knownProjectIds = input.project
-        ? projectIdsByName(withThread.map((consult) => consult.thread)).get(chatGptProjectSlug(input.project))
-        : undefined;
+    const knownProjectIds = new Set(input.project ? projectIdsByName(withThread.map((consult) => consult.thread)).get(chatGptProjectSlug(input.project)) ?? [] : []);
+    if (input.projectId)
+        knownProjectIds.add(input.projectId.toLowerCase());
     const candidates = withThread
         .filter((consult) => consult.status === "done")
         .filter((consult) => threadMatchesProject(consult.thread, input.project, knownProjectIds))

package/dist/http-mcp.js

@@ -32,7 +32,7 @@ export async function startHttpMcpServer(options) {
                 return;
             }
             if (req.method === "POST") {
-                await handlePost(req, res, transports, options.cwd, requestBodyLimitBytes);
+                await handlePost(req, res, transports, options.cwd, requestBodyLimitBytes, options.registerRoot);
                 return;
             }
             if (req.method === "GET" || req.method === "DELETE") {
@@ -51,10 +51,23 @@ export async function startHttpMcpServer(options) {
             }
         }
     });
+    const requestedPort = options.port ?? 8787;
     await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(options.port ?? 8787, host, () => {
-            server.off("error", reject);
+        server.once("error", (error) => {
+            // "address already in use" names neither who has it nor how to move.
+            // Measured here: prodex's default port was held by an unrelated tool of
+            // the user's, and the only thing said was the raw errno - on a machine
+            // where the fix is one flag.
+            if (error.code === "EADDRINUSE") {
+                reject(new Error(`Port ${requestedPort} on ${host} is already taken, so the HTTP MCP server did not start. ` +
+                    `Another prodex may already be running here - check with \`prodex status\` - or another program holds it ` +
+                    `(\`ss -ltnp | grep ${requestedPort}\` says which). Move prodex with \`prodex setup --port <free port>\`, then start again.`, { cause: error }));
+                return;
+            }
+            reject(error);
+        });
+        server.listen(requestedPort, host, () => {
+            server.removeAllListeners("error");
             resolve();
         });
     });
@@ -118,7 +131,7 @@ async function withTimeout(promise, timeoutMs, message) {
             clearTimeout(timeout);
     }
 }
-async function handlePost(req, res, transports, cwd, requestBodyLimitBytes) {
+async function handlePost(req, res, transports, cwd, requestBodyLimitBytes, registerRoot) {
     const body = await readJsonBody(req, requestBodyLimitBytes);
     const sessionId = headerValue(req.headers["mcp-session-id"]);
     if (sessionId) {
@@ -145,7 +158,11 @@ async function handlePost(req, res, transports, cwd, requestBodyLimitBytes) {
             if (id)
                 transports.delete(id);
         };
-        const mcpServer = createMcpServer(cwd, { source: "chatgpt_project", claimedBy: "chatgpt" });
+        const mcpServer = createMcpServer(cwd, {
+            source: "chatgpt_project",
+            claimedBy: "chatgpt",
+            ...(registerRoot !== undefined ? { registerRoot } : {})
+        });
         await mcpServer.connect(transport);
         await transport.handleRequest(req, res, body);
         return;

package/dist/mcp-tools.js

@@ -40,7 +40,9 @@ function redactTaskForMcp(task) {
     return { ...task, provenance: redactedProvenance };
 }
 export function createMcpToolHandlers(context) {
-    const store = new BridgeStore(context.cwd);
+    const store = new BridgeStore(context.cwd, {
+        ...(context.registerRoot !== undefined ? { registerRoot: context.registerRoot } : {})
+    });
     const source = context.source ?? "claude";
     const claimedBy = context.claimedBy ?? source;
     return {

package/dist/mcp.js

@@ -51,7 +51,12 @@ function serverVersionNotice() {
 }
 export function createServer(cwd = process.cwd(), options = {}) {
     const server = new McpServer({ name: "prodex", version: mcpPackageJson.version ?? "0.0.0" });
-    const handlers = createMcpToolHandlers({ cwd, source: options.source, claimedBy: options.claimedBy });
+    const handlers = createMcpToolHandlers({
+        cwd,
+        source: options.source,
+        claimedBy: options.claimedBy,
+        ...(options.registerRoot !== undefined ? { registerRoot: options.registerRoot } : {})
+    });
     server.registerTool("bridge_create_task", {
         description: "Create a durable task for Codex/local execution in .bridge/tasks.",
         inputSchema: {
@@ -201,7 +206,7 @@ export function createServer(cwd = process.cwd(), options = {}) {
                 allow_model_fallback: z
                     .boolean()
                     .optional()
-                    .describe("Send even when the requested model or effort could not be applied. Off by default, because an answer from a step nobody asked for is usually unusable: a consult asking for Pro that comes back from a lesser model cannot be cited as a Pro review. Pass true only when any answer beats no answer.")
+                    .describe("Send even when the requested EFFORT step could not be applied. Off by default, because an answer from a step nobody asked for is usually unusable: a consult asking for Pro that comes back from a lesser model cannot be cited as a Pro review. Pass true only when any answer beats no answer. It does not gate the model axis: this picker's model rows cannot be driven at all, so a model it will not provide is always a warning and the send goes out on whatever the composer had - check `model_used` and `pro_verified` in the answer to see what actually replied.")
             }
         }, async (input, extra) => {
             // Bridge send progress to MCP progress notifications, but only when

package/dist/schema.js

@@ -23,6 +23,14 @@ export const ProvenanceSchema = z.object({
     session_id: z.string().optional(),
     thread: z.string().optional(),
     project: z.string().optional(),
+    /**
+     * What the send asked for - model, effort, project. Recorded on failures as
+     * well as answers: 57 timeouts in this machine's ledger carry no selection
+     * at all, because it was only ever written into the ANSWER receipt, so the
+     * ledger cannot say whether a Pro run times out more often than a quick one
+     * - which is the first question anyone asks of a timeout.
+     */
+    selection: z.record(z.string()).optional(),
     warnings: z.array(z.string()).default([])
 });
 export const BridgeFileSchema = z.object({

package/dist/store.js

@@ -66,9 +66,17 @@ const READ_ALL_CONCURRENCY = 32;
 export class BridgeStore {
     root;
     bridgeDir;
-    constructor(root = process.cwd()) {
+    registerRoot;
+    /**
+     * `registerRoot: false` keeps this bridge out of the machine-wide registry.
+     * For throwaway roots prodex makes for itself - doctor's smoke checks build
+     * a bridge in a temp directory, delete it, and left a dead entry in the
+     * user's registry on every run.
+     */
+    constructor(root = process.cwd(), options = {}) {
         this.root = root;
         this.bridgeDir = path.join(root, ".bridge");
+        this.registerRoot = options.registerRoot !== false;
     }
     async ensure() {
         await assertUsableBridgeRoot(this.root);
@@ -85,7 +93,8 @@ export class BridgeStore {
         await this.ensureReceiptIntegrityKey();
         // Advisory: let local indexers (sessionwiki's prodex adapter) find this
         // bridge. Best-effort inside - a registry failure never breaks the bridge.
-        await registerBridgeRoot(this.root);
+        if (this.registerRoot)
+            await registerBridgeRoot(this.root);
     }
     dir(kind) {
         return path.join(this.bridgeDir, kind);

package/package.json

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