@youdie006/prodex 0.40.6 → 0.40.8

package/dist/tui-run.js

@@ -8,6 +8,7 @@
  */
 import readline from "node:readline";
 import { renderBanner } from "./banner.js";
+import { shellQuote } from "./cli-args.js";
 import { destinationChoices, effortChoices, SEND_KINDS } from "./tui-flow.js";
 import { consultArgsFromChoices, conversationsInProject, conversationThreadUrl, moveCursor, parseAttachmentLine, progressLabel, renderContextPanel, renderProgressBar, renderSelectList } from "./tui.js";
 const ESC = "";
@@ -32,11 +33,18 @@ class KeyQueue {
     input;
     pending = [];
     waiting;
+    ended = false;
     constructor(input) {
         this.input = input;
         this.input.on("keypress", this.onKey);
+        this.input.on("end", this.onEnd);
+        this.input.on("close", this.onEnd);
+        if (this.input.readableEnded || this.input.destroyed)
+            this.onEnd();
     }
     onKey = (_str, key) => {
+        if (this.ended)
+            return;
         const value = key ?? {};
         if (this.waiting) {
             const resolve = this.waiting;
@@ -46,7 +54,16 @@ class KeyQueue {
         }
         this.pending.push(value);
     };
+    onEnd = () => {
+        this.ended = true;
+        this.pending.length = 0;
+        const resolve = this.waiting;
+        this.waiting = undefined;
+        resolve?.({ name: "c", ctrl: true });
+    };
     next() {
+        if (this.ended)
+            return Promise.resolve({ name: "c", ctrl: true });
         const buffered = this.pending.shift();
         if (buffered)
             return Promise.resolve(buffered);
@@ -60,6 +77,8 @@ class KeyQueue {
     }
     dispose() {
         this.input.off("keypress", this.onKey);
+        this.input.off("end", this.onEnd);
+        this.input.off("close", this.onEnd);
     }
 }
 let keys;
@@ -69,7 +88,7 @@ function readKey(_io) {
     return keys.next();
 }
 function isCancel(key) {
-    return (key.ctrl === true && key.name === "c") || key.name === "escape" || key.name === "q";
+    return (key.ctrl === true && (key.name === "c" || key.name === "d")) || key.name === "escape" || key.name === "q";
 }
 // Terminals disagree about the Enter key: a carriage return arrives as
 // "return", a line feed as "enter". Accept either, or the picker looks frozen.
@@ -121,15 +140,38 @@ function numericChoice(key, length) {
 async function askLine(io, question) {
     io.input.setRawMode?.(false);
     const rl = readline.createInterface({ input: io.input, output: process.stdout, terminal: true });
-    const answer = await new Promise((resolve) => rl.question(question, resolve));
-    rl.close();
-    // Closing the line reader detaches the keypress plumbing and pauses the
-    // stream, so the next picker would sit there ignoring every key. Re-arm both.
-    io.input.setRawMode?.(true);
-    readline.emitKeypressEvents(io.input);
-    io.input.resume();
-    keys?.drain();
-    return answer.trim();
+    try {
+        const answer = await new Promise((resolve) => {
+            let settled = false;
+            function settle(value) {
+                if (settled)
+                    return;
+                settled = true;
+                rl.off("SIGINT", onInterrupt);
+                rl.off("close", onClose);
+                resolve(value);
+            }
+            function onInterrupt() {
+                settle(undefined);
+            }
+            function onClose() {
+                settle(undefined);
+            }
+            rl.once("SIGINT", onInterrupt);
+            rl.once("close", onClose);
+            rl.question(question, (value) => settle(value));
+        });
+        return answer?.trim();
+    }
+    finally {
+        rl.close();
+        // Closing the line reader detaches the keypress plumbing and pauses the
+        // stream, so the next picker would sit there ignoring every key. Re-arm both.
+        io.input.setRawMode?.(true);
+        readline.emitKeypressEvents(io.input);
+        io.input.resume();
+        keys?.drain();
+    }
 }
 /**
  * Walk the questions a send needs, then run it with a moving progress bar.
@@ -253,6 +295,8 @@ export async function runInteractiveConsult(io, deps) {
         }
         else if (destination === "project-new") {
             projectName = await askLine(io, `${CLEAR}${header}New project\n\n  name: `);
+            if (projectName === undefined)
+                return cancel(io);
             if (!projectName)
                 return cancel(io);
             projectMode = "new";
@@ -265,6 +309,8 @@ export async function runInteractiveConsult(io, deps) {
         const kindLabel = SEND_KINDS[kindChoice].label;
         const prompt = await askLine(io, `${kindLabel}   Step ${steps} of ${steps}\n\n  prompt: `);
         io.write(HIDE_CURSOR);
+        if (prompt === undefined)
+            return cancel(io);
         if (prompt.length === 0) {
             io.write("Nothing to ask.\n");
             return 1;
@@ -273,8 +319,11 @@ export async function runInteractiveConsult(io, deps) {
         // image, and the picker had no way to say so. Asked after the prompt, and
         // skipped by pressing enter, so the common case costs one keystroke.
         io.write(SHOW_CURSOR);
-        const attachments = parseAttachmentLine(await askLine(io, "\n  attach files? repo-relative paths, space separated, enter to skip\n  files: "));
+        const attachmentLine = await askLine(io, "\n  attach files? repo-relative paths, space separated, enter to skip\n  files: ");
         io.write(HIDE_CURSOR);
+        if (attachmentLine === undefined)
+            return cancel(io);
+        const attachments = parseAttachmentLine(attachmentLine);
         const choices = {
             prompt,
             projectMode,
@@ -295,20 +344,8 @@ export async function runInteractiveConsult(io, deps) {
         // stop", and under raw mode that promise was false for the whole ten
         // minutes a deep research send runs. No key is read from here on.
         io.input.setRawMode?.(false);
-        // --target-url confirms which conversation a send means; it deliberately
-        // does not navigate. Picking one from a list IS a request to go there, so
-        // move the tab first and let the flag confirm it landed.
-        if (targetUrl && deps.openThread) {
-            io.write("Opening the conversation you picked...\n");
-            if (!(await deps.openThread(targetUrl))) {
-                io.write(`Could not open ${targetUrl} in the dedicated browser.\n`);
-                return 1;
-            }
-        }
         io.write(`Sending. Equivalent command:\n  prodex ${formatCommand(args)}\n\n`);
-        // Deep research runs about ten minutes; an ordinary Pro answer, minutes.
-        // Fill the bar against that so the wait has a shape.
-        const budgetMs = tools.includes("deep-research") ? 30 * 60_000 : 20 * 60_000;
+        const budgetMs = 20 * 60_000;
         const startedAt = now();
         let label = "starting";
         let tick = 0;
@@ -345,5 +382,5 @@ function cancel(io) {
 }
 /** Quote only what a shell would need quoted, so the echo can be pasted. */
 export function formatCommand(args) {
-    return args.map((arg) => (/^[A-Za-z0-9._\-/:=]+$/.test(arg) ? arg : JSON.stringify(arg))).join(" ");
+    return args.map(shellQuote).join(" ");
 }

package/dist/tui.js

@@ -75,35 +75,33 @@ export function parseAttachmentLine(line) {
 /**
  * Projects with the id their conversations are tagged with.
  *
- * The sidebar gives names only, which is enough to ENTER a project but not to
- * tell which chats live in it - and "open the project, then pick the session
- * inside it" needs exactly that link.
+ * Read only rendered links. A project id is accepted only when the visible
+ * anchor itself has a canonical ChatGPT project URL.
  */
 export function projectsWithIdsExpression() {
-    return `(async () => {
-  let token = "";
-  try {
-    const session = await fetch("/api/auth/session", { credentials: "include" });
-    if (!session.ok) return [];
-    const parsed = await session.json();
-    token = (parsed && parsed.accessToken) || "";
-  } catch (error) {
-    return [];
-  }
-  try {
-    const response = await fetch("/backend-api/gizmos/snorlax/sidebar", {
-      credentials: "include",
-      headers: token ? { Authorization: "Bearer " + token } : {}
-    });
-    if (!response.ok) return [];
-    const listed = await response.json();
-    return ((listed && listed.items) || [])
-      .map((item) => item && item.gizmo)
-      .filter((gizmo) => gizmo && gizmo.id)
-      .map((gizmo) => ({ id: gizmo.id, name: ((gizmo.display && gizmo.display.name) || gizmo.name || "").trim() || gizmo.id }));
-  } catch (error) {
-    return [];
+    return `(() => {
+  const out = [];
+  const seen = new Set();
+  for (const anchor of document.querySelectorAll("a[href]")) {
+    if (out.length >= 100) break;
+    if (typeof anchor.getClientRects !== "function" || anchor.getClientRects().length === 0) continue;
+    let url;
+    try {
+      url = new URL(anchor.getAttribute("href") || "", "https://chatgpt.com");
+    } catch (error) {
+      continue;
+    }
+    if (url.protocol !== "https:" || url.hostname !== "chatgpt.com" || url.port || url.username || url.password) continue;
+    const match = /^\\/g\\/g-p-([0-9a-f]{1,128})(?:-[^/]+)?\\/project\\/?$/i.exec(url.pathname);
+    if (!match) continue;
+    const id = "g-p-" + match[1].toLowerCase();
+    if (seen.has(id)) continue;
+    const name = ((anchor.textContent || anchor.getAttribute("aria-label") || "").replace(/\\s+/g, " ").trim()).slice(0, 200);
+    if (!name) continue;
+    seen.add(id);
+    out.push({ id, name });
   }
+  return out;
 })()`;
 }
 /** The conversations that live inside a project, or all of them without one. */
@@ -114,37 +112,53 @@ export function conversationsInProject(conversations, projectId) {
 }
 /**
  * Recent conversations with their titles, for the "continue an existing chat"
- * list. Only the sidebar listing is fetched - the transcripts themselves are
- * large and nothing here needs them.
+ * list. This is deliberately limited to rendered links; no account API or
+ * transcript is read. A project association is included only when that same
+ * visible conversation URL carries the project id.
  */
 export function recentConversationTitlesExpression(limit = 10) {
-    return `(async () => {
-  let token = "";
-  try {
-    const session = await fetch("/api/auth/session", { credentials: "include" });
-    if (!session.ok) return [];
-    const parsed = await session.json();
-    token = (parsed && parsed.accessToken) || "";
-  } catch (error) {
-    return [];
-  }
-  try {
-    const response = await fetch("/backend-api/conversations?offset=0&limit=${limit}&order=updated", {
-      credentials: "include",
-      headers: token ? { Authorization: "Bearer " + token } : {}
-    });
-    if (!response.ok) return [];
-    const listed = await response.json();
-    return ((listed && listed.items) || [])
-      .filter((item) => item && item.id)
-      .map((item) => ({
-        id: item.id,
-        title: (item.title || "").trim() || "Untitled",
-        ...(item.gizmo_id ? { gizmoId: item.gizmo_id } : {})
-      }));
-  } catch (error) {
-    return [];
+    const boundedLimit = Number.isFinite(limit) ? Math.max(0, Math.min(100, Math.floor(limit))) : 10;
+    return `(() => {
+  const out = [];
+  const seen = new Map();
+  const ambiguousProjects = new Set();
+  let inspected = 0;
+  for (const anchor of document.querySelectorAll("a[href]")) {
+    if (++inspected > 2000) break;
+    if (typeof anchor.getClientRects !== "function" || anchor.getClientRects().length === 0) continue;
+    let url;
+    try {
+      url = new URL(anchor.getAttribute("href") || "", "https://chatgpt.com");
+    } catch (error) {
+      continue;
+    }
+    if (url.protocol !== "https:" || url.hostname !== "chatgpt.com" || url.port || url.username || url.password) continue;
+    const projectMatch = /^\\/g\\/g-p-([0-9a-f]{1,128})(?:-[^/]+)?\\/c\\/([0-9a-f-]{16,128})\\/?$/i.exec(url.pathname);
+    const plainMatch = /^\\/c\\/([0-9a-f-]{16,128})\\/?$/i.exec(url.pathname);
+    const id = (projectMatch && projectMatch[2]) || (plainMatch && plainMatch[1]);
+    if (!id) continue;
+    const gizmoId = projectMatch ? "g-p-" + projectMatch[1].toLowerCase() : undefined;
+    const existing = seen.get(id);
+    if (existing) {
+      if (gizmoId && !ambiguousProjects.has(id)) {
+        if (existing.gizmoId && existing.gizmoId !== gizmoId) {
+          delete existing.gizmoId;
+          ambiguousProjects.add(id);
+        } else existing.gizmoId = gizmoId;
+      }
+      continue;
+    }
+    if (out.length >= ${boundedLimit}) continue;
+    const title = ((anchor.textContent || anchor.getAttribute("aria-label") || "").replace(/\\s+/g, " ").trim()).slice(0, 300) || "Untitled";
+    const entry = {
+      id,
+      title,
+      ...(gizmoId ? { gizmoId } : {})
+    };
+    seen.set(id, entry);
+    out.push(entry);
   }
+  return out;
 })()`;
 }
 const ESC = "";

package/docs/claude.md

@@ -107,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.
 
-`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.
+`pro_recover` reads a finished, rendered answer after a consult stopped waiting. It verifies the requested conversation and refuses still-generating or unstable content. It sends nothing. Deep-research widget reports are not supported; current builds block automated deep-research sends before posting. Like `pro_consult`, recovery is registered only on the local stdio MCP server.
+
+Generic bridge result/session/task tools redact ChatGPT thread metadata, including nested blockers; local `pro_consult` recovery information remains available. A legacy result artifact with no saved hash returns `legacy_artifact_unverified` rather than implying its bytes were verified. `sessions cancel` only clears stale bookkeeping after a send was interrupted; it does not stop an active consult.
 
 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.
 

package/docs/cli-reference.md

@@ -82,6 +82,7 @@ Use this only when you explicitly want to use your logged-in ChatGPT Pro web ses
 ```bash
 prodex pro browser login --dry-run
 prodex pro browser login
+prodex pro browser login --headed  # force a visible window for interactive reauthentication
 prodex pro browser help
 prodex pro browser check
 prodex pro browser smoke --cwd /absolute/path/to/your/repo
@@ -105,6 +106,7 @@ What happens:
 
 - `login --dry-run` prints the dedicated Chrome profile, debug URL, and next commands without opening a browser.
 - `login` opens that dedicated Chrome profile at ChatGPT. In an interactive terminal it then waits (default 5 minutes; `--no-wait` skips, `--wait-timeout-ms` tunes) and narrates which manual step is still missing until it reports READY; scripts and agents get the immediate return unless they pass `--wait`.
+- `login` reuses the last profile recorded for the resolved debug port when `--profile-dir` is omitted. It does not reuse a saved custom port implicitly: `--port` / `PRODEX_CDP_PORT` / the normal `9333` default still resolve the port exactly as before.
 - You log in manually in the visible browser.
 - If ChatGPT asks for captcha, Cloudflare/human verification, permission, or account verification, handle it in that browser.
 - If ChatGPT shows a usage limit, message limit, model limit, or rate limit, wait for the reset or choose an available model in the browser.
@@ -131,6 +133,10 @@ prodex sessions show latest
 
 This uses the currently available ChatGPT web session and model selection. It is not a hidden API client, and it does not read cookies, tokens, localStorage, or sessionStorage.
 
+Current builds read rendered page content only. Project/conversation listings are limited to entries exposed by the UI. Automatic chat/project deletion and deep-research report retrieval are unsupported; those commands stop rather than call internal endpoints. A recovered answer must belong to the requested thread and be stable and finished. Formatting may differ from ChatGPT's rendered message.
+
+Locks fail closed if a process is killed while reclaiming an abandoned lock. A leftover `.reap` claim then needs manual cleanup: first stop every prodex process using that resource and confirm no request/write/startup is active; only then remove the affected lock and its matching `.reap` file. Browser locks live beside the recorded send lock, repo-write locks under `.bridge`, and virtual-display allocation locks under `~/.local/share/prodex/xvfb`. Do not remove a live request's lock to shorten a wait.
+
 #### Choosing the model, reasoning effort, and project
 
 The visible-browser send drives the same composer picker you use by hand. Since ChatGPT replaced the model menu with one power slider that walks model and effort together, that slider is the lever:
@@ -174,13 +180,18 @@ Log in once, then never see the browser again:
 ```bash
 prodex pro browser login                    # once, headed - sign in
 prodex pro browser login --virtual-display  # from now on: no window anywhere
+prodex pro browser login --headed            # force a visible window for login/captcha
 ```
 
-`--virtual-display` (or `PRODEX_VIRTUAL_DISPLAY=1`, which also covers the MCP server and its auto-recovery) starts an X virtual framebuffer and runs the dedicated Chrome on it. It is a **real headed browser**, so Cloudflare treats it as an ordinary one — measured end to end: the signed-in profile loaded chatgpt.com with no challenge and a real Pro send returned in 31 seconds, with nothing on the desktop and nothing in the taskbar. Headless, by contrast, never gets past Cloudflare at all (see below).
+Window mode is one mutually exclusive choice: `--headed`, `--headless`, `--minimized`, or `--virtual-display`. Supplying a CLI mode flag selects the whole mode and overrides environment and saved state. With no mode flag, any non-empty `PRODEX_HEADLESS`, `PRODEX_MINIMIZE_WINDOW`, or `PRODEX_VIRTUAL_DISPLAY` value selects the whole environment mode; `0`, `false`, and `no` are meaningful false values, so `PRODEX_HEADLESS=0` explicitly selects ordinary headed mode instead of falling back to a saved headless launch. With neither flags nor mode environment settings, `login` and CLI/MCP auto-recovery reuse the last recorded mode. With no saved record, the normal default is headed.
+
+`--virtual-display` (or `PRODEX_VIRTUAL_DISPLAY=1`, which also covers the MCP server and its auto-recovery) starts an X virtual framebuffer and runs the dedicated Chrome on it. It is a **real headed browser** without a desktop window, not Chrome's headless mode. Login, captcha, rate limits, and permission checks still apply; this mode does not bypass them.
+
+Requires `Xvfb` and `xauth` (`sudo apt install -y xvfb x11-xkb-utils xauth`); prodex names the package if they are missing. Linux and WSL only. New displays use Linux abstract Unix sockets, which also work when WSLg mounts `/tmp/.X11-unix` read-only. TCP and filesystem Unix listeners are disabled. A per-display xauth cookie under `~/.local/share/prodex/xvfb/` restricts access to clients holding that credential; `-ac` is never used. The X server outlives the CLI on purpose (the browser runs on it) and is reused by later commands; `PRODEX_VIRTUAL_DISPLAY_NUM` selects the first number to try if `:99` is taken. A setup failure stops the launch or recovery, without falling back to a desktop window.
 
-Requires `Xvfb` and `xauth` (`sudo apt install -y xvfb x11-xkb-utils xauth`); prodex names the package if they are missing. Linux and WSL only. The display is served over loopback TCP because WSLg mounts `/tmp/.X11-unix` read-only, and it is protected by a per-display xauth cookie under `~/.local/share/prodex/xvfb/` — never `-ac`, so no other process can watch your signed-in window. The X server outlives the CLI on purpose (the browser runs on it) and is reused by later commands; `PRODEX_VIRTUAL_DISPLAY_NUM` picks the display number if `:99` is taken.
+Existing browsers and legacy TCP X servers are not stopped or migrated automatically. Finish pending consults, stop the dedicated browser and its old X server, then run the updated `prodex pro browser login --virtual-display` to migrate. New launches skip display numbers with an existing TCP listener and record the display number actually used.
 
-A browser already running on your desktop cannot be moved onto a virtual display by reusing it, so prodex refuses the switch and tells you to close it first (`pkill -f "remote-debugging-port=9333"`).
+A browser already running on your desktop cannot be moved onto a virtual display by reusing it. prodex refuses the switch without ending the browser; close it yourself, then rerun with the intended mode. Reinvoking `login` for an already-running virtual browser reuses its saved display identity and does not allocate another display.
 
 ### Keeping the window, just out of the way
 
@@ -192,10 +203,10 @@ The catch is what "minimized" means to your desktop. Under WSLg a minimized Chro
 
 `prodex pro browser login --headless` (or `PRODEX_HEADLESS=1`, which also covers the MCP server and its auto-recovery) runs the dedicated browser with no visible window. Two constraints are real, not cosmetic:
 
-- **Sign in headed first.** Nobody can log in to a window that does not exist, so headless reuses a profile you already signed into. The headless login verifies the saved session and tells you to run the headed login once if it is not there.
+- **Sign in headed first.** Nobody can log in to a window that does not exist, so headless reuses a profile you already signed into. If login, captcha, Cloudflare, permission, or account verification is needed, close the hidden browser yourself and run `prodex pro browser login --headed` for a visible interactive window. Do not merely omit `--headless`: saved modes persist.
 - **One mode at a time.** A single Chrome profile cannot serve a headed and a headless instance simultaneously; close the running one before switching (prodex refuses the switch instead of silently reusing the wrong mode).
 
-**Cloudflare is the catch, and it is not theoretical.** Measured on a real signed-in profile: headless Chrome lands on the "Just a moment..." interstitial and stays there past 60 seconds, so ChatGPT never loads. A signed-in profile does not buy a pass — the challenge keys on the headless browser itself. Treat `--headless` as available-but-unproven against ChatGPT: try it, and if `prodex pro browser check` reports the challenge, run headed. Only the window is optional; the login is not.
+**Cloudflare is the catch, and it is not theoretical.** Measured on a real signed-in profile: headless Chrome lands on the "Just a moment..." interstitial and stays there past 60 seconds, so ChatGPT never loads. A signed-in profile does not buy a pass — the challenge keys on the headless browser itself. Treat `--headless` as available-but-unproven against ChatGPT: if `prodex pro browser check` reports the challenge, run `prodex pro browser login --headed` and complete it visibly. prodex does not invoke a hidden API or bypass login/protection. Only the window is optional; the login is not.
 
 If a consult finds the browser closed, prodex now relaunches it in the same mode you last used and retries once — including from the MCP server, which has no terminal to prompt in. `PRODEX_NO_AUTO_LOGIN=1` turns that off.
 
@@ -270,7 +281,7 @@ Token-bearing MCP URLs are secrets. They authorize all enabled bridge tools, inc
 prodex status --show-token --url-only
 ```
 
-`status --show-token` requires a token with an expiry, so run `setup --token-ttl-hours <hours>` before asking for a paste-ready URL. The URL token is stored only in `.bridge/config.local.json`, which is ignored by git. Rotate it with `setup` when you no longer need that URL. If you intentionally created a non-expiring token for local-only debugging, `status --show-token` refuses to reveal it unless you also pass `--unsafe-show-non-expiring-token`. `doctor` and `pro browser check` also print `config_warning` when the saved token is non-expiring.
+`status --show-token` requires a token with an expiry, so run `setup --token-ttl-hours <hours>` before asking for a paste-ready URL. The URL token is stored only in `.bridge/config.local.json`, which is ignored by git. Rotate it with `setup --token-ttl-hours <hours>`, then restart `prodex start` and update client URLs. Plain `setup` preserves the saved token and expiry, and unspecified listener settings are preserved. If you intentionally created a non-expiring token for local-only debugging, `status --show-token` refuses to reveal it unless you also pass `--unsafe-show-non-expiring-token`. `doctor` and `pro browser check` also print `config_warning` when the saved token is non-expiring.
 
 After adding the MCP URL to ChatGPT, generate a paste-ready verification prompt:
 

package/docs/clients.md

@@ -48,12 +48,10 @@ 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.
+Keep the client budget longer than the ordinary consult budget. Current
+browser-only builds block `tools: ["deep-research"]` before sending because
+automatic report retrieval depended on an internal API. Run research manually
+in ChatGPT; `pro_recover` only accepts a finished, rendered conversation answer.
 
 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

package/docs/http-mcp.md

@@ -4,6 +4,8 @@ Use this path when you want a ChatGPT Project to hand tasks back to this local r
 
 This is not the ChatGPT Pro browser adapter. It does not open ChatGPT, read cookies, or automate a web session. It starts a local HTTP MCP server that exposes the same bridge/repo tools as the Claude stdio server.
 
+Generic task, session and result responses redact personal ChatGPT thread metadata, including nested blockers and recovery URLs in diagnostic text. Local CLI records retain that context for recovery. Legacy result artifacts without a recorded hash are readable with a `legacy_artifact_unverified` warning; a signed completion receipt does not verify unhashed artifact bytes.
+
 ## What It Is
 
 `prodex start` runs a local Streamable HTTP MCP server.
@@ -63,7 +65,9 @@ Equivalent from outside the repo:
 prodex setup --cwd /absolute/path/to/your/repo --token-ttl-hours 24
 ```
 
-Expired tokens are rejected by `prodex start` and by the HTTP MCP server. Rerun `setup` to rotate the URL.
+Token-bearing MCP URLs are secrets. Keep the renewed URL in your own trusted private MCP client configuration.
+
+Expired tokens are rejected by `prodex start` and by the HTTP MCP server. Run `prodex setup --token-ttl-hours <hours>` to rotate the URL, restart `prodex start`, then reconnect clients using `prodex status --show-token --url-only`. Plain `setup` preserves the existing token and expiry; changing the TTL preserves the listener unless `--host` or `--port` is supplied.
 
 ## Start The Local Server
 

package/docs/releasing.md

@@ -21,7 +21,7 @@ One-time setup (owner, on npmjs.com): open the package → Settings → Trusted
 
 ## Release checks
 
-GitHub Actions runs `npm ci`, `npm run build`, `npm run release:check`, and `npm run release:verify` on pushes to `main` and pull requests. The workflow installs `ripgrep` because the repo-search smoke checks require `rg`. It verifies release readiness only; it does not publish anything.
+GitHub Actions runs `npm ci`, `npm run build`, `npm run release:check -- --metadata-only`, and `npm run release:verify` on pushes to `main` and pull requests. The metadata step checks package readiness; the verification step runs the full test and package checks once. The workflow installs `ripgrep` because the repo-search smoke checks require `rg`. It verifies release readiness only; it does not publish anything.
 
 Before sharing a package tarball, run:
 
@@ -39,6 +39,8 @@ npm run release:verify
 
 This runs tests, typecheck, build, package smoke, and `doctor` without weakening the publish guard.
 
+Package smoke runs tarball publish dry-runs against an isolated, read-only loopback registry. This keeps repeat verification working after the package version has already been published. It does not establish that a version is available on npm; the separate release dry-run and actual publish still enforce registry readiness. No package is uploaded by the smoke check.
+
 If direct `npm pack` is blocked because a WSL/Windows mount reports normal source files as executable, build the publish tarball from a temporary Linux staging directory:
 
 ```bash

package/package.json

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