@youdie006/prodex 0.40.1 → 0.40.3

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" &&
@@ -1888,6 +2005,18 @@ export function browserSendBlockerFromError(error) {
             next_step: "Another prodex send holds the browser. Wait for it to finish and retry, or pass a longer --timeout-ms, which is also the queue budget."
         };
     }
+    // The composer would have posted somewhere other than the project that was
+    // asked for, so nothing was sent. A prompt that lands in another project is
+    // worse than a blocker: the receipt records the project the caller asked for,
+    // and the answer is somewhere nobody is looking.
+    if (/composer did not bind to project/.test(message)) {
+        return {
+            code: "project_not_bound",
+            message,
+            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 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.

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