@youdie006/prodex 0.40.11 → 0.40.12

package/README.md

@@ -115,7 +115,7 @@ a configurable approval checkpoint (default 5, not a target round count); an
 See [same-task dialogue](docs/clients.md#same-task-dialogue) for the budget and
 `user_approved` contract. New topics still start fresh chats.
 
-Updating the installed npm package does not reload an MCP process that is already running. Reconnect the MCP server or restart the Codex/Claude client to load the new build. The dedicated browser profile is separate and remains signed in, so this does not require ChatGPT authentication again.
+Updating the installed npm package does not reload an MCP process that is already running. Reconnect the MCP server or restart the Codex/Claude client to load the new build. This preserves the separate dedicated browser profile and does not itself require another login. ChatGPT can still expire the saved session; a `login_required` blocker means you need to sign in manually again.
 
 An MCP server usually starts without `--cwd`, so a per-repo default can be missed. For defaults that apply from any directory, set `PRODEX_DEFAULT_PROJECT`, `PRODEX_DEFAULT_MODEL`, `PRODEX_DEFAULT_EFFORT` or `PRODEX_DEFAULT_PRO_MODE` in the agent's MCP `env` block; a per-repo config still wins field by field.
 
@@ -245,6 +245,12 @@ Reports are deduplicated by blocker code, so something that stays broken adds to
 
 ## FAQ
 
+**Do I need tmux?** No. Explicit CLI commands work in a normal terminal, and stdio MCP works through pipes without a terminal. Only the interactive picker and `setup --interactive` need keyboard input from a terminal. Keep the calling CLI or agent running while waiting for an answer: closing its terminal or disconnecting SSH can interrupt collection. tmux is an optional way to keep that foreground session alive, not a requirement. `prodex start` is also a foreground process, not an installed service.
+
+**Can I close the terminal after login?** Yes, once login is READY: the dedicated Chrome is launched separately. Keep that browser running for consults. If a CLI or agent exits during a request, ChatGPT may still finish it; recover the original thread and request ID rather than automatically sending the question again.
+
+**It stopped with `browser_tab_crashed` or `Runtime.enable`.** Chrome can leave an "Aw, Snap!" tab listed on its control port even though that tab's renderer has crashed. Before typing a new prompt, prodex can reload a confirmed crashed tab once at the same conversation address and records `browser_tab_recovered`. A timeout alone never authorizes a reload. A crash after a prompt was submitted stops without resending; inspect the original conversation, then recover with both `--target-url` and `--request-id` from the blocker. Other tabs, the browser profile, and saved login are left alone.
+
 **A send failed with `send_ui_changed`.** ChatGPT redesigned the composer or send control. Update (`npm i -g @youdie006/prodex@latest`); if it persists, `prodex pro report-issue`, and paste the prompt by hand meanwhile.
 
 **It stopped with `tab_not_visible`.** A tab counts as watchable only while its window is not minimized and it is the active tab. Leave the dedicated window behind your editor and it sends in the background; prodex never steals focus (`PRODEX_ACTIVATE_TAB=1` if you want the tab pulled forward on a stopped send).

package/dist/chatgpt-browser.js

@@ -4,6 +4,7 @@ import { accessSync, constants, statSync } from "node:fs";
 import net from "node:net";
 import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import WsWebSocket from "ws";
 import { captureBrowserDiagnostics, diagnosticsEnabled, diagnosticsNote } from "./browser-diagnostics.js";
 import { withCrossProcessFileLock } from "./safe-file.js";
 import os from "node:os";
@@ -17,6 +18,22 @@ export class ChatGptBrowserBlockerError extends Error {
         this.blocker = blocker;
     }
 }
+function crashedTabBlocker(thread, requestId) {
+    return {
+        code: "browser_tab_crashed",
+        message: "Chrome reported that this ChatGPT tab's renderer crashed. The browser itself may still be running.",
+        retryable: false,
+        next_step: requestId
+            ? `Do not resend automatically. Reload the crashed tab at the same address, then ${thread
+                ? `collect the original answer with \`prodex pro browser recover --target-url ${thread} --request-id ${requestId}\`.`
+                : `find [prodex-request:${requestId}] in the original conversation before recovering its answer; its thread URL was not captured.`}`
+            : "Before typing, prodex can reload a confirmed crashed tab once at the same address. If it crashes again, inspect Chrome's error screen; do not restart other tabs or resend an uncertain request.",
+        ...(thread ? { thread } : {})
+    };
+}
+function isCrashedTabError(error) {
+    return error instanceof ChatGptBrowserBlockerError && error.blocker.code === "browser_tab_crashed";
+}
 function unsupportedChatGptOperationError(operation, nextStep) {
     return new ChatGptBrowserBlockerError({
         code: "unsupported_chatgpt_operation",
@@ -1410,9 +1427,18 @@ export async function getChatGptBrowserStatus(options = {}) {
     // `pro browser check --timeout-ms 5000` measured 65 seconds because every
     // evaluate silently used the default. Agents read that silence as a hung
     // bridge and start "recovering" a browser that is merely busy.
-    const state = await evaluateOnPage(page.page, statusExpression(), {
-        ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {})
-    });
+    let state;
+    try {
+        state = await evaluateOnPage(page.page, statusExpression(), {
+            ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {})
+        });
+    }
+    catch (error) {
+        if (!isCrashedTabError(error))
+            throw error;
+        return { reachable: true, loggedInLikely: false, hasComposer: false, modelHints: [],
+            url: page.page.url, blocker: crashedTabBlocker(page.page.url) };
+    }
     const loggedInLikely = inferChatGptPageLoggedInLikely(state);
     // The busy verdict is checked against the transcript here too, so `check`
     // does not report a finished conversation as one still being written.
@@ -1862,6 +1888,47 @@ async function reloadPageAndAwaitComposer(page) {
         cdp.close();
     }
 }
+/** A crashed renderer cannot mark its document or enable Runtime before reload. */
+async function recoverCrashedPageBeforeSend(port, page) {
+    const cdp = await connectCdp(page.webSocketDebuggerUrl, 2_000);
+    try {
+        if (!cdp.crashed())
+            return { state: await readSettledChatGptPageStatus(page), reloaded: false };
+        const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(2_000) });
+        if (!response.ok)
+            throw new Error("Could not verify the crashed tab before reload");
+        const pages = await response.json();
+        const current = pages.find((candidate) => candidate.webSocketDebuggerUrl === page.webSocketDebuggerUrl && candidate.id === page.id);
+        if (!current)
+            throw new Error("The crashed ChatGPT tab closed before recovery; nothing was reloaded");
+        assertChatGptTargetUrlMatches(current.url, page.url);
+        if (!cdp.crashed())
+            return { state: await readSettledChatGptPageStatus(page), reloaded: false };
+        const reply = await cdp.send("Page.reload");
+        if (reply.error?.message)
+            throw new Error(`Page.reload failed: ${reply.error.message}`);
+        const deadline = Date.now() + RELOAD_SETTLE_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            await sleep(250);
+            try {
+                const state = await cdp.evaluate(statusExpression());
+                if (detectChatGptPageBlocker(state))
+                    return { state, reloaded: true };
+                assertChatGptTargetUrlMatches(state.url, page.url);
+                if (state.hasComposer)
+                    return { state, reloaded: true };
+            }
+            catch (error) {
+                if (!/execution context|cannot find context|Runtime\.evaluate failed/i.test(error instanceof Error ? error.message : String(error)))
+                    throw error;
+            }
+        }
+        throw new ChatGptBrowserBlockerError(crashedTabBlocker(page.url));
+    }
+    finally {
+        cdp.close();
+    }
+}
 // Every alternative is wording measured on the error page itself, anchored so
 // the whole body has to be made of them and nothing else. It may repeat one:
 // the heading and the button carry the same words.
@@ -3246,7 +3313,22 @@ export async function sendChatGptPrompt(options) {
         assertChatGptPageAvailable();
     }
     const page = pageResult.page;
-    let status = await readSettledChatGptPageStatus(page);
+    const preflightWarnings = [];
+    let status;
+    try {
+        status = await readSettledChatGptPageStatus(page);
+    }
+    catch (error) {
+        if (!isCrashedTabError(error))
+            throw error;
+        emitProgress("waiting", "Chrome reported a crashed tab; checking same-tab recovery before typing");
+        const recovered = await recoverCrashedPageBeforeSend(port, page);
+        status = recovered.state;
+        if (recovered.reloaded) {
+            preflightWarnings.push("browser_tab_recovered: Chrome reported a crashed tab; reloaded the same conversation before typing. No previous prompt was resent.");
+            emitProgress("waiting", "crashed tab reloaded at the same address; rechecking readiness");
+        }
+    }
     status = await ensureVisibleChatGptPage(port, page, status);
     const blocker = detectChatGptPageBlocker(status);
     if (blocker) {
@@ -3426,7 +3508,7 @@ export async function sendChatGptPrompt(options) {
     let beforeSubmit;
     let boundProjectId;
     let submitButtonFound = false;
-    const sendWarnings = [];
+    const sendWarnings = [...preflightWarnings];
     // Anything the page put in front of prodex was answered on the caller's
     // behalf. The note is read at return time - there are several return paths -
     // so it is folded into the array rather than pushed from each of them.
@@ -3593,6 +3675,8 @@ export async function sendChatGptPrompt(options) {
         // looks the way it looked when it refused, and the selection failures this
         // project keeps hitting are invisible in the error text alone.
         await captureOnFailure(`send-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+        if (isCrashedTabError(error))
+            throw attachSendWarnings(new ChatGptBrowserBlockerError(crashedTabBlocker(undefined, requestId)), sendWarnings);
         throw attachSendWarnings(error, sendWarnings);
     }
     finally {
@@ -3608,7 +3692,9 @@ export async function sendChatGptPrompt(options) {
         try {
             finalState = await evaluateOnPage(page, answerExpression());
         }
-        catch {
+        catch (error) {
+            if (isCrashedTabError(error))
+                throw attachSendWarnings(new ChatGptBrowserBlockerError(crashedTabBlocker(undefined, requestId)), sendWarnings);
             // Transient CDP failure (command timeout, mid-poll navigation): retry the
             // poll rather than aborting the whole send.
             continue;
@@ -3704,6 +3790,8 @@ export async function sendChatGptPrompt(options) {
             finalState = observedState;
         }
         catch (error) {
+            if (isCrashedTabError(error))
+                throw attachSendWarnings(new ChatGptBrowserBlockerError(crashedTabBlocker(pinnedThreadUrl, requestId)), sendWarnings);
             if (error instanceof ChatGptBrowserBlockerError)
                 throw error;
             // Transient CDP failure while the answer is streaming: retry. A throw here
@@ -3713,7 +3801,7 @@ export async function sendChatGptPrompt(options) {
             // sitting out the whole budget on it only delays the recovery.
             consecutiveReadFailures += 1;
             if (consecutiveReadFailures >= CONSECUTIVE_READ_FAILURES_BEFORE_GIVING_UP) {
-                throw new ChatGptBrowserBlockerError(browserLostMidWaitBlocker(pinnedThreadUrl ?? finalState?.url));
+                throw new ChatGptBrowserBlockerError(browserLostMidWaitBlocker(pinnedThreadUrl ?? finalState?.url, requestId));
             }
             continue;
         }
@@ -4417,8 +4505,10 @@ async function getChatGptPageVisibility(pages) {
         try {
             visibilityByPage.set(page.webSocketDebuggerUrl, await evaluateOnPage(page, "document.visibilityState", { timeoutMs: PAGE_VISIBILITY_PROBE_TIMEOUT_MS }));
         }
-        catch {
-            // Leave visibility unknown; untargeted sends treat unknown ChatGPT pages conservatively.
+        catch (error) {
+            if (isCrashedTabError(error))
+                visibilityByPage.set(page.webSocketDebuggerUrl, "crashed");
+            // Other failures leave visibility unknown; untargeted sends treat them conservatively.
         }
     }));
     return visibilityByPage;
@@ -4463,9 +4553,11 @@ export function resolveCdpTimeoutMs(explicit) {
 }
 async function connectCdp(webSocketUrl, timeoutMs) {
     const effectiveTimeoutMs = resolveCdpTimeoutMs(timeoutMs);
-    const ws = new WebSocket(webSocketUrl);
+    const WebSocketConstructor = globalThis.WebSocket ?? WsWebSocket;
+    const ws = new WebSocketConstructor(webSocketUrl);
     let id = 0;
     const pending = new Map();
+    let crashError;
     /** Types of JavaScript dialog answered on this connection. */
     const dialogsAnswered = [];
     ws.addEventListener("message", (event) => {
@@ -4480,6 +4572,23 @@ async function connectCdp(webSocketUrl, timeoutMs) {
             // the per-command timeout fires.
             return;
         }
+        const method = message.method;
+        if (method === "Inspector.targetCrashed") {
+            crashError = new ChatGptBrowserBlockerError(crashedTabBlocker());
+            for (const [messageId, waiter] of pending) {
+                if (waiter.method === "Inspector.enable" || waiter.method === "Page.reload")
+                    continue;
+                if (waiter.timer)
+                    clearTimeout(waiter.timer);
+                pending.delete(messageId);
+                waiter.reject(crashError);
+            }
+            return;
+        }
+        if (method === "Inspector.targetReloadedAfterCrash") {
+            crashError = undefined;
+            return;
+        }
         if (message.id && pending.has(message.id)) {
             const waiter = pending.get(message.id);
             if (waiter.timer)
@@ -4505,7 +4614,7 @@ async function connectCdp(webSocketUrl, timeoutMs) {
         for (const [messageId, waiter] of pending) {
             if (waiter.timer)
                 clearTimeout(waiter.timer);
-            waiter.reject(new Error("Chrome DevTools websocket closed"));
+            waiter.reject(crashError ?? new Error("Chrome DevTools websocket closed"));
             pending.delete(messageId);
         }
     });
@@ -4544,13 +4653,15 @@ async function connectCdp(webSocketUrl, timeoutMs) {
     /** The timeout that closed this socket, so later commands can name it rather than a bare closed socket. */
     let closedByTimeout;
     const send = (method, params = {}) => {
+        if (crashError && method !== "Inspector.enable" && method !== "Page.reload")
+            return Promise.reject(crashError);
         // Once a timeout has closed the socket, every later command would sit out
         // its own full timeout for an answer that cannot come. Measured cost of not
         // checking: a 14-probe confirmation loop turning into minutes of silence.
         // The rejection carries the timeout that did the closing: a caller that
         // swallowed that first error and moved on would otherwise report "socket
         // not open", which names neither the stalled tab nor the dialog cure.
-        if (ws.readyState !== WebSocket.OPEN) {
+        if (ws.readyState !== WebSocketConstructor.OPEN) {
             return Promise.reject(new Error(closedByTimeout
                 ? `${closedByTimeout} (the connection was closed by that timeout before ${method})`
                 : `Chrome DevTools websocket is not open (${method})`));
@@ -4563,7 +4674,7 @@ async function connectCdp(webSocketUrl, timeoutMs) {
                 ws.close();
                 reject(new Error(closedByTimeout));
             }, Math.max(1, effectiveTimeoutMs));
-            pending.set(messageId, { resolve, reject, timer });
+            pending.set(messageId, { method, resolve, reject, timer });
             ws.send(JSON.stringify({ id: messageId, method, params }));
         });
     };
@@ -4576,6 +4687,15 @@ async function connectCdp(webSocketUrl, timeoutMs) {
     // caller's diagnosis from "command timed out: Runtime.enable" - which at
     // least names what was being attempted - into a bare "websocket closed".
     // Nothing waits on the arming, so a build without the domain is no worse off.
+    // Inspector is browser-side and replays an existing renderer crash. Runtime
+    // and DOM commands cannot diagnose that state because the renderer is gone.
+    try {
+        await send("Inspector.enable");
+    }
+    catch (error) {
+        ws.close();
+        throw error;
+    }
     ws.send(JSON.stringify({ id: ++id, method: "Page.enable", params: {} }));
     const evaluate = async (expression) => {
         const response = await send("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true });
@@ -4585,7 +4705,7 @@ async function connectCdp(webSocketUrl, timeoutMs) {
             throw new Error("Runtime.evaluate failed");
         return response.result?.result?.value;
     };
-    return { send, evaluate, dialogsAnswered, close: () => ws.close() };
+    return { send, evaluate, dialogsAnswered, crashed: () => crashError !== undefined, close: () => ws.close() };
 }
 // In-page reasoning-header placeholder test, shared by statusExpression and
 // answerExpression. MUST stay in sync with isUsableChatGptAnswer: a header
@@ -5154,7 +5274,7 @@ export function chunkComposerText(text, size = COMPOSER_INSERT_CHUNK_CHARS) {
 // Reading the page can fail for a moment (a navigation, a busy renderer). Five
 // failures in a row is not a moment - it is a browser that went away.
 const CONSECUTIVE_READ_FAILURES_BEFORE_GIVING_UP = 5;
-export function browserLostMidWaitBlocker(threadUrl) {
+export function browserLostMidWaitBlocker(threadUrl, requestId) {
     // Killing the browser aborts a streaming answer too, so promise nothing
     // about the answer itself - only say where to look. Deep research is the one
     // case that genuinely keeps going without us.
@@ -5165,8 +5285,8 @@ export function browserLostMidWaitBlocker(threadUrl) {
         // Retrying the send would duplicate a prompt that has already posted.
         retryable: false,
         next_step: threadUrl
-            ? `Run \`prodex pro browser login\` to reopen the browser, then collect the answer with \`prodex pro browser recover --target-url ${threadUrl}\` (MCP: pro_recover with thread ${threadUrl}).`
-            : "Run `prodex pro browser login` to reopen the browser, then inspect the original chat before asking again. The prompt was already submitted; prodex did not capture its thread URL.",
+            ? `Run \`prodex pro browser login\` to reopen the browser, then collect the answer with \`prodex pro browser recover --target-url ${threadUrl}${requestId ? ` --request-id ${requestId}` : ""}\` (MCP: pro_recover with thread ${threadUrl}${requestId ? ` and request_id ${requestId}` : ""}).`
+            : `Run \`prodex pro browser login\` to reopen the browser, then inspect the original chat before asking again. The prompt was already submitted; prodex did not capture its thread URL.${requestId ? ` Find [prodex-request:${requestId}] in that conversation before recovering its answer; do not resend automatically.` : ""}`,
         ...(threadUrl ? { thread: threadUrl } : {})
     };
 }

package/dist/cli-pro.js

@@ -1219,20 +1219,27 @@ export async function runAskProCommand(rest, io, beforeSend) {
         // the name matching to do what it can; the send would fail on the same
         // browser anyway.
         let continuationProjectId;
+        let ambiguousProjectName = false;
         if (continuationProject) {
             try {
-                continuationProjectId = projectIdFromSidebar(await listChatGptProjectsWithIds({ port: resolveCdpPort(readPortFlag(parsedAskPro.optionArgs, "--port")) }), continuationProject);
+                const projects = await listChatGptProjectsWithIds({ port: resolveCdpPort(readPortFlag(parsedAskPro.optionArgs, "--port")) });
+                continuationProjectId = projectIdFromSidebar(projects, continuationProject);
+                ambiguousProjectName = !continuationProjectId && projects.some((project) => project.name.trim().toLowerCase() === continuationProject.trim().toLowerCase());
             }
             catch {
                 continuationProjectId = undefined;
             }
         }
+        if (ambiguousProjectName && continueTaskId === undefined) {
+            throw new Error(`Project name "${continuationProject}" is ambiguous in the sidebar. Name the intended conversation with --continue-task <task_id>.`);
+        }
         const resolved = resolveContinuationThread({
             consults: (await targetStore.listSessionsReadOnly()).map((session) => ({
                 taskId: session.task_id ?? "",
                 ...(session.session_key ? { sessionKey: session.session_key } : {}),
                 ...(session.thread ? { thread: session.thread } : {}),
                 status: session.status,
+                warnings: session.warnings,
                 ...(session.created_at ? { createdAt: session.created_at } : {})
             })),
             ...(continuationProject ? { project: continuationProject } : {}),
@@ -1569,6 +1576,9 @@ export async function runAskProCommand(rest, io, beforeSend) {
         });
         if (destination.warning)
             persistenceWarnings.push(destination.warning);
+        if (consult.requestVerified === false && !persistenceWarnings.some((warning) => warning.startsWith("request_unverified:"))) {
+            persistenceWarnings.push("request_unverified: the saved answer was not verified against its requested user turn. Review the original conversation before continuing.");
+        }
         // 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.
@@ -2536,8 +2546,9 @@ export function browserSendBlockerFromError(error) {
             code: "browser_cdp_timeout",
             message,
             retryable: true,
-            next_step: "The ChatGPT tab stopped responding. A very long thread does it, and so does an open JavaScript dialog - that one halts the page outright, and no retry gets past it because the browser will not let a late client dismiss it. " +
-                "Look at the visible window and close any dialog sitting on it, or reopen the window with `prodex pro browser login`. For a heavy thread, retry with `--new-chat` for a fresh, light one."
+            next_step: "The ChatGPT tab stopped responding; a timeout alone does not prove it crashed. A long thread or an open JavaScript dialog can also stall it. " +
+                "Inspect the visible tab: if Chrome shows 'Aw, Snap!', reload only that tab at the same address. Close an ordinary dialog manually; login, verification, and permission prompts require your action. " +
+                "If the browser is gone, reopen it with `prodex pro browser login`. Do not resend automatically when the prompt may already have posted; recover its original thread and request ID. Use `--new-chat` only for a new request after the original is accounted for."
         };
     }
     return {

package/dist/continue-thread.js

@@ -72,6 +72,9 @@ export function projectIdsByName(threadUrls) {
     }
     return byName;
 }
+function projectIdFromThreadUrl(threadUrl) {
+    return /\/g\/g-p-([0-9a-f]+)(?:-|\/)/i.exec(threadUrl)?.[1]?.toLowerCase();
+}
 /**
  * Whether a recorded thread belongs to the project this send is for.
  *
@@ -153,13 +156,22 @@ export function resolveContinuationThread(input) {
                 "Pass --session-key <id> (or PRODEX_SESSION_KEY/CODEX_THREAD_ID), or name the intended consult with --continue-task <task_id>."
         };
     }
-    const knownProjectIds = new Set(input.project ? projectIdsByName(withThread.map((consult) => consult.thread)).get(chatGptProjectSlug(input.project)) ?? [] : []);
-    if (input.projectId)
-        knownProjectIds.add(input.projectId.toLowerCase());
+    const recordedProjectIds = new Set(input.project ? projectIdsByName(withThread.map((consult) => consult.thread)).get(chatGptProjectSlug(input.project)) ?? [] : []);
+    if (input.project && !input.projectId && recordedProjectIds.size > 1) {
+        return {
+            error: `Recorded project name "${input.project}" is ambiguous because its consult threads use multiple project ids. ` +
+                "Name the intended conversation with --continue-task <task_id>."
+        };
+    }
+    const selectedProjectId = input.project
+        ? input.projectId?.replace(/^g-p-/i, "").toLowerCase() ?? recordedProjectIds.values().next().value
+        : undefined;
     const candidates = withThread
         .filter((consult) => consult.sessionKey === input.sessionKey)
         .filter((consult) => consult.status === "done")
-        .filter((consult) => threadMatchesProject(consult.thread, input.project, knownProjectIds))
+        .filter((consult) => selectedProjectId
+        ? projectIdFromThreadUrl(consult.thread) === selectedProjectId
+        : threadMatchesProject(consult.thread, input.project))
         .sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
     const latest = candidates[0];
     if (!latest) {
@@ -169,5 +181,18 @@ export function resolveContinuationThread(input) {
                 `Send once without --continue, or name a consult with --continue-task <task_id>.`
         };
     }
+    const unreliableWarningPrefixes = [
+        "answer_incomplete:",
+        "request_unverified:",
+        "receipt_record_warning:",
+        "session_record_warning:"
+    ];
+    const unreliableWarning = latest.warnings?.find((warning) => unreliableWarningPrefixes.some((prefix) => warning.startsWith(prefix)));
+    if (unreliableWarning) {
+        return {
+            error: `Cannot implicitly continue consult "${latest.taskId}" because its record is unreliable: ${unreliableWarning} ` +
+                `Recover and verify the original answer first. After explicit user review, name it with --continue-task ${latest.taskId}. Do not resend automatically.`
+        };
+    }
     return { target: { taskId: latest.taskId, thread: latest.thread } };
 }

package/dist/issue-report.js

@@ -49,9 +49,7 @@ export function buildIssueReport(consult, environment) {
         `| platform | ${environment.platform} |`,
         `| node | ${environment.nodeVersion} |`,
         "",
-        "Private error details and recovery instructions are omitted. Review the local receipt before sharing more context.",
-        "",
-        "Receipt (local, not attached): " + consult.task_id
+        "Private error details and recovery instructions are omitted. Review the local receipt before sharing more context."
     ].join("\n");
     return {
         title: `${code}: ${message || "blocked consult"}`.slice(0, 120),

package/docs/clients.md

@@ -74,9 +74,17 @@ already-resolved target). An answer that failed to save or is incomplete does no
 invite another automatic turn; report it and resolve the blocker first.
 
 After updating the installed package, reconnect the MCP server or restart the agent
-client. A running stdio process keeps the old code until it exits. The dedicated
-browser profile is unchanged, so restarting Codex/Claude does not require signing in
-to ChatGPT again.
+client. A running stdio process keeps the old code until it exits. This preserves the
+dedicated browser profile and does not itself require signing in again. A saved
+ChatGPT session can still expire independently; stop on `login_required` and finish
+the login manually.
+
+Stdio MCP does not require tmux or a terminal. The client launches prodex and keeps
+its stdin/stdout pipes open. Keep that client or its remote SSH session running
+while a consult is pending; restarting it can interrupt answer collection even if
+ChatGPT is still generating. Recover that marked request instead of resending it.
+The separate `prodex start` HTTP server runs in the foreground and also needs its
+own process kept alive; neither command installs a background service.
 
 ## Claude Code
 

package/docs/releasing.md

@@ -15,7 +15,7 @@ git tag v0.8.2
 git push origin v0.8.2
 ```
 
-`.github/workflows/publish.yml` fires on a `v*.*.*` tag: it checks out, installs, verifies the tag equals `package.json`'s version, runs `release:verify`, and publishes with `npm publish --provenance --access public`. The tag/version guard prevents publishing a mismatched version.
+`.github/workflows/publish.yml` fires on a `v*.*.*` tag: it checks out, installs, verifies the tag equals `package.json`'s version, builds, runs `release:check -- --metadata-only` and `release:verify`, then publishes with `npm publish --provenance --access public --ignore-scripts`. The explicit metadata check also runs for manual workflow dispatches. It is required because `--ignore-scripts` skips `prepublishOnly`; a separate main-branch CI run is not a substitute for checking the commit being published.
 
 One-time setup (owner, on npmjs.com): open the package → Settings → Trusted Publishing → add a GitHub Actions publisher for repo `youdie006/prodex` and workflow `publish.yml`. After that, no npm tokens are needed anywhere; revoke any previously issued automation tokens.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.40.11",
+  "version": "0.40.12",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",
@@ -59,12 +59,14 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.13.3",
+    "ws": "^8.21.3",
     "zod": "^3.25.67"
   },
   "devDependencies": {
     "@types/node": "^22.15.32",
+    "@types/ws": "^8.18.1",
     "tsx": "^4.20.3",
     "typescript": "^5.8.3",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.11"
   }
 }