@youdie006/prodex 0.23.1 → 0.25.0

package/dist/bundle.js

@@ -12,10 +12,14 @@ export async function buildDryRunBundle(root, input) {
         input.prompt.trim()
     ];
     const files = [];
+    // The prompt leads so the instruction is never buried under file dumps.
+    const sendSections = [input.prompt.trim()];
     for (const file of input.files) {
         const content = await readRepoFile(root, file, { maxLines: 500 });
         files.push({ path: file, role: "context", bytes: Buffer.byteLength(content.content, "utf8") });
-        sections.push("", `## File: ${file}`, "", "```text", content.content, "```");
+        const fileSection = ["", `## File: ${file}`, "", "```text", content.content, "```"];
+        sections.push(...fileSection);
+        sendSections.push(...fileSection);
     }
     return {
         schema_version: SCHEMA_VERSION,
@@ -24,6 +28,7 @@ export async function buildDryRunBundle(root, input) {
         prompt: input.prompt,
         files,
         text: sections.join("\n"),
+        sendText: sendSections.join("\n"),
         created_at: nowIso()
     };
 }

package/dist/chatgpt-browser.js

@@ -402,8 +402,43 @@ export function isUsableChatGptAnswer(answer) {
         if (headerOnly)
             return false;
     }
+    // A composer tool renders its own progress panel into the assistant turn
+    // before any text exists. Measured on a --tool web-search send: "Searching
+    // the web" over an "Answer now" button, which the page reports as a settled
+    // two-line answer. Only treat it as a placeholder when it is the WHOLE
+    // content, so an answer that discusses searching still counts.
+    if (lineCount <= 2) {
+        const toolPanelOnly = normalized
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .every((line) => /^(searching the web|웹\s*검색\s*중|answer now|지금\s*답변|검색\s*중)$/i.test(line));
+        if (toolPanelOnly)
+            return false;
+    }
     return true;
 }
+/**
+ * Who decides the answer is finished: the transcript, when it can be read.
+ *
+ * The page only guesses - a tool's progress panel looks exactly like a settled
+ * two-line answer, and a consult once returned "Searching the web / Answer now"
+ * as its result. When the transcript is reachable AND belongs to this consult,
+ * its state is authoritative: "pending" keeps the wait alive even if the page
+ * looks done. "unavailable" (unreachable, or a different conversation) is the
+ * only case that falls back to reading the page.
+ */
+export function classifyTranscriptRead(state, sentPrompt) {
+    if (!state)
+        return "unavailable";
+    if (!transcriptMatchesSentPrompt(state.userText, sentPrompt))
+        return "unavailable";
+    if (state.ok)
+        return "answer";
+    return state.reason === "answer_not_finished" || state.reason === "no_assistant_message" || state.reason === "answer_empty"
+        ? "pending"
+        : "unavailable";
+}
 export function hasFreshChatGptAnswer(previousAssistantMessageCount, state) {
     return state.assistantMessageCount > previousAssistantMessageCount && isUsableChatGptAnswer(state.answer) && !state.generating;
 }
@@ -1750,25 +1785,23 @@ export async function recoverChatGptAnswerFromThread(options) {
         warnings: []
     };
 }
-/**
- * Read the answer from the conversation transcript, or undefined when it is not
- * there yet. The transcript trails the rendered stream by a beat, so callers
- * either poll it or fall back to the DOM text.
- */
-async function readTranscriptAnswer(page, conversationId) {
+async function readTranscriptAnswer(page, conversationId, sentPrompt) {
     let transcript;
     try {
         transcript = await evaluateOnPage(page, transcriptAnswerExpression(conversationId), { timeoutMs: 30_000 });
     }
     catch {
-        // Transcript unavailable (endpoint changed, transient failure): the DOM
+        // Transcript unreachable (endpoint changed, transient failure): the DOM
         // reader still runs, so this never blocks a send.
-        return undefined;
+        return { classification: "unavailable" };
     }
-    if (!transcript.ok || transcript.text.trim().length === 0)
-        return undefined;
+    const classification = classifyTranscriptRead(transcript, sentPrompt);
+    if (classification !== "answer")
+        return { classification };
     const answer = resolveTranscriptCitations(transcript.text, transcript.references).trim();
-    return answer.length > 0 ? { answer, modelSlug: transcript.modelSlug } : undefined;
+    return answer.length > 0
+        ? { classification: "answer", answer: { answer, modelSlug: transcript.modelSlug } }
+        : { classification: "pending" };
 }
 export async function sendChatGptPrompt(options) {
     const port = resolveCdpPort(options.port);
@@ -2084,7 +2117,7 @@ export async function sendChatGptPrompt(options) {
                 await sleep(5_000);
                 continue;
             }
-            if (lastState.ok && lastState.report.trim().length > 0) {
+            if (lastState.ok && lastState.report.trim().length > 0 && transcriptMatchesSentPrompt(lastState.userText, options.prompt)) {
                 const report = resolveTranscriptCitations(lastState.report, lastState.references).trim();
                 emitProgress("answered", `deep research report (${report.length} chars)`);
                 return {
@@ -2115,15 +2148,19 @@ export async function sendChatGptPrompt(options) {
         await sleep(1000);
         try {
             finalState = await evaluateOnPage(page, answerExpression());
+            // First conversation id wins. Re-deriving it every poll would let a tab
+            // that wandered to another thread redirect the read to a stranger's
+            // conversation - and the prompt check below is the second line of defence,
+            // not the first.
             if (!transcriptConversationId && finalState?.url)
                 transcriptConversationId = conversationIdFromThreadUrl(finalState.url);
             // The transcript is the same data the page renders, minus the rendering:
             // markdown instead of flattened innerText, an explicit finish state
             // instead of caret heuristics, and the model that actually answered.
             if (transcriptConversationId && !finalState.generating) {
-                const transcript = await readTranscriptAnswer(page, transcriptConversationId);
-                if (transcript)
-                    return transcriptResult(transcript);
+                const transcript = await readTranscriptAnswer(page, transcriptConversationId, options.prompt);
+                if (transcript.answer)
+                    return transcriptResult(transcript.answer);
             }
             // Only the DOM reader depends on which thread the tab is showing; once the
             // conversation id is known, a wandering tab is harmless.
@@ -2167,12 +2204,15 @@ export async function sendChatGptPrompt(options) {
             // Give the transcript that beat: it carries markdown (tables and fenced
             // code that innerText flattens) and the model that actually answered.
             if (transcriptConversationId) {
-                for (let attempt = 0; attempt < 6; attempt += 1) {
-                    const transcript = await readTranscriptAnswer(page, transcriptConversationId);
-                    if (transcript)
-                        return transcriptResult(transcript);
-                    await sleep(1_500);
-                }
+                const transcript = await readTranscriptAnswer(page, transcriptConversationId, options.prompt);
+                if (transcript.answer)
+                    return transcriptResult(transcript.answer);
+                // The transcript can read this conversation and says it is not done:
+                // believe it over a page that merely looks settled. A tool's progress
+                // panel renders exactly like a two-line answer, and that is how a
+                // consult once returned "Searching the web / Answer now" as its result.
+                if (transcript.classification === "pending")
+                    continue;
             }
             break;
         }
@@ -3030,7 +3070,7 @@ export function deepResearchUnreadableBlocker(threadUrl) {
  */
 export function transcriptAnswerExpression(conversationId) {
     return `(async () => {
-  const fail = (reason, extra) => Object.assign({ ok: false, reason, status: "", endTurn: false, isComplete: false, text: "", modelSlug: "", references: [] }, extra || {});
+  const fail = (reason, extra) => Object.assign({ ok: false, reason, status: "", endTurn: false, isComplete: false, text: "", modelSlug: "", references: [], userText: "" }, extra || {});
   let token = "";
   try {
     const session = await fetch("/api/auth/session", { credentials: "include" });
@@ -3063,7 +3103,9 @@ export function transcriptAnswerExpression(conversationId) {
   const message = chain.find(
     (entry) => entry && entry.author && entry.author.role === "assistant" && entry.content && entry.content.content_type === "text"
   );
-  if (!message) return fail("no_assistant_message");
+  const userMessage = chain.find((entry) => entry && entry.author && entry.author.role === "user" && entry.content);
+  const userText = userMessage ? (userMessage.content.parts || []).filter((part) => typeof part === "string").join("") : "";
+  if (!message) return fail("no_assistant_message", { userText });
   const parts = (message.content.parts || []).filter((part) => typeof part === "string");
   const text = parts.join("");
   const metadata = message.metadata || {};
@@ -3073,15 +3115,37 @@ export function transcriptAnswerExpression(conversationId) {
     isComplete: metadata.is_complete === true,
     text,
     modelSlug: metadata.model_slug || "",
-    references: Array.isArray(metadata.content_references) ? metadata.content_references : []
+    references: Array.isArray(metadata.content_references) ? metadata.content_references : [],
+    userText
   };
   if (state.status !== "finished_successfully" || !state.endTurn) return fail("answer_not_finished", state);
   if (!text) return fail("answer_empty", state);
   return Object.assign({ ok: true, reason: "" }, state);
 })()`;
 }
+const NORMALIZED_PROMPT_MATCH_CHARS = 120;
+/**
+ * Does this transcript belong to the consult that is waiting on it?
+ *
+ * The browser is shared with the user and other agents. Reading "whatever
+ * conversation the tab shows" once cost a consult its answer - prodex saved a
+ * different conversation as the result. Identity is checked against the prompt
+ * that was actually sent, normalized because ChatGPT re-wraps whitespace, and
+ * as a containment test because the transcript wraps the prompt: a composer
+ * tool prefixes it ("@Deep research ...") and attachments append to it.
+ */
+export function transcriptMatchesSentPrompt(userText, sentPrompt) {
+    const normalize = (value) => value.replace(/\s+/g, " ").trim();
+    const seen = normalize(userText);
+    const sent = normalize(sentPrompt);
+    if (seen.length === 0 || sent.length === 0)
+        return false;
+    const expected = sent.slice(0, NORMALIZED_PROMPT_MATCH_CHARS);
+    return seen.includes(expected);
+}
 // ChatGPT marks citations with private-use delimiters (U+E200 opens, U+E202
 // separates, U+E201 closes) and keeps the real sources in content_references.
+const CITATION_DELIMITER_PATTERN = /[\uE200-\uE206]/;
 const CITATION_MARKER_PATTERN = /\uE200[^\uE200-\uE206]*(?:[\uE202\uE204-\uE206][^\uE200-\uE206]*)*[\uE201\uE203]/g;
 /**
  * Turn those markers into ordinary markdown links, so a saved answer keeps the
@@ -3091,7 +3155,11 @@ const CITATION_MARKER_PATTERN = /\uE200[^\uE200-\uE206]*(?:[\uE202\uE204-\uE206]
 export function resolveTranscriptCitations(text, references = []) {
     const byMarker = new Map();
     for (const reference of references) {
-        if (reference && typeof reference.matched_text === "string" && reference.matched_text.length > 0) {
+        // Only substitute on text that IS a marker. A `sources_footnote` reference
+        // carries matched_text " " - a single space - and substituting on that
+        // replaced every space in the document, fusing a 47k-character report into
+        // one run-on word.
+        if (reference && typeof reference.matched_text === "string" && CITATION_DELIMITER_PATTERN.test(reference.matched_text)) {
             byMarker.set(reference.matched_text, reference);
         }
     }
@@ -3117,7 +3185,7 @@ export function resolveTranscriptCitations(text, references = []) {
 }
 export function deepResearchReportExpression(conversationId) {
     return `(async () => {
-  const fail = (reason, status) => ({ ok: false, reason, status: status || "", report: "", chars: 0, references: [] });
+  const fail = (reason, status, userText) => ({ ok: false, reason, status: status || "", report: "", chars: 0, references: [], userText: userText || "" });
   let token = "";
   try {
     const session = await fetch("/api/auth/session", { credentials: "include" });
@@ -3138,7 +3206,8 @@ export function deepResearchReportExpression(conversationId) {
   } catch (error) {
     return fail("conversation_error");
   }
-  const nodes = Object.keys((conversation && conversation.mapping) || {}).map((key) => conversation.mapping[key]);
+  const mapping = (conversation && conversation.mapping) || {};
+  const nodes = Object.keys(mapping).map((key) => mapping[key]);
   const widgetNode = nodes.find(
     (node) => node && node.message && node.message.metadata && node.message.metadata.chatgpt_sdk && node.message.metadata.chatgpt_sdk.widget_state
   );
@@ -3150,12 +3219,22 @@ export function deepResearchReportExpression(conversationId) {
     return fail("widget_state_unparsable");
   }
   const status = (state && state.status) || "";
+  const chain = [];
+  let walkId = conversation && conversation.current_node;
+  let walkGuard = 0;
+  while (walkId && mapping[walkId] && walkGuard < 2000) {
+    walkGuard += 1;
+    if (mapping[walkId].message) chain.push(mapping[walkId].message);
+    walkId = mapping[walkId].parent;
+  }
+  const userNode = chain.find((entry) => entry && entry.author && entry.author.role === "user" && entry.content);
+  const userText = userNode ? (userNode.content.parts || []).filter((part) => typeof part === "string").join("") : "";
   const message = (state && state.report_message) || null;
   const parts = message && message.content && message.content.parts;
   const report = Array.isArray(parts) ? parts.filter((part) => typeof part === "string").join("") : "";
   const references = message && message.metadata && Array.isArray(message.metadata.content_references) ? message.metadata.content_references : [];
-  if (!report) return fail("report_not_ready", status);
-  return { ok: true, reason: "", status, report, chars: report.length, references };
+  if (!report) return fail("report_not_ready", status, userText);
+  return { ok: true, reason: "", status, report, chars: report.length, references, userText };
 })()`;
 }
 /**

package/dist/cli-pro.js

@@ -52,7 +52,7 @@ export async function runChatgptCommand(rest, io) {
             const task = await targetStore.createTask({
                 source: "codex",
                 title: "GPT Pro smoke",
-                prompt: bundle.text,
+                prompt: bundle.sendText,
                 repo_id: "default",
                 provenance: {
                     adapter: "chatgpt-control",
@@ -852,7 +852,8 @@ export async function runAskProCommand(rest, io) {
         const task = await targetStore.createTask({
             source: "codex",
             title: "GPT Pro consult",
-            prompt: bundle.text,
+            // Record what ChatGPT actually received, not the preview rendering.
+            prompt: bundle.sendText,
             repo_id: "default",
             files: files.map((file) => ({ path: file, role: "context" })),
             provenance: {
@@ -901,7 +902,7 @@ export async function runAskProCommand(rest, io) {
         // fast. A dead holder is still reaped immediately.
         const sendOnce = () => withBrowserSendLock(busyWaitMs ?? browserTimeoutMs ?? 0, (detail) => io.stderr(`progress: ${detail}`), () => sendChatGptPrompt({
             port: browserPort,
-            prompt: bundle.text,
+            prompt: bundle.sendText,
             targetUrl: normalizedTargetUrl,
             timeoutMs: browserTimeoutMs,
             ...(attachments.length > 0 ? { attachments } : {}),
@@ -1155,12 +1156,36 @@ Rules:
 Write the debate in the language of the topic.`;
 }
 /**
- * MCP-facing wrapper around the visible-browser ask flow. Reuses the full CLI
- * path (send pacing, task/session/receipt persistence, artifact save) by
- * invoking runAskProCommand with captured io, then returns structured fields
- * instead of printed lines. Registered only on the local stdio MCP server -
- * never on the HTTP MCP surface, which is exposed to ChatGPT itself.
+ * MCP-side counterpart to `pro browser recover`. A consult that outlives its
+ * budget hands back the thread it landed in, but until now the only way to act
+ * on that was a shell command - which an agent reaching prodex over MCP may not
+ * be able to run. Recovery has to be reachable the same way the consult was.
  */
+export async function performBrowserRecoverForMcp(cwd, input) {
+    const stdoutLines = [];
+    const stderrLines = [];
+    const argv = [
+        "browser",
+        "recover",
+        "--target-url",
+        input.thread,
+        ...(input.timeout_ms !== undefined ? ["--timeout-ms", String(input.timeout_ms)] : [])
+    ];
+    await runProCommand(argv, {
+        cwd,
+        stdout: (line) => stdoutLines.push(line),
+        stderr: (line) => stderrLines.push(line)
+    }, async () => 0);
+    const header = stdoutLines[0] ?? "";
+    const [taskId = "", status = "", thread = ""] = header.split("\t");
+    return {
+        task_id: taskId,
+        status,
+        thread,
+        answer: stdoutLines.slice(2).join("\n"),
+        notes: stderrLines
+    };
+}
 export async function performBrowserConsultForMcp(cwd, input, onProgress) {
     const stdoutLines = [];
     const stderrLines = [];

package/dist/cli.js

@@ -19,7 +19,7 @@ import { printHelpIfRequested, assertNoExtraArgs, assertOnlyOptions, formatCliCo
 import { listRawResultsForInspection, listTasksForInspection, runReceiptsCommand, runResultsCommand, runSessionsCommand, runTasksCommand } from "./cli-ledger.js";
 import { isMissingFileError, errorMessage, formatBrowserCheckCommand, formatBrowserLoginCommand, formatInitCommand, formatReleaseStatusCommand, formatSetupCommand, sourceAwareReleaseMessage, sourceAwareSetupMessage } from "./cli-shared.js";
 import { TOKEN_BEARING_MCP_URL_AUTHORITY_WARNING, redactServerUrl, runInitCommand, runSetupCommand, runStartCommand, runStatusCommand, runTunnelCommand } from "./cli-server.js";
-import { assertNoMissingTerminalConsultResults, assertNoOrphanConsultResults, formatConfigWarningLine, isConsultRecord, performBrowserConsultForMcp, runAskProCommand, runChatgptCommand, runConsultsCommand, runProCommand } from "./cli-pro.js";
+import { assertNoMissingTerminalConsultResults, assertNoOrphanConsultResults, formatConfigWarningLine, isConsultRecord, performBrowserConsultForMcp, performBrowserRecoverForMcp, runAskProCommand, runChatgptCommand, runConsultsCommand, runProCommand } from "./cli-pro.js";
 import { CLI_VERSION, printClaudeHelp, printDoctorHelp, printHelp, printMcpHelp, printOnboardHelp, printProjectHelp, printReleaseHelp } from "./cli-help.js";
 const execFileAsync = promisify(execFile);
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -208,7 +208,8 @@ export async function runCli(args, io = defaultIo()) {
         // pro_consult is stdio-only: the HTTP MCP surface is exposed to ChatGPT
         // itself (and possibly a tunnel) and must never drive the user's browser.
         await runMcpServer(mcpCwd, {
-            browserConsult: (input, onProgress) => performBrowserConsultForMcp(mcpCwd, input, onProgress)
+            browserConsult: (input, onProgress) => performBrowserConsultForMcp(mcpCwd, input, onProgress),
+            browserRecover: (input) => performBrowserRecoverForMcp(mcpCwd, input)
         });
         return 0;
     }
@@ -336,7 +337,7 @@ repo: ${cwd}
 2. Let coding agents consult ChatGPT (stdio MCP: Claude, Codex, Cursor, ...):
    ${cli} claude config --cwd ${quotedCwd}${sourceCliOption}
    ${cli} claude prompt --cwd ${quotedCwd}${sourceCliOption}
-   Agents get the bridge/ledger tools plus pro_consult (ask ChatGPT Pro directly; see docs/clients.md for Codex timeout and approval notes).
+   Agents get the bridge/ledger tools plus pro_consult (ask ChatGPT Pro directly; see docs/clients.md for Codex timeout and approval notes) and pro_recover (collect an answer that finished after a consult stopped waiting - including a deep research report).
    Saved setup defaults (--model/--project) apply to agent consults too - pin them once per repo so consults stop landing in the general chat list.
    Agents often run the MCP as \`prodex mcp\` with no --cwd, which misses a per-repo default. For a default that applies from ANY directory, set PRODEX_DEFAULT_PROJECT and PRODEX_DEFAULT_MODEL (in the agent's MCP env block, or your shell) to YOUR project/model. No project? Consults just go to the general chat. List your exact project names with \`${cli} pro browser projects\`.
    ${cli} pro debate-prompt --topic "your question"${sourceCliOption}  # structured GPT Pro debate prompt for your agent

package/dist/mcp.js

@@ -154,7 +154,7 @@ export function createServer(cwd = process.cwd(), options = {}) {
                     .array(McpShortTextSchema)
                     .max(4)
                     .optional()
-                    .describe("ChatGPT composer tools to enable for this consult: \"deep-research\" (a multi-minute browsed report - the timeout rises to 30 minutes automatically), \"web-search\" (current facts), \"create-image\". Deep research often replies with a CLARIFYING QUESTION first; answer it with a normal follow-up consult in the same thread."),
+                    .describe("ChatGPT composer tools to enable for this consult: \"deep-research\" (a browsed report; prodex presses start and waits out the run, which takes about ten minutes, so the timeout rises to 30 minutes automatically and the FULL report comes back as the answer - if the budget still runs out, the blocker carries the thread and pro_recover collects the report later), \"web-search\" (current facts, with the sources kept as links), \"create-image\". Deep research sometimes replies with a CLARIFYING QUESTION instead; answer it with a normal follow-up consult in the same thread."),
                 attach: z
                     .array(McpShortTextSchema)
                     .max(10)
@@ -187,6 +187,16 @@ export function createServer(cwd = process.cwd(), options = {}) {
             return asText(await browserConsult(input, onProgress));
         });
     }
+    const browserRecover = options.browserRecover;
+    if (browserRecover) {
+        server.registerTool("pro_recover", {
+            description: "Fetch a ChatGPT answer that finished AFTER a consult stopped waiting, and record it as a normal consult receipt. Use this whenever pro_consult came back with a timeout or a still-running blocker: those carry the thread URL, and the answer is almost always sitting in that thread. This is also how a deep research report is collected - a research run takes about ten minutes and keeps going even when the consult that started it has already returned. Reading is cheap and does not send anything, so it is safe to retry.",
+            inputSchema: {
+                thread: McpShortTextSchema.min(1).describe("The ChatGPT conversation URL from the blocker (its `thread` field)."),
+                timeout_ms: z.number().int().positive().max(600_000).optional()
+            }
+        }, async (input) => asText(await browserRecover(input)));
+    }
     return server;
 }
 export async function runMcpServer(cwd = process.cwd(), options = {}) {

package/docs/claude.md

@@ -99,6 +99,7 @@ The server currently exposes ledger-first tools:
 - `repo_write_file_apply`
 - `repo_stage_reviewed_paths`
 - `pro_consult`
+- `pro_recover`
 
 `bridge_complete_task` and `bridge_block_task` close tasks by writing durable `.bridge/results` records; they do not modify repo files. `bridge_fetch_result_artifact` only returns text artifacts that are listed on a result record and stored under `.bridge/artifacts/pro-consults/` or `.bridge/artifacts/results/`; it does not expose arbitrary `.bridge/artifacts` files. Newly finalized result artifacts record a sha256, and fetch rejects the artifact if its content changed afterward. The bridge rejects oversized result artifacts before task finalization; if a Pro browser answer is too large for `bridge_fetch_result_artifact`, it stays in the result summary with `answer_artifact_warning` instead of listing an unfetchable artifact.
 
@@ -106,7 +107,9 @@ Write tools are narrow and receipt-gated, and they require a git worktree with a
 
 `pro_consult` lets Claude ask your logged-in ChatGPT (Pro) directly: it drives the same explicit visible-browser consult as `prodex pro browser ask` (human-paced, blocker-gated, receipt-recorded, answer saved under `.bridge/artifacts/pro-consults/`) and can take minutes for Pro extended reasoning. It requires a prior `prodex pro browser login` session and is registered only on the local stdio MCP server — the HTTP MCP surface never exposes it, so nothing reachable through a tunnel or ChatGPT itself can drive your browser.
 
-No shell, public tunnel, direct ungated write, or direct ungated staging tools are exposed through the Claude stdio MCP server; the only browser-facing tool is the explicit `pro_consult` consult described above.
+`pro_recover` collects an answer that finished after a consult stopped waiting. A timed-out or still-running consult returns the thread it landed in, and the answer is almost always sitting there; this is also how a deep research report is collected, since a research run keeps going after the consult that started it has returned. It reads a thread and sends nothing, so retrying it is safe. Like `pro_consult`, it is registered only on the local stdio MCP server.
+
+No shell, public tunnel, direct ungated write, or direct ungated staging tools are exposed through the Claude stdio MCP server; the only browser-facing tools are the explicit `pro_consult` consult and the read-only `pro_recover` described above.
 
 ## First Prompt
 

package/docs/clients.md

@@ -48,6 +48,13 @@ consult you expect. Claude Code needs no change: its default stdio tool
 timeout is effectively unlimited (~28h) unless you tightened `MCP_TOOL_TIMEOUT`
 or a per-server `"timeout"`.
 
+A deep research consult (`tools: ["deep-research"]`) is the longest of these:
+the run takes about ten minutes and prodex raises its own budget to 30, so a
+client timeout below that aborts the call while the research keeps going. That
+is recoverable rather than lost - `pro_recover` with the thread from the
+blocker collects the report afterwards - but a client budget that covers the
+run avoids the round trip.
+
 Approval gate (verified on Codex 0.142.5): Codex asks for per-call approval
 before invoking prodex MCP tools. In interactive `codex` sessions you simply
 approve the prompt. In non-interactive `codex exec`, the approval cannot be

package/package.json

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