@youdie006/prodex 0.40.3 → 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

@@ -503,6 +503,17 @@ export function isUsableChatGptAnswer(answer) {
         return false;
     return true;
 }
+/**
+ * What comes back when the turn finished and wrote no text.
+ *
+ * Measured with `--tool create-image`: the image was generated and rendered,
+ * the assistant message in the transcript came back finished with an empty
+ * part (the image lives in a separate tool message), and prodex waited out the
+ * whole budget before reporting a timeout for a result that was already there.
+ * The thread URL travels with every answer, so saying so and pointing at it
+ * beats six minutes of silence.
+ */
+export const CHATGPT_NON_TEXT_ANSWER_NOTE = "[no text answer] ChatGPT finished this turn without writing any text - an image or another non-text result. Open the thread to see it.";
 /**
  * Who decides the answer is finished: the transcript, when it can be read.
  *
@@ -520,9 +531,16 @@ export function classifyTranscriptRead(state, sentPrompt) {
         return "unavailable";
     if (state.ok)
         return "answer";
-    return state.reason === "answer_not_finished" || state.reason === "no_assistant_message" || state.reason === "answer_empty"
-        ? "pending"
-        : "unavailable";
+    // A turn that FINISHED with no text is not a turn still being written. The
+    // transcript only reports answer_empty after checking the turn ended, and
+    // calling it "pending" is what made an image request wait out its whole
+    // budget: measured, `--tool create-image` produced the image, its assistant
+    // message came back finished with an empty part, and the send spent six and
+    // a half minutes "stabilizing" before reporting a timeout for an answer that
+    // was sitting in the thread.
+    if (state.reason === "answer_empty")
+        return "no_text";
+    return state.reason === "answer_not_finished" || state.reason === "no_assistant_message" ? "pending" : "unavailable";
 }
 /**
  * Should prodex drag the tab back to the thread it pinned?
@@ -540,8 +558,11 @@ export function shouldRecoverThreadNavigation(args) {
         return false;
     if (!conversationIdFromThreadUrl(pinnedThreadUrl))
         return false;
-    if (lastTranscriptClassification === "pending" || lastTranscriptClassification === "answer")
+    if (lastTranscriptClassification === "pending" ||
+        lastTranscriptClassification === "answer" ||
+        lastTranscriptClassification === "no_text") {
         return false;
+    }
     return !chatGptUrlsReferToSameTarget(currentUrl, pinnedThreadUrl);
 }
 export function hasFreshChatGptAnswer(previousAssistantMessageCount, state) {
@@ -1360,6 +1381,66 @@ async function dispatchEscapeKey(cdp) {
  * stamp is what proves the old document is gone; the URL alone can be read off
  * the very page we are trying to leave.
  */
+/**
+ * Put the tab on a specific conversation, for a thread prodex itself resolved.
+ */
+async function openChatGptThread(cdp, url) {
+    const conversationId = conversationIdFromThreadUrl(url);
+    if (!conversationId)
+        throw new Error(`Not a ChatGPT conversation URL: ${url}`);
+    await cdp.evaluate(`location.assign(${JSON.stringify(url)})`);
+    const deadline = Date.now() + RELOAD_SETTLE_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await sleep(250);
+        try {
+            if (await cdp.evaluate(chatGptThreadReadyExpression(conversationId)))
+                return;
+        }
+        catch (error) {
+            // Between documents the context is gone and the next poll lands on the
+            // new one; a command timeout means the tab stopped answering.
+            if (cdpCommandTimedOut(error))
+                throw error;
+        }
+    }
+    throw new ChatGptBrowserBlockerError(chatGptThreadUnavailableBlocker(url));
+}
+/**
+ * The conversation a follow-up names cannot be opened.
+ *
+ * Retrying cannot undelete a thread, and the generic "resolve the visible
+ * browser issue manually" this used to fall back to describes a browser that
+ * is working fine - measured on a thread whose project had been deleted: the
+ * 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",
+        message: `ChatGPT did not open the conversation to continue (${url}). It may have been deleted, or its project was.`,
+        retryable: false,
+        next_step: "That conversation cannot be reached, and retrying will not bring it back. Send without --continue to start a new one, " +
+            "or name a different consult with --continue-task <task_id> (`prodex pro list` shows them).",
+        thread: url
+    };
+}
 async function openFreshChatGptHome(cdp) {
     await cdp.evaluate(markDocumentForReloadExpression());
     await cdp.evaluate(`location.assign("https://chatgpt.com/")`);
@@ -1641,6 +1722,20 @@ export function reloadedDocumentReadyExpression(extraCondition = "true") {
  * home that fails to load, and the composer candidate is the real editor
  * rather than the broad selector that also matches a hidden fallback.
  */
+/**
+ * True once the tab is on this conversation and has rendered a real composer.
+ *
+ * The id is compared rather than the whole URL because ChatGPT rewrites the
+ * project part of it (measured: the same project appears with and without its
+ * name), and the composer has to be the real editor rather than the hidden 0x0
+ * fallback that the broad selector also matches.
+ */
+export function chatGptThreadReadyExpression(conversationId) {
+    return `(() => {${composerExpressionHelpers()}
+    if (!location.href.includes(${JSON.stringify(conversationId)})) return false;
+    return Boolean(findChatGptComposerCandidate());
+  })()`;
+}
 export function freshChatGptHomeReadyExpression() {
     return reloadedDocumentReadyExpression(`/^https:\\/\\/chatgpt\\.com\\/?(?:[?#].*)?$/.test(location.href) && (() => {${composerExpressionHelpers()}
     return Boolean(findChatGptComposerCandidate());
@@ -1757,9 +1852,13 @@ export function composerProjectBinding(input) {
     const named = /^new\s+chat\s+in\s+(.+)$/i.exec(placeholder)?.[1] ?? /^(.+?)\uc5d0\uc11c\s*\uc0c8\s*\ucc44\ud305$/.exec(placeholder)?.[1];
     if (named)
         return named.trim().toLowerCase() === wanted ? "bound" : "elsewhere";
-    // The placeholder a plain new chat carries: recognised, and it names no
-    // project, so the composer belongs to none.
-    if (/^ask\s+chatgpt$/i.test(placeholder))
+    // The label a plain new chat carries: recognised, and it names no project, so
+    // the composer belongs to none. Two wordings measured on the same live root -
+    // the hidden fallback textarea says "Ask ChatGPT" while the editor prodex
+    // actually reads says "Chat with ChatGPT" - and reading only the first left
+    // the clearest case of "this composer is not the project's" reported as a
+    // label that could not be read.
+    if (/^(?:ask|chat with)\s+chatgpt$/i.test(placeholder))
         return "elsewhere";
     return "unknown";
 }
@@ -2379,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)
@@ -2390,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
@@ -3046,7 +3152,7 @@ async function readTranscriptAnswer(page, conversationId, sentPrompt) {
     const answer = resolveTranscriptCitations(transcript.text, transcript.references).trim();
     return answer.length > 0
         ? { classification: "answer", answer: { answer, modelSlug: transcript.modelSlug } }
-        : { classification: "pending" };
+        : { classification: "no_text" };
 }
 // A page that has not reported the prompt posting within this long is worth
 // double-checking against the transcript; the probe is a couple of small fetches.
@@ -3086,7 +3192,10 @@ export async function sendChatGptPrompt(options) {
     if (options.newChat && normalizedTargetUrl) {
         throw new Error("newChat cannot be combined with targetUrl: a fresh chat navigates away from the pinned tab.");
     }
-    const pageResult = await findChatGptPage(port, computePageDiscoveryTimeout(timeoutMs), normalizedTargetUrl);
+    // A resolved thread is reached by navigating, so page discovery must not
+    // demand a tab already sitting on it.
+    const requireTabAtTargetUrl = options.navigateToTargetUrl ? undefined : normalizedTargetUrl;
+    const pageResult = await findChatGptPage(port, computePageDiscoveryTimeout(timeoutMs), requireTabAtTargetUrl);
     if (!pageResult.ok) {
         throwBlockerOrError(pageResult.blocker, "ChatGPT browser page is not available");
     }
@@ -3094,8 +3203,8 @@ export async function sendChatGptPrompt(options) {
         if (pageResult.blocker) {
             throw new ChatGptBrowserBlockerError(pageResult.blocker);
         }
-        if (normalizedTargetUrl) {
-            assertChatGptTargetTabAvailable(normalizedTargetUrl);
+        if (requireTabAtTargetUrl) {
+            assertChatGptTargetTabAvailable(requireTabAtTargetUrl);
         }
         assertChatGptPageAvailable();
     }
@@ -3242,14 +3351,21 @@ export async function sendChatGptPrompt(options) {
         awaitingResponseChoice: status.awaitingResponseChoice === true,
         ...(options.newChat !== undefined ? { newChat: options.newChat } : {}),
         ...(options.project !== undefined ? { project: options.project } : {}),
-        ...(options.projectNew !== undefined ? { projectNew: options.projectNew } : {})
+        ...(options.projectNew !== undefined ? { projectNew: options.projectNew } : {}),
+        // Navigating to another conversation leaves the parked one alone, the
+        // same way a fresh chat or a project home does.
+        ...(options.navigateToTargetUrl ? { newChat: true } : {})
     })) {
         throw new ChatGptBrowserBlockerError(chatGptResponseChoiceBlocker(true));
     }
     assertChatGptIdleAndReadyForPrompt(status, busyBlocker, true);
-    if (normalizedTargetUrl)
-        assertChatGptTargetUrlMatches(status.url, normalizedTargetUrl);
-    assertVisibleChatGptTab(status.visibilityState, status.url, normalizedTargetUrl);
+    // Only a PINNED target has to be under the tab already; a resolved thread is
+    // navigated to below, and asserting the match here would refuse the send for
+    // the tab merely being somewhere else - which is the whole reason a
+    // continuation resolves from records rather than from the tab.
+    if (requireTabAtTargetUrl)
+        assertChatGptTargetUrlMatches(status.url, requireTabAtTargetUrl);
+    assertVisibleChatGptTab(status.visibilityState, status.url, requireTabAtTargetUrl);
     emitProgress("tab_ready");
     // Progress details deliberately avoid project names (receipts redact them too).
     const selectionSummary = [
@@ -3315,6 +3431,9 @@ export async function sendChatGptPrompt(options) {
         // keeps Work's composer, and switching afterwards does not move it.
         // Max and Ultra are rungs of Work's slider, so asking for one means staying
         // there; anything else belongs on Chat, whose top step is Pro.
+        if (normalizedTargetUrl && options.navigateToTargetUrl) {
+            await openChatGptThread(cdp, normalizedTargetUrl);
+        }
         if (!effortNeedsWorkSurface(options.effort)) {
             // Leaving the current page is safe only for a send that was going to
             // navigate anyway; a continuation or a pinned tab has to be reloaded
@@ -3440,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();
@@ -3635,6 +3754,13 @@ export async function sendChatGptPrompt(options) {
                 lastTranscriptClassification = transcript.classification;
                 if (transcript.answer)
                     return transcriptResult(transcript.answer);
+                // A finished turn with no text is an answer of a different shape - an
+                // image, measured - and waiting for words it will never write spends
+                // the whole budget and then calls the result a timeout. The page must
+                // agree it has stopped generating before this counts.
+                if (transcript.classification === "no_text") {
+                    return transcriptResult({ answer: CHATGPT_NON_TEXT_ANSWER_NOTE, modelSlug: "" });
+                }
             }
             if (shouldRecoverThreadNavigation({ pinnedThreadUrl, currentUrl: finalState?.url, lastTranscriptClassification })) {
                 if (recoveredNavigations >= 2) {
@@ -4354,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);
 }
@@ -4901,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);
@@ -4924,8 +5105,11 @@ export function activeComposerToolsExpression(labels) {
     // selection did not take.
     const el = document.querySelector('#prompt-textarea,[contenteditable="true"]');
     const form = el ? (el.closest("form") || el.parentElement) : null;
-    const text = (el ? el.innerText || "" : "") + String.fromCharCode(10) + (form ? form.innerText || "" : "");
-    return { ok: true, active: ${labelsJson}.filter((label) => text.includes(label)) };
+    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.
+    return { ok: true, active: ${labelsJson}.filter((label) => text.includes(String(label).toLowerCase())) };
   })()`;
 }
 export function composerTextStateExpression(expectedText, toolLabels = []) {

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)
@@ -1313,6 +1328,9 @@ export async function runAskProCommand(rest, io) {
             port: browserPort,
             prompt: bundle.sendText,
             targetUrl: normalizedTargetUrl,
+            // A thread prodex resolved from its own records is reached by
+            // navigating; a --target-url the person confirmed is not moved.
+            ...(continuedFromTaskId ? { navigateToTargetUrl: true } : {}),
             timeoutMs: browserTimeoutMs,
             ...(attachments.length > 0 ? { attachments } : {}),
             ...(tools.length > 0 ? { tools } : {}),
@@ -1366,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),
@@ -1376,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,
@@ -1395,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 }));
         }
@@ -1432,6 +1466,13 @@ export async function runAskProCommand(rest, io) {
             io.stderr(warning);
         if (consult.modelSlug)
             io.stderr(`model_used: ${consult.modelSlug}`);
+        // Which conversation this followed, and where the answer actually landed.
+        // The progress line that says it is filtered out of MCP notes, so an
+        // agent asking for a follow-up had no way to know which thread it got -
+        // or whether the answer is in the project it asked for.
+        if (continuedFromTaskId)
+            io.stderr(`continued_from: ${continuedFromTaskId}`);
+        io.stderr(`destination: ${destination.destination}${destination.verified === undefined ? "" : ` verified=${destination.verified}`}`);
         // "Can I count this as a Pro review?" - answered here rather than left
         // for whoever reads the receipt to work out from two other fields.
         const proVerified = proSelectionVerified({
@@ -1500,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
                 }
             });
@@ -1525,6 +1569,11 @@ export async function runAskProCommand(rest, io) {
                 status: result.status,
                 thread: consult.url,
                 answer: result.summary,
+                ...(continuedFromTaskId ? { continued_from: continuedFromTaskId } : {}),
+                destination: {
+                    observed: destination.destination,
+                    ...(destination.verified !== undefined ? { verified: destination.verified } : {})
+                },
                 warnings: persistenceWarnings
             }, null, 2));
         }
@@ -1626,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 = [];
@@ -1652,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 {
@@ -1940,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" &&
@@ -2017,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.
@@ -2102,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);
@@ -2109,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/config.js

@@ -252,8 +252,13 @@ export async function loadBrowserDefaults(cwd) {
         // stop applying with nothing said, so a consult that should have landed in
         // a project lands in the general chat and looks like it worked.
         if (!isMissingFileError(error)) {
+            // Say only what is true. Passing the flags explicitly does NOT get past
+            // this - the config is read before any of them are looked at - and
+            // advice that does not work is worse than none. Moving the file aside
+            // does work: a repo with no config has no defaults and sends fine.
             throw new Error(`${error instanceof Error ? error.message : String(error)} Until then prodex will not apply the browser defaults ` +
-                `pinned there (project, model), so pass them explicitly if you need to send before fixing it.`, { cause: error });
+                `pinned there (project, model), and every send from this repo stops here. Move .bridge/config.local.json aside ` +
+                `if this repo does not need the HTTP MCP surface.`, { cause: error });
         }
         repo = undefined;
     }

package/dist/continue-thread.js

@@ -28,6 +28,50 @@ export function chatGptProjectSlug(name) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
+/**
+ * Whether a recorded URL is a conversation someone can go back to.
+ *
+ * Not everything prodex records as a "thread" is one. Measured across this
+ * machine's records: six of them are `https://chatgpt.com/?temporary-chat=true`
+ * - a temporary chat is never saved, so returning to that URL opens a fresh
+ * empty one. Continuing into it would look like a follow-up and be a new
+ * conversation with none of the context, which is the failure --continue
+ * exists to remove rather than reproduce.
+ */
+export function isChatGptConversationUrl(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.
+ *
+ * Some thread URLs carry the project name after its id and some carry only the
+ * id (measured: three of this machine's hundred-odd records). The named ones
+ * teach the mapping, so the bare ones can still be recognised instead of being
+ * invisible to every follow-up - which would quietly continue an OLDER
+ * conversation while the newest one sat unmatched.
+ */
+export function projectIdsByName(threadUrls) {
+    const byName = new Map();
+    for (const url of threadUrls) {
+        const match = /\/g\/g-p-([0-9a-f]+)-([^/?#]+)/i.exec(url);
+        if (!match)
+            continue;
+        const name = match[2].toLowerCase();
+        const ids = byName.get(name) ?? new Set();
+        ids.add(match[1].toLowerCase());
+        byName.set(name, ids);
+    }
+    return byName;
+}
 /**
  * Whether a recorded thread belongs to the project this send is for.
  *
@@ -35,18 +79,46 @@ export function chatGptProjectSlug(name) {
  * so a follow-up meant for the general chat cannot walk into a project - and a
  * project's follow-up cannot land in another project's conversation.
  */
-export function threadMatchesProject(threadUrl, project) {
+export function threadMatchesProject(threadUrl, project, knownProjectIds) {
     const projectSegment = /\/g\/(g-p-[^/?#]+)/.exec(threadUrl)?.[1];
     if (!project)
         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);
-    if (!slug)
-        return false;
     // The id comes first and the name follows it, so an exact suffix match keeps
     // "notes" from answering for "notes-archive".
-    return projectSegment.toLowerCase().endsWith(`-${slug}`);
+    if (slug && projectSegment.toLowerCase().endsWith(`-${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 -
+    // and it survives a rename, which the name comparison cannot.
+    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.
@@ -57,9 +129,16 @@ export function threadMatchesProject(threadUrl, project) {
  * the conversation is the failure this exists to prevent.
  */
 export function resolveContinuationThread(input) {
-    const withThread = input.consults.filter((consult) => Boolean(consult.thread));
+    const withThread = input.consults.filter((consult) => consult.thread && isChatGptConversationUrl(consult.thread));
     if (input.taskId) {
         const named = withThread.find((consult) => consult.taskId === input.taskId);
+        const recordedButUnusable = !named && input.consults.some((consult) => consult.taskId === input.taskId);
+        if (recordedButUnusable) {
+            return {
+                error: `Consult "${input.taskId}" has no conversation to continue - it was a temporary chat, or it never reached one. ` +
+                    `A temporary chat is never saved, so there is nothing to go back to.`
+            };
+        }
         if (!named) {
             return {
                 error: `No recorded consult thread for "${input.taskId}". List what is here with \`prodex pro list\`, ` +
@@ -68,9 +147,12 @@ export function resolveContinuationThread(input) {
         }
         return { target: { taskId: named.taskId, thread: named.thread } };
     }
+    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))
+        .filter((consult) => threadMatchesProject(consult.thread, input.project, knownProjectIds))
         .sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
     const latest = candidates[0];
     if (!latest) {

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.3",
+  "version": "0.40.5",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",