@youdie006/prodex 0.40.2 → 0.40.3

package/dist/blocker-report.js

@@ -53,8 +53,14 @@ export function buildBlockerReport(input) {
         const existing = groups.get(key);
         if (existing) {
             existing.count += 1;
-            if (at > existing.lastSeen)
+            // The example belongs to the record the row dates itself by. Keeping the
+            // first one seen printed a cause's oldest wording next to its newest
+            // timestamp: a group holding both `has no "Pro" step` and a pre-fix
+            // `has no "<a model>" step` showed the fixed one as what is failing now.
+            if (at > existing.lastSeen) {
                 existing.lastSeen = at;
+                existing.example = consult.blocker.message;
+            }
             existing.repos.set(consult.repo, (existing.repos.get(consult.repo) ?? 0) + 1);
         }
         else {

package/dist/browser-send-lock.js

@@ -1,4 +1,4 @@
-import { link, mkdir, open, readFile, rm } from "node:fs/promises";
+import { link, mkdir, open, readFile, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 // One visible-browser send at a time per machine: the dedicated Chrome is a
@@ -91,6 +91,15 @@ async function tryAcquire(file) {
         await rm(temp, { force: true }).catch(() => undefined);
     }
 }
+async function lockFileExists(file) {
+    try {
+        await stat(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Serialize visible-browser sends across processes. Waits up to waitMs for a
  * live holder to finish (0 = fail fast); a lock whose holder process is dead
@@ -112,6 +121,17 @@ export async function withBrowserSendLock(waitMs, onWait, fn) {
             if (current?.pid === holder?.pid) {
                 await rm(file, { force: true }).catch(() => undefined);
             }
+            // A reap that did not actually remove the file - another user's lock in a
+            // shared directory, or a directory sitting in its place - used to retry
+            // immediately, skipping both the sleep and the deadline: a hot loop that
+            // never returned and never timed out. Waiting here costs a reap that
+            // raced nothing; not waiting costs the process.
+            if (await lockFileExists(file)) {
+                if (Date.now() >= deadline) {
+                    throw new Error(`A prodex browser send lock at ${file} is held by nothing and could not be removed, so no send can start. Delete that file and retry.`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, 2_000));
+            }
             continue;
         }
         if (Date.now() >= deadline) {

package/dist/chatgpt-browser.js

@@ -437,17 +437,29 @@ export function resolveHeadlessPreference(explicit, env = process.env) {
     const raw = (env.PRODEX_HEADLESS ?? "").trim().toLowerCase();
     return raw === "1" || raw === "true" || raw === "yes";
 }
-export function inferLoggedInLikely(text, visibleButtonLabels = []) {
+/**
+ * The two verdicts read different text on purpose.
+ *
+ * `text` answers "is this a login screen": it has to be the sample with chat
+ * MESSAGES excluded, or an old conversation quoting a signup page reports the
+ * session as logged out.
+ *
+ * `loggedInSignalText` answers "is the app here": the sidebar furniture, which
+ * survives in whichever sample happened to keep it. Measured live, that is not
+ * always the filtered one - on a project home the filter left 111 characters
+ * of a banner while document.body.innerText held the whole sidebar.
+ */
+export function inferLoggedInLikely(text, visibleButtonLabels = [], loggedInSignalText = text) {
     // Only sign-up prompts and explicit login/sign-up buttons count as logged-out signals. Bare
     // "Log in"/"로그인" substrings appear in the menus and footers of a logged-in page, so matching
     // them against the full page text falsely reported logged-in Pro users as logged out.
     const hasLoginPrompt = text.includes("Sign up for free") ||
         text.includes("무료로 가입") ||
         visibleButtonLabels.some((label) => /^(log in|sign up|로그인|회원가입)$/i.test(label.trim()));
-    const hasNewChat = text.includes("New chat") || text.includes("새 채팅");
-    const hasProjectNav = text.includes("Projects") || text.includes("프로젝트");
+    const hasNewChat = loggedInSignalText.includes("New chat") || loggedInSignalText.includes("새 채팅");
+    const hasProjectNav = loggedInSignalText.includes("Projects") || loggedInSignalText.includes("프로젝트");
     const hasProfileButton = visibleButtonLabels.some((label) => /profile|account|프로필|계정/i.test(label));
-    const hasPlanHint = /\bPro\b|Plus|Team|Enterprise|매우 높음|Extra High/i.test(text);
+    const hasPlanHint = /\bPro\b|Plus|Team|Enterprise|매우 높음|Extra High/i.test(loggedInSignalText);
     return !hasLoginPrompt && hasNewChat && (hasProfileButton || hasProjectNav || hasPlanHint);
 }
 export function isUsableChatGptAnswer(answer) {
@@ -842,9 +854,23 @@ export function detectChatGptPageBlocker(state) {
     return detectChatGptBlocker(state.blockerScanTextSample ?? state.blockerTextSample ?? state.textSample, state.visibleButtonLabels);
 }
 export function inferChatGptPageLoggedInLikely(state) {
-    // Login detection uses the nav-INCLUDED sample: "New chat"/"Projects"/plan
-    // hints live in the sidebar and are the primary logged-in signal.
-    return inferLoggedInLikely(state.blockerTextSample ?? state.textSample, state.visibleButtonLabels);
+    // The logged-in signals live in the sidebar - "New chat", "Projects", the
+    // plan hint - so this needs the sample that HAS the sidebar in it. That was
+    // meant to be blockerTextSample, and measured live on a project home it is
+    // not: its text walk keeps only nodes whose own parent has a box, and what
+    // survived there was 111 characters of a promotional banner while
+    // document.body.innerText carried the whole sidebar. So a logged-in Pro
+    // account on a working page was told to go and log in.
+    //
+    // The logged-OUT question keeps the message-excluded sample, so a chat
+    // quoting a signup page cannot report the session as dead. The logged-IN
+    // question reads both, because the sidebar turns up in whichever one kept
+    // it - and being wrong in that direction is caught at once by the composer
+    // check beside it, while being wrong the other way tells someone with a
+    // working browser to go and log in.
+    const messageExcluded = state.blockerTextSample ?? state.textSample;
+    const anySample = [state.textSample, state.blockerTextSample].filter(Boolean).join(String.fromCharCode(10));
+    return inferLoggedInLikely(messageExcluded, state.visibleButtonLabels, anySample);
 }
 function hasLikelyChatGptLoginPrompt(haystack) {
     const hasSpecificSignup = /sign up for free|무료로 가입/i.test(haystack);
@@ -1893,11 +1919,18 @@ export function projectItemRectExpression(name) {
     }
     let target = opt ? (opt.closest('a,[role="link"],li') || opt.parentElement) : null;
     if (!target) {
+      // The fallback for a sidebar whose option buttons this cannot read. It
+      // used to take the first row CONTAINING the name, which is the substring
+      // match the exact comparison above exists to prevent: asking for "Codex"
+      // took "Codex Review" and sent the prompt into a project nobody named.
+      // A row's first line is its name; anything else here is a guess, and a
+      // guess about which project to post into is the failure being fixed.
       const icons = [...document.querySelectorAll('[data-testid="project-folder-icon"]')];
-      for (const ic of icons) {
-        const row = ic.closest('a,li,[role="link"]') || ic.parentElement?.parentElement;
-        if (row && (row.textContent || "").includes(wanted)) { target = row; break; }
-      }
+      const rowName = (row) => ((row.innerText || row.textContent || "").split("\\n").map((line) => line.trim()).find((line) => line.length > 0) || "");
+      const rows = icons.map((ic) => ic.closest('a,li,[role="link"]') || ic.parentElement?.parentElement).filter(Boolean);
+      const named = rows.filter((row) => rowName(row).toLowerCase() === wanted.toLowerCase());
+      if (named.length > 1) return { ok: false, reason: "project name matches multiple sidebar projects; rename one to disambiguate" };
+      if (named.length === 1) target = named[0];
     }
     if (!target) {
       return { ok: false, reason: "project not found in sidebar (" + optionButtons.length + " projects visible; names are matched exactly first, then case-insensitively - check the exact sidebar spelling)" };
@@ -2093,6 +2126,21 @@ async function selectPickerModel(cdp, requested, warnings = []) {
  * without this the step that follows reported "the picker did not expose its
  * power slider" on a picker that was simply shut.
  */
+/**
+ * How to apply the stored Chat-surface preference on a page that renders no
+ * surface toggle at all.
+ *
+ * Reloading in place is the only option for a send that has to stay where it
+ * is - a pinned thread, a continuation. On a project home it is the wrong one:
+ * a hard load of one comes back as ChatGPT's error page (measured on two
+ * projects), which leaves the send on a document with no sidebar, and the
+ * project step then reports the project missing from a sidebar that was never
+ * drawn. A send that is going to navigate anyway takes the root, which loads.
+ */
+export function chatSurfaceRecoveryPlan(input) {
+    const onProjectPage = /^https:\/\/chatgpt\.com\/g\/g-p-/.test(input.href);
+    return input.mayLeaveCurrentPage && onProjectPage ? "fresh-root" : "reload";
+}
 /**
  * Put the browser back on ChatGPT's Chat surface when it has drifted onto Work.
  *
@@ -2100,7 +2148,7 @@ async function selectPickerModel(cdp, requested, warnings = []) {
  * the page announces which one is live, so a drifted browser silently drives
  * the wrong picker. Returns a warning to carry to the caller when it moved.
  */
-async function ensureChatSurface(cdp) {
+async function ensureChatSurface(cdp, options) {
     const read = async () => {
         try {
             return await cdp.evaluate(chatSurfaceProbeExpression());
@@ -2158,8 +2206,23 @@ async function ensureChatSurface(cdp) {
     try {
         await cdp.evaluate(selectChatSurfaceExpression());
         // Reading the persisted value back right after writing it proves nothing;
-        // the reloaded document rendering its composer is what proves the switch.
-        if ((await reloadAndAwaitComposer(cdp, RELOAD_SETTLE_TIMEOUT_MS)) && (await confirm()))
+        // the new document rendering its composer is what proves the switch.
+        const plan = chatSurfaceRecoveryPlan({
+            href: await cdp.evaluate("location.href"),
+            mayLeaveCurrentPage: options.mayLeaveCurrentPage
+        });
+        let applied;
+        if (plan === "fresh-root") {
+            // Throws when the root never rendered a composer, which the catch below
+            // turns into the same "could not be switched back" warning as a reload
+            // that never settled.
+            await openFreshChatGptHome(cdp);
+            applied = true;
+        }
+        else {
+            applied = await reloadAndAwaitComposer(cdp, RELOAD_SETTLE_TIMEOUT_MS);
+        }
+        if (applied && (await confirm()))
             return note;
     }
     catch (error) {
@@ -2601,11 +2664,27 @@ async function createChatGptProject(cdp, name) {
     }
 }
 /** The placeholder of the composer the send will actually type into. */
-function composerProjectBindingExpression() {
+/**
+ * Read the label the composer carries, wherever it keeps it.
+ *
+ * Measured live on a project home: the editor prodex types into is the
+ * contenteditable div, and it carries the label ONLY as `aria-label` -
+ * `data-placeholder` is null on it. The 0x0 textarea beside it does carry
+ * `placeholder`, but the composer finder rejects that one on size, exactly as
+ * it should. Reading a single attribute meant the label was there and prodex
+ * could not see it, so every project send refused with "the placeholder could
+ * not be read" - the fail-closed branch doing its job on a page that was fine.
+ */
+export function composerProjectBindingExpression() {
     return `(() => {${composerExpressionHelpers()}
     const node = findChatGptComposerCandidate();
     if (!node) return { found: false };
-    return { found: true, placeholder: node.getAttribute("data-placeholder") || node.getAttribute("placeholder") || "" };
+    const label =
+      node.getAttribute("data-placeholder") ||
+      node.getAttribute("placeholder") ||
+      node.getAttribute("aria-label") ||
+      "";
+    return { found: true, placeholder: label };
   })()`;
 }
 /**
@@ -2620,9 +2699,20 @@ async function waitForComposerProjectBinding(cdp, project, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     let verdict = "unknown";
     for (;;) {
-        const read = await cdp
-            .evaluate(composerProjectBindingExpression())
-            .catch(() => ({ found: false }));
+        let read;
+        try {
+            read = await cdp.evaluate(composerProjectBindingExpression());
+        }
+        catch (error) {
+            // A read that lands between documents answers about neither, and the next
+            // poll lands on the new one. A command timeout is a different thing: the
+            // tab stopped answering, and swallowing it spent this whole budget and
+            // the recovery's before refusing with "the placeholder could not be
+            // read" - a binding failure reported for a browser that was gone.
+            if (cdpCommandTimedOut(error))
+                throw error;
+            read = { found: false };
+        }
         if (read.found) {
             const sample = composerProjectBinding({
                 ...(read.placeholder !== undefined ? { placeholder: read.placeholder } : {}),
@@ -2691,6 +2781,35 @@ async function navigateToExistingProject(cdp, project) {
         }
     }
 }
+/**
+ * The refusal to post into a project prodex cannot confirm, as a blocker.
+ *
+ * It used to be a plain Error whose English prose a regex in the CLI matched to
+ * recover the code - so the difference between "the composer belongs elsewhere"
+ * and "the browser stopped answering" survived only as a sentence, and a
+ * reworded message would have quietly become an unclassified send failure. The
+ * wording still carries the phrase the classifier keys on, because older
+ * senders and other paths still reach it as text.
+ *
+ * The project it OFFERED instead is deliberately absent: naming it would put
+ * another project's name in a persisted record, which redaction covers only for
+ * the ones this send asked for.
+ */
+export function projectNotBoundBlocker(input) {
+    const detail = input.reason === "elsewhere"
+        ? "after entering it, the composer still offers a chat that belongs somewhere else"
+        : input.reason === "unknown"
+            ? "after entering it, the composer's placeholder could not be read, so where the prompt would land is unknown"
+            : "it read as this project's after entering it and no longer does";
+    return {
+        code: "project_not_bound",
+        message: `ChatGPT composer did not bind to project "${input.project}": ${detail}, so nothing was sent.` +
+            (input.recoveryNote ?? ""),
+        retryable: true,
+        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."
+    };
+}
 /**
  * The project name the composer has to agree with before anything is typed,
  * or undefined for a send that pins no project.
@@ -2715,11 +2834,18 @@ export function composerBindingTarget(options) {
 async function selectProject(cdp, options) {
     const wanted = composerBindingTarget(options);
     if (!wanted)
-        return;
+        return undefined;
     if (options.projectNew)
         await createChatGptProject(cdp, options.projectNew);
-    else
+    // Clicking the sidebar row when the composer already belongs to this project
+    // is work that can only fail. Measured: a send into the project the tab was
+    // already sitting in refused with "another element covers its click point" -
+    // a promotional banner over the sidebar - on a page that was ready to accept
+    // the prompt. The read below is the same evidence the gate accepts, so a
+    // composer that already answers with this project needs no navigation.
+    else if ((await waitForComposerProjectBinding(cdp, options.project, 0)) !== "bound") {
         await navigateToExistingProject(cdp, options.project);
+    }
     // A sidebar SPA navigation moves the URL to the target project while the
     // composer can stay bound to the PREVIOUS project's conversation target, so
     // the send silently creates the thread in the OLD project (reproduced live
@@ -2766,20 +2892,17 @@ async function selectProject(cdp, options) {
         // read is not evidence that the composer is this project's, and what it
         // guards against - a prompt posted into another project, recorded under
         // the requested one - costs far more than a send the caller can retry.
-        //
-        // Naming the project it offered instead would put ANOTHER project's name
-        // in a persisted receipt, which redaction only covers for the requested
-        // one, so say what happened and leave that name out.
-        const detail = binding === "elsewhere"
-            ? "the composer still offers a chat that belongs somewhere else"
-            : "the composer's placeholder could not be read, so where the prompt would land is unknown";
-        throw new Error(`ChatGPT composer did not bind to project "${wanted}": after entering it, ${detail}, ` +
-            `so nothing was sent.${recoveryNote}`);
+        throw new ChatGptBrowserBlockerError(projectNotBoundBlocker({
+            project: wanted,
+            reason: binding,
+            ...(recoveryNote ? { recoveryNote } : {})
+        }));
     }
     const composerReady = await waitForExpressionTrue(cdp, `Boolean(document.querySelector('#prompt-textarea,[contenteditable="true"],textarea'))`, PROJECT_NAVIGATION_TIMEOUT_MS);
     if (!composerReady) {
         throw new Error(`ChatGPT composer did not appear after entering project "${wanted}"`);
     }
+    return chatGptProjectIdFromUrl(await cdp.evaluate("location.href"));
 }
 // Read the finished answer from an existing ChatGPT thread WITHOUT sending a new
 // prompt. Recovers a consult whose send timed out but whose answer ChatGPT
@@ -3147,6 +3270,7 @@ export async function sendChatGptPrompt(options) {
             process.stderr.write(`DBG-SEND +${Date.now() - sendStartedAt}ms ${msg}\n`);
     };
     let beforeSubmit;
+    let boundProjectId;
     let submitButtonFound = false;
     let wantsDeepResearch = false;
     const sendWarnings = [];
@@ -3192,11 +3316,16 @@ export async function sendChatGptPrompt(options) {
         // 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 (!effortNeedsWorkSurface(options.effort)) {
-            const surfaceWarning = await ensureChatSurface(cdp);
+            // 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
+            // where it stands, because that page IS the destination.
+            const surfaceWarning = await ensureChatSurface(cdp, {
+                mayLeaveCurrentPage: Boolean(options.newChat || options.project || options.projectNew)
+            });
             if (surfaceWarning)
                 sendWarnings.push(surfaceWarning);
         }
-        await selectProject(cdp, options);
+        boundProjectId = await selectProject(cdp, options);
         try {
             await selectModelReasoning(cdp, options, sendWarnings);
         }
@@ -3230,8 +3359,7 @@ export async function sendChatGptPrompt(options) {
             const stillBound = await waitForComposerProjectBinding(cdp, boundProject, PROJECT_NAVIGATION_TIMEOUT_MS);
             dbgSend(`project binding before typing=${stillBound}`);
             if (stillBound !== "bound") {
-                throw new Error(`ChatGPT composer did not bind to project "${boundProject}": it read as this project's after entering it and ` +
-                    `no longer does, so nothing was sent.`);
+                throw new ChatGptBrowserBlockerError(projectNotBoundBlocker({ project: boundProject, reason: "drifted" }));
             }
         }
         // Attach BEFORE typing: the upload is the slow part, and a file that
@@ -3428,6 +3556,7 @@ export async function sendChatGptPrompt(options) {
             answer: transcript.answer,
             modelHints: finalState?.modelHints ?? [],
             ...(transcript.modelSlug ? { modelSlug: transcript.modelSlug } : finalState?.modelSlug ? { modelSlug: finalState.modelSlug } : {}),
+            ...(boundProjectId ? { boundProjectId } : {}),
             warnings: withDialogNote([...sendWarnings, selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...((transcript.modelSlug || finalState?.modelSlug) ? { modelSlug: (transcript.modelSlug || finalState?.modelSlug) } : {}) })]).filter((warning) => Boolean(warning))
         };
     };
@@ -3576,6 +3705,7 @@ export async function sendChatGptPrompt(options) {
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
             ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
+            ...(boundProjectId ? { boundProjectId } : {}),
             warnings: withDialogNote([...sendWarnings, selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...(completed.modelSlug !== undefined ? { modelSlug: completed.modelSlug } : {}) })]).filter((warning) => Boolean(warning))
         };
     }
@@ -3590,6 +3720,7 @@ export async function sendChatGptPrompt(options) {
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
             ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
+            ...(boundProjectId ? { boundProjectId } : {}),
             warnings: withDialogNote([
                 ...sendWarnings,
                 ...(selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...(completed.modelSlug !== undefined ? { modelSlug: completed.modelSlug } : {}) }) ? [selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...(completed.modelSlug !== undefined ? { modelSlug: completed.modelSlug } : {}) })] : []),
@@ -5299,6 +5430,68 @@ export function deepResearchReportExpression(conversationId) {
  * Thread urls come in a plain (`/c/<id>`) and a project (`/g/g-p-.../c/<id>`)
  * shape; both end in the conversation id the backend API is keyed by.
  */
+/**
+ * The project a ChatGPT URL belongs to, as its stable id.
+ *
+ * Measured live within one send: the SAME project renders as
+ * `/g/g-p-<hash>/project` on its home and `/g/g-p-<hash>-<name>/c/<id>` on the
+ * thread that came out of it. Comparing the slugs whole would call those two
+ * different projects, so only the hash - the part that does not depend on how
+ * the page felt like writing the name - identifies it.
+ */
+export function chatGptProjectIdFromUrl(url) {
+    if (!url)
+        return undefined;
+    const match = /\/g\/g-p-([0-9a-f]+)(?:[-/?#]|$)/i.exec(url);
+    return match ? match[1].toLowerCase() : undefined;
+}
+/**
+ * Where the prompt actually landed, against where it was aimed.
+ *
+ * The receipt recorded the project the caller ASKED for, which is intent, not
+ * evidence: a send that ended up somewhere else was recorded under the name of
+ * the place it never reached. The answered thread's URL carries the project it
+ * really belongs to, and the project step knows the id it bound to, so the two
+ * can be compared instead of assumed. "unverified" is its own answer - better
+ * than a receipt that certifies what nobody checked.
+ */
+export function destinationVerification(input) {
+    const answeredProjectId = chatGptProjectIdFromUrl(input.answeredUrl);
+    const destination = !input.answeredUrl ? "unknown" : answeredProjectId ? "project" : "root";
+    if (!input.requestedProject)
+        return { destination };
+    if (destination === "unknown")
+        return { destination, verified: false };
+    // Landing outside every project is wrong on its own evidence: it needs no id
+    // to compare against, and requiring one would have retired a warning that
+    // caught this in the field.
+    if (destination === "root") {
+        return {
+            destination,
+            verified: false,
+            warning: "project_landing_warning: a project was requested but the answered thread is a root chat, so it landed OUTSIDE the project. " +
+                "Move it via the thread menu (Move to project) or re-run; list projects with `prodex pro browser projects`."
+        };
+    }
+    // In a project, with nothing to check it against: not a warning, but not a
+    // verified landing either.
+    if (!input.boundProjectId)
+        return { destination, verified: false };
+    const verified = answeredProjectId === input.boundProjectId;
+    return {
+        destination,
+        verified,
+        ...(verified
+            ? {}
+            : {
+                // Naming the project it landed in would put another project's name in
+                // a persisted record; the thread URL is already there for anyone who
+                // needs to go look.
+                warning: "project_landing_warning: the answered thread belongs to a different project than the one this send entered. " +
+                    "Open the thread URL in the receipt to see where it went."
+            })
+    };
+}
 export function conversationIdFromThreadUrl(url) {
     const match = /\/c\/([0-9a-fA-F-]{16,})/.exec(url);
     return match ? match[1] : undefined;

package/dist/cli-args.js

@@ -260,6 +260,9 @@ export const ASK_PRO_BOOLEAN_FLAGS = new Set([
     "--no-auto-login",
     // Send outside any project for once, overriding a pinned default.
     "--no-project",
+    // Continue the conversation a previous consult left off in, resolved from
+    // this repo's own records rather than from whatever the shared tab shows.
+    "--continue",
     // Send even when the requested model/effort could not be applied, rather
     // than stopping. Off by default: an answer from a step nobody asked for is
     // usually thrown away.
@@ -268,6 +271,8 @@ export const ASK_PRO_BOOLEAN_FLAGS = new Set([
 export const ASK_PRO_SELECTION_VALUE_FLAGS = ["--project", "--project-new", "--model", "--pro-mode", "--effort"];
 export const ASK_PRO_VALUE_FLAGS = new Set([
     "--cwd",
+    // Continue one NAMED past consult, when "the last one" is not the one meant.
+    "--continue-task",
     "--file",
     // Upload the file itself (pdf/pptx/image) instead of inlining its text.
     "--attach",

package/dist/cli-help.js

@@ -26,7 +26,7 @@ Ask / consult commands:
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of model menu options
   prodex pro browser projects [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of sidebar project names (for --project)
   prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # recover a finished answer from a thread whose send timed out
-  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"] "prompt"  # explicit visible-browser send
+  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"] "prompt"  # explicit visible-browser send
   prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro blockers [--cwd /absolute/path/to/repo] [--since 7d] [--limit 10] [--json]  # what actually blocks consults, ranked, across every bridge root on this machine
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
@@ -170,7 +170,7 @@ Commands:
   prodex pro browser check [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js]
-  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--target-url url --confirm-target] [--new-chat] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"] "prompt"
+  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"] "prompt"
   prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro blockers [--cwd /absolute/path/to/repo] [--since 7d] [--limit 10] [--json]  # what actually blocks consults, ranked, across every bridge root on this machine
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
@@ -258,8 +258,8 @@ export function printProBrowserHelp(stdout, sourceCli) {
         : "prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]";
     const selectionUsage = '[--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|Pro] [--project "name" | --project-new "name"]';
     const askUsage = sourceCli
-        ? `${cli} pro browser ask${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`
-        : `prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`;
+        ? `${cli} pro browser ask${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`
+        : `prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--continue | --continue-task task_id] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`;
     const modelsUsage = sourceCli
         ? `${cli} pro browser models${sourceCliOption} [--port 9333] [--timeout-ms 15000]`
         : "prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]";
@@ -306,6 +306,11 @@ Model/project selection (ask):
   --pro-mode   Pro sub-mode: 기본 (standard) or 확장 (extended), used when the model is Pro. A Pro selection raises the default --timeout-ms to 1200000.
   --effort     Reasoning effort: 즉시 / 중간 / 높음 / 매우 높음 / Max / Ultra / Pro (aliases: instant/light, medium, high, extrahigh/max, ultra). One power slider sets the model and the effort together, so picking an effort moves off Pro. Max and Ultra are rungs of the Work surface and only apply when the browser is already on Work; everything else is sent on Chat.
   --project    Enter an existing sidebar project before sending. Cannot be combined with --target-url.
+
+Continuing a conversation (ask):
+  --continue        Send into the conversation a previous consult is already in: the newest FINISHED consult of the same project, read from this repo's own .bridge records. The browser tab is shared and a pinned project starts a new chat on every send, so the tab is not what decides this. A --project here scopes the search rather than navigating. Refuses instead of guessing when this project has no finished consult yet.
+  --continue-task   Continue one named past consult by its task_id, when the newest is not the conversation meant. List them with \`${cli} pro list\`.
+Cannot be combined with --new-chat, --target-url, --project-new or --temporary.
 --pro-mode and --effort cannot be combined. Labels are matched in both the Korean and English (US) ChatGPT UI (e.g. 높음/High, Pro 확장/Pro Extended).
 Run \`${cli} pro browser models${sourceCliOption}\` to list the labels your account currently shows.
 Persist defaults with \`${cli} setup${sourceCliOption}\`; per-ask flags override them.

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 } 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, 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";
@@ -11,6 +11,7 @@ import { errorMessage, firstLine, formatBlockedConsultRecordedMessage, formatPro
 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 { readBridgeRoots } from "./registry.js";
 import { BridgeStore, MAX_FETCHABLE_RESULT_ARTIFACT_BYTES } from "./store.js";
 import { CLI_VERSION } from "./cli-help.js";
@@ -162,6 +163,8 @@ export async function runProCommand(rest, io, runCliFn) {
             "--effort",
             "--new-chat",
             "--temporary",
+            "--continue",
+            "--continue-task",
             "--auto-login",
             "--no-auto-login"
         ].find((flag) => proArgs.includes(flag));
@@ -1058,7 +1061,8 @@ export async function runAskProCommand(rest, io) {
         throw new Error("--tool only applies when sending (`prodex pro browser ask`); the dry-run preview cannot open ChatGPT's tools menu.");
     }
     const targetUrl = readFlag(parsedAskPro.optionArgs, "--target-url");
-    const normalizedTargetUrl = targetUrl ? normalizeChatGptTargetUrl(targetUrl) : undefined;
+    let normalizedTargetUrl = targetUrl ? normalizeChatGptTargetUrl(targetUrl) : undefined;
+    let continuedFromTaskId;
     if (!normalizedTargetUrl && parsedAskPro.optionArgs.includes("--confirm-target")) {
         throw new Error("--confirm-target requires --target-url so the visible browser target is explicit.");
     }
@@ -1104,6 +1108,46 @@ export async function runAskProCommand(rest, io) {
     if (normalizedTargetUrl && (explicitProject !== undefined || explicitProjectNew !== undefined)) {
         throw new Error("ask-pro cannot combine --target-url with --project/--project-new: --target-url pins the confirmed tab while the project step navigates the sidebar away from it. Open the project thread in the browser and pass its URL as --target-url instead.");
     }
+    // Continue the conversation a previous consult left off in. Resolved from
+    // this repo's records rather than from the shared tab: the tab is whatever
+    // the last person or session left on screen, and a pinned project
+    // navigates away from it before every send anyway - which is why a
+    // "continuing" consult on a machine with a default project measurably
+    // started a new thread every time.
+    const continueRequested = parsedAskPro.optionArgs.includes("--continue");
+    const continueTaskId = readFlag(parsedAskPro.optionArgs, "--continue-task");
+    if (continueRequested || continueTaskId !== undefined) {
+        const conflict = [
+            parsedAskPro.optionArgs.includes("--new-chat") ? "--new-chat" : undefined,
+            targetUrl !== undefined ? "--target-url" : undefined,
+            explicitProjectNew !== undefined ? "--project-new" : undefined,
+            parsedAskPro.optionArgs.includes("--temporary") ? "--temporary" : undefined
+        ].find(Boolean);
+        if (conflict) {
+            throw new Error(`ask-pro cannot combine --continue with ${conflict}: continuing means sending into the conversation a previous consult is already in.`);
+        }
+        // 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);
+        const resolved = resolveContinuationThread({
+            consults: (await targetStore.listSessionsReadOnly()).map((session) => ({
+                taskId: session.task_id ?? "",
+                ...(session.thread ? { thread: session.thread } : {}),
+                status: session.status,
+                ...(session.created_at ? { createdAt: session.created_at } : {})
+            })),
+            ...(continuationProject ? { project: continuationProject } : {}),
+            ...(continueTaskId !== undefined ? { taskId: continueTaskId } : {})
+        });
+        if ("error" in resolved)
+            throw new Error(resolved.error);
+        continuedFromTaskId = resolved.target.taskId;
+        // The thread pins the tab exactly as --target-url does, and carries its
+        // own project with it - so the project step is suppressed below for the
+        // same reason a pinned target suppresses it.
+        normalizedTargetUrl = normalizeChatGptTargetUrl(resolved.target.thread);
+        io.stderr(`progress: continuing ${resolved.target.taskId}`);
+    }
     const newChat = parsedAskPro.optionArgs.includes("--new-chat");
     // A temporary chat is not saved, so there is nothing to come back to: the
     // recovery path every timeout message points at cannot fetch it later.
@@ -1130,18 +1174,19 @@ export async function runAskProCommand(rest, io) {
     }
     const explicitProMode = explicitProModeRaw === undefined ? undefined : parseProMode(explicitProModeRaw);
     const explicitEffort = explicitEffortRaw === undefined ? undefined : parseReasoningEffort(explicitEffortRaw);
-    // Explicit per-ask flags override persisted defaults. Choosing either
-    // reasoning axis explicitly suppresses the default for the other axis, and
-    // pinning --target-url suppresses a default project (it would navigate away
-    // from the confirmed tab).
-    // Choosing an effort IS choosing the reasoning axis, and ChatGPT deselects
-    // Pro the moment an effort is set - so applying a pinned Pro first would
-    // select a model only to undo it, and a quick question would still pay for
-    // the Pro selection dance.
-    // --pro-mode refines Pro, so it keeps a pinned Pro. --effort replaces it:
-    // ChatGPT deselects Pro the moment an effort is set, so applying the pinned
-    // Pro first would select a model only to undo it.
-    const selectionModel = explicitModel ?? (explicitEffort !== undefined ? undefined : browserDefaults?.model);
+    // Explicit per-ask flags override persisted defaults; resolveSelectionAxes
+    // holds which default a given flag suppresses and why. The project axis is
+    // separate: pinning --target-url suppresses a default project, because
+    // entering one would navigate away from the confirmed tab.
+    const selectionAxes = resolveSelectionAxes({
+        explicit: {
+            ...(explicitModel !== undefined ? { model: explicitModel } : {}),
+            ...(explicitProMode !== undefined ? { proMode: explicitProMode } : {}),
+            ...(explicitEffort !== undefined ? { effort: explicitEffort } : {})
+        },
+        ...(browserDefaults ? { defaults: browserDefaults } : {})
+    });
+    const selectionModel = selectionAxes.model;
     const selectionProjectNew = explicitProjectNew;
     // A persisted default project APPLIES under --new-chat: since 0.16.11 a
     // fresh chat inside the project is exactly what "--new-chat + project"
@@ -1154,15 +1199,24 @@ export async function runAskProCommand(rest, io) {
     // produced "composer did not rebind after entering project" - a temporary
     // chat is never saved, a project chat is, and entering a project leaves
     // temporary mode.
-    const selectionProject = explicitProject ??
-        (normalizedTargetUrl || selectionProjectNew !== undefined || suppressProject || temporary
-            ? undefined
-            : browserDefaults?.project);
-    const reasoningAxisChosen = explicitProMode !== undefined || explicitEffort !== undefined;
-    const selectionProMode = explicitProMode ?? (reasoningAxisChosen ? undefined : browserDefaults?.pro_mode);
-    const selectionEffort = explicitEffort ?? (reasoningAxisChosen ? undefined : browserDefaults?.effort);
+    // A continuation sends into a thread that already lives in its project, so
+    // the project step must not run - entering a project navigates AWAY from
+    // the pinned thread and starts a new chat, which is the very failure
+    // --continue exists to fix. An explicit --project on a continuation is the
+    // SCOPE of the search, not an instruction to navigate.
+    const selectionProject = continuedFromTaskId
+        ? undefined
+        : explicitProject ??
+            (normalizedTargetUrl || selectionProjectNew !== undefined || suppressProject || temporary
+                ? undefined
+                : browserDefaults?.project);
+    const selectionProMode = selectionAxes.proMode;
+    const selectionEffort = selectionAxes.effort;
+    const continuationScopeProject = continuedFromTaskId
+        ? explicitProject ?? (suppressProject ? undefined : browserDefaults?.project)
+        : undefined;
     const selectionMetadata = {
-        ...(selectionProject ? { project: selectionProject } : {}),
+        ...(selectionProject ?? continuationScopeProject ? { project: (selectionProject ?? continuationScopeProject) } : {}),
         ...(selectionProjectNew ? { project_new: selectionProjectNew } : {}),
         ...(selectionModel ? { model: selectionModel } : {}),
         ...(selectionProMode ? { pro_mode: selectionProMode } : {}),
@@ -1307,10 +1361,7 @@ export async function runAskProCommand(rest, io) {
             // "project not found" error). Local stdout/stderr keep it (useful to the
             // operator), but the persisted task/session cross the MCP boundary, so
             // scrub the project name there the same way provenance.project is redacted.
-            const redactProject = (text) => {
-                const name = selectionMetadata.project;
-                return name ? text.split(name).join("<project>") : text;
-            };
+            const redactProject = (text) => redactProjectNames(text, [selectionMetadata.project, selectionMetadata.project_new]);
             // Where the prompt actually landed beats where the caller aimed: with
             // --new-chat there is no target url, and a blocker that started a run
             // still has a thread worth handing back.
@@ -1359,13 +1410,21 @@ export async function runAskProCommand(rest, io) {
                 (consult.modelSlug ? ` - it answered as "${consult.modelSlug}"` : "") +
                 ". Pin one with `prodex setup --model Pro` or pass --model/--effort.");
         }
-        // In-project threads carry the project slug in their URL
-        // (/g/g-p-<project>/c/<id>); a bare /c/<id> after requesting a project
-        // means the thread landed at root - say so instead of leaving it to a
-        // sidebar audit (field-verified failure mode).
-        if ((selectionMetadata.project || selectionMetadata.project_new) && !/\/g\/g-p-/.test(consult.url ?? "")) {
-            persistenceWarnings.push("project_landing_warning: a project was requested but the answered thread URL is a root /c/ thread, so it likely landed OUTSIDE the project. Move it via the thread menu (Move to project) or re-run; list projects with `prodex pro browser projects`.");
-        }
+        // Where the answer actually IS, checked rather than assumed: the project
+        // id the composer bound to before typing, against the project the
+        // answered thread belongs to. The requested name is intent - a send that
+        // ended up elsewhere was recorded under the name of the place it never
+        // reached.
+        const continuationProjectId = continuedFromTaskId ? chatGptProjectIdFromUrl(normalizedTargetUrl) : undefined;
+        const destination = destinationVerification({
+            requestedProject: Boolean(selectionMetadata.project || selectionMetadata.project_new),
+            ...(consult.boundProjectId ?? continuationProjectId
+                ? { boundProjectId: (consult.boundProjectId ?? continuationProjectId) }
+                : {}),
+            ...(consult.url ? { answeredUrl: consult.url } : {})
+        });
+        if (destination.warning)
+            persistenceWarnings.push(destination.warning);
         // Truncation and other send warnings must be visible at runtime, not
         // only inside the persisted receipt: a caller who never opens .bridge
         // would otherwise treat a cut-off answer as complete.
@@ -1414,6 +1473,14 @@ export async function runAskProCommand(rest, io) {
                     // receipt used to record only what prodex asked for.
                     ...(consult.modelSlug ? { model_used: consult.modelSlug } : {}),
                     ...(proVerified !== undefined ? { pro_verified: proVerified } : {}),
+                    // Intent and evidence, kept apart. `selection` is what was asked
+                    // for; this is where the answer turned out to be, and whether
+                    // anything actually confirmed it.
+                    ...(continuedFromTaskId ? { continued_from: continuedFromTaskId } : {}),
+                    destination: {
+                        observed: destination.destination,
+                        ...(destination.verified !== undefined ? { verified: destination.verified } : {})
+                    },
                     warnings: persistenceWarnings
                 }
             });
@@ -1579,6 +1646,8 @@ export async function performBrowserConsultForMcp(cwd, input, onProgress) {
         ...(input.attach ?? []).flatMap((file) => ["--attach", file]),
         ...(input.tools ?? []).flatMap((tool) => ["--tool", tool]),
         ...(input.new_chat ? ["--new-chat"] : []),
+        ...(input.continue_thread ? ["--continue"] : []),
+        ...(input.continue_task !== undefined ? ["--continue-task", input.continue_task] : []),
         ...(input.allow_model_fallback ? ["--allow-model-fallback"] : []),
         "--",
         input.prompt
@@ -1823,6 +1892,54 @@ export function temporaryProjectConflict(input) {
     return (`--temporary and --project cannot be combined: a temporary chat is never saved, and a chat inside a project is. ` +
         `Drop --temporary to send into "${input.explicitProject}", or drop --project to send a throwaway chat.`);
 }
+/**
+ * What a send actually selects, given the per-ask flags and the persisted
+ * defaults.
+ *
+ * Explicit flags beat persisted defaults - except that a saved effort used to
+ * beat an explicit `--model Pro`, because Pro IS the top step of the effort
+ * slider: setting any other step deselects it. So the send ran at the saved
+ * effort, the answer came from a lesser model, and the warning about it told
+ * the caller to clear a saved MODEL default, which was not what overrode
+ * anything. Asking for Pro on the model axis now suppresses a saved effort
+ * exactly as `--effort` suppresses a saved model. A saved pro_mode survives:
+ * it only refines Pro.
+ *
+ * Combining an explicit model with an explicit effort is left alone - that is
+ * the caller saying both out loud, and the picker warns about it.
+ */
+export function resolveSelectionAxes(input) {
+    const { explicit } = input;
+    const defaults = input.defaults;
+    const reasoningAxisChosen = explicit.proMode !== undefined || explicit.effort !== undefined;
+    const explicitlyPro = explicit.model !== undefined && namesPro(explicit.model);
+    const model = explicit.model ?? (explicit.effort !== undefined ? undefined : defaults?.model);
+    const proMode = explicit.proMode ?? (reasoningAxisChosen ? undefined : defaults?.pro_mode);
+    const effort = explicit.effort ?? (reasoningAxisChosen || explicitlyPro ? undefined : defaults?.effort);
+    return {
+        ...(model !== undefined ? { model } : {}),
+        ...(proMode !== undefined ? { proMode } : {}),
+        ...(effort !== undefined ? { effort } : {})
+    };
+}
+/**
+ * Scrub project names out of text that gets persisted.
+ *
+ * Both names count. A send that CREATES its project names it in exactly the
+ * same failures - the binding refusal, the composer that never appeared, the
+ * sidebar click that missed - and only the requested name was ever scrubbed,
+ * so those records kept a real project name while the equivalent record for an
+ * existing project did not.
+ */
+export function redactProjectNames(text, names) {
+    let redacted = text;
+    // Longest first: a project named "Notes" inside "Notes Archive" would
+    // otherwise leave "<project> Archive" behind.
+    for (const name of [...names].filter((name) => Boolean(name)).sort((a, b) => b.length - a.length)) {
+        redacted = redacted.split(name).join("<project>");
+    }
+    return redacted;
+}
 export function browserSendBlockerFromError(error) {
     const blocker = typeof error === "object" && error !== null && "blocker" in error ? error.blocker : undefined;
     if (typeof blocker === "object" &&

package/dist/config.js

@@ -208,22 +208,56 @@ export function envBrowserDefaults() {
     });
     return (model || project) && freeText.success ? freeText.data : undefined;
 }
+/**
+ * Combine the global env defaults with this repo's.
+ *
+ * The project is independent of the rest, so the repo's wins that field and
+ * the env fills it in. The model and the two reasoning fields are NOT
+ * independent: an effort is a step ChatGPT deselects the model to reach, and a
+ * pro_mode only refines Pro. Merging those field-by-field built a request
+ * neither side asked for - a repo pinning `model: Pro` next to
+ * PRODEX_DEFAULT_EFFORT ran at the effort and dropped Pro - so whichever side
+ * names the reasoning selection provides all of it.
+ */
+export function mergeBrowserDefaultSources(env, repo) {
+    if (!repo && !env)
+        return undefined;
+    const namesSelection = (defaults) => Boolean(defaults && (defaults.model !== undefined || defaults.pro_mode !== undefined || defaults.effort !== undefined));
+    const selection = namesSelection(repo) ? repo : env;
+    const merged = {
+        ...(selection?.model !== undefined ? { model: selection.model } : {}),
+        ...(selection?.pro_mode !== undefined ? { pro_mode: selection.pro_mode } : {}),
+        ...(selection?.effort !== undefined ? { effort: selection.effort } : {})
+    };
+    const project = repo?.project ?? env?.project;
+    if (project !== undefined)
+        merged.project = project;
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
 // Read persisted browser-selection defaults without failing when the local
 // config is absent or unrelated to this cwd (defaults are optional convenience).
-// Per-repo config wins field-by-field; PRODEX_DEFAULT_* env vars are the global
-// fallback so a pinned default project/model applies from any cwd.
+// The repo's config provides the project and, if it names any of them, the
+// reasoning selection; PRODEX_DEFAULT_* env vars are the global fallback so a
+// pinned default project/model applies from any cwd.
 export async function loadBrowserDefaults(cwd) {
     const env = envBrowserDefaults();
     let repo;
     try {
         repo = (await loadLocalConfig(cwd)).browser_defaults;
     }
-    catch {
+    catch (error) {
+        // Having no config is the ordinary case - browser sends work without one -
+        // and stays silent. A config that EXISTS and cannot be read is a different
+        // thing, and swallowing it was the quiet failure: the defaults it pins
+        // 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)) {
+            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 });
+        }
         repo = undefined;
     }
-    if (!repo && !env)
-        return undefined;
-    return { ...(env ?? {}), ...(repo ?? {}) };
+    return mergeBrowserDefaultSources(env, repo);
 }
 export function getTokenExpiryStatus(config, now = new Date()) {
     if (!config.token_expires_at) {

package/dist/continue-thread.js

@@ -0,0 +1,84 @@
+/**
+ * Which conversation a follow-up consult belongs to.
+ *
+ * "Continue" used to mean "whatever thread the shared browser tab is showing",
+ * which is not a conversation anyone named: another session, or a person
+ * clicking around, moves it. Worse, a pinned project navigates AWAY from that
+ * tab before every send, so on a machine with a default project every consult
+ * started a fresh thread while the tool description promised the opposite
+ * (measured: two consecutive sends into one project landed in two different
+ * /c/ threads).
+ *
+ * prodex already writes down where each consult landed. That record - not the
+ * tab - is what a follow-up should resolve against. Pure on purpose: the
+ * reading lives in the command.
+ */
+/**
+ * The project name as it appears inside a thread URL.
+ *
+ * Measured: a project named "prodex-smoke-project" answers on
+ * `/g/g-p-<id>-prodex-smoke-project/c/<id>`, and "Codex" on
+ * `/g/g-p-<id>-codex/c/<id>` - the name lowercased, with runs of anything else
+ * collapsed to a single dash.
+ */
+export function chatGptProjectSlug(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Whether a recorded thread belongs to the project this send is for.
+ *
+ * A send with no project continues only a thread that belongs to no project,
+ * 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) {
+    const projectSegment = /\/g\/(g-p-[^/?#]+)/.exec(threadUrl)?.[1];
+    if (!project)
+        return projectSegment === undefined;
+    if (!projectSegment)
+        return false;
+    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}`);
+}
+/**
+ * The thread a follow-up should continue, or why it cannot be resolved.
+ *
+ * Naming a task wins over the search, because the caller who names one knows
+ * which conversation they mean. Otherwise it is the most recent consult that
+ * finished, in this project - fail-closed when there is none, since guessing
+ * the conversation is the failure this exists to prevent.
+ */
+export function resolveContinuationThread(input) {
+    const withThread = input.consults.filter((consult) => Boolean(consult.thread));
+    if (input.taskId) {
+        const named = withThread.find((consult) => consult.taskId === input.taskId);
+        if (!named) {
+            return {
+                error: `No recorded consult thread for "${input.taskId}". List what is here with \`prodex pro list\`, ` +
+                    `or pass the thread itself with --target-url --confirm-target.`
+            };
+        }
+        return { target: { taskId: named.taskId, thread: named.thread } };
+    }
+    const candidates = withThread
+        .filter((consult) => consult.status === "done")
+        .filter((consult) => threadMatchesProject(consult.thread, input.project))
+        .sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
+    const latest = candidates[0];
+    if (!latest) {
+        const where = input.project ? `project "${input.project}"` : "a chat outside any project";
+        return {
+            error: `No finished consult of this repo has a thread in ${where} to continue. ` +
+                `Send once without --continue, or name a consult with --continue-task <task_id>.`
+        };
+    }
+    return { target: { taskId: latest.taskId, thread: latest.thread } };
+}

package/dist/mcp.js

@@ -162,7 +162,7 @@ export function createServer(cwd = process.cwd(), options = {}) {
     const browserConsult = options.browserConsult;
     if (browserConsult) {
         server.registerTool("pro_consult", {
-            description: "Ask the user's logged-in ChatGPT (Pro) in the visible browser and wait for the full answer. This drives a real browser send: it can take minutes (Pro extended reasoning), is human-paced, and records a durable receipt under .bridge/. Requires a running `prodex pro browser login` session. By DEFAULT the consult continues in the currently-open thread, so consecutive follow-ups on the same topic stay in one conversation (keeps context, avoids sidebar clutter). Pass new_chat:true ONLY to start a fresh thread for a genuinely new topic. If the thread is still generating a previous answer, the send automatically queues behind it (up to the timeout budget) - long 'tab busy' progress is normal, not stuck. `project` and `model` come from saved defaults (per-repo config, or PRODEX_DEFAULT_PROJECT / PRODEX_DEFAULT_MODEL env vars) when omitted - do NOT pass them per-call unless deliberately overriding. Returns task_id, thread URL, and the answer text.",
+            description: "Ask the user's logged-in ChatGPT (Pro) in the visible browser and wait for the full answer. This drives a real browser send: it can take minutes (Pro extended reasoning), is human-paced, and records a durable receipt under .bridge/. Requires a running `prodex pro browser login` session. By default the consult continues in whatever thread the browser tab is showing - EXCEPT when a project applies (passed here, or pinned as a saved default), because entering a project starts a new chat in it. To follow up on a previous consult, pass continue_thread:true: it resolves the thread from prodex's own records - the newest finished consult of the same project - instead of trusting the shared tab, and continue_task with a task_id names one exactly. Pass new_chat:true to start a fresh thread for a genuinely new topic. If the thread is still generating a previous answer, the send automatically queues behind it (up to the timeout budget) - long 'tab busy' progress is normal, not stuck. `project` and `model` come from saved defaults (per-repo config, or PRODEX_DEFAULT_PROJECT / PRODEX_DEFAULT_MODEL env vars) when omitted - do NOT pass them per-call unless deliberately overriding. Returns task_id, thread URL, and the answer text.",
             inputSchema: {
                 prompt: McpBridgeTextSchema.min(1),
                 model: McpShortTextSchema.optional(),
@@ -187,7 +187,17 @@ export function createServer(cwd = process.cwd(), options = {}) {
                 new_chat: z
                     .boolean()
                     .optional()
-                    .describe("Start a fresh thread. Omit to continue the current thread (preferred for follow-ups)."),
+                    .describe("Start a fresh thread for a new topic."),
+                continue_thread: z
+                    .boolean()
+                    .optional()
+                    .describe("Follow up inside the conversation a previous consult is already in, resolved from prodex's records: the newest finished consult of the same project. This is the reliable way to keep a follow-up in one conversation - the tab is shared, and a project default starts a new chat on every send. Fails rather than guessing when this project has no finished consult yet."),
+                continue_task: z
+                    .string()
+                    .min(1)
+                    .max(200)
+                    .optional()
+                    .describe("Continue one NAMED past consult by its task_id, when the newest one is not the conversation meant."),
                 allow_model_fallback: z
                     .boolean()
                     .optional()

package/package.json

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