@youdie006/prodex 0.40.28 → 0.40.29

package/dist/browser-process.js

@@ -1,3 +1,4 @@
+import { readlinkSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 export class BrowserProcessInspectionError extends Error {
@@ -38,6 +39,33 @@ function defaultProcessListRunner(command, args, options) {
     return spawnSync(command, args, options);
 }
 /** Read process identity without passing a port, profile, or other user data to a shell. */
+function defaultNetworkNamespaceReader(pid) {
+    try {
+        return readlinkSync(`/proc/${pid}/ns/net`);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Drop processes that live in another network namespace than this one.
+ *
+ * A browser container's Chromium shows up in the host's process list, runs as
+ * the same uid, and passes --remote-debugging-port=9333 too, but that port is
+ * the container's own. Counting it as ours made `pro browser reset` on the host
+ * offer to end the container's browser (measured 2026-10-08: 12 processes, all
+ * of them the container's), and a second claimant on "our" port fails a
+ * port-only search outright. A namespace that cannot be read keeps the process.
+ */
+export function inOwnNetworkNamespace(processes, readNetworkNamespace = defaultNetworkNamespaceReader) {
+    const own = readNetworkNamespace("self");
+    if (!own)
+        return processes;
+    return processes.filter((processInfo) => {
+        const theirs = readNetworkNamespace(processInfo.processId);
+        return theirs === undefined || theirs === own;
+    });
+}
 export function inspectBrowserProcesses(options = {}) {
     const platform = options.platform ?? process.platform;
     const run = options.run ?? defaultProcessListRunner;
@@ -53,7 +81,10 @@ export function inspectBrowserProcesses(options = {}) {
     if (listed.error || listed.status !== 0 || stdout === undefined) {
         throw new BrowserProcessInspectionError("Could not inspect browser processes.");
     }
-    return platform === "win32" ? parseWindowsCimProcessJson(stdout) : parsePosixProcessList(stdout);
+    if (platform === "win32")
+        return parseWindowsCimProcessJson(stdout);
+    const processes = parsePosixProcessList(stdout);
+    return platform === "linux" ? inOwnNetworkNamespace(processes, options.readNetworkNamespace) : processes;
 }
 export function parseWindowsCimProcessJson(raw) {
     let parsed;

package/dist/chatgpt-browser.js

@@ -7,7 +7,7 @@ import path from "node:path";
 import WsWebSocket from "ws";
 import { captureBrowserDiagnostics, diagnosticsEnabled, diagnosticsNote } from "./browser-diagnostics.js";
 import { withCrossProcessFileLock, writeVerifiedUtf8File } from "./safe-file.js";
-import { findBrowserProcessesByPort, findMatchingBrowserProcesses, inspectBrowserProcesses, parsePosixProcessList } from "./browser-process.js";
+import { findBrowserProcessesByPort, findMatchingBrowserProcesses, inOwnNetworkNamespace, inspectBrowserProcesses, parsePosixProcessList } from "./browser-process.js";
 import os from "node:os";
 import { answeredDialogWarning, chatSurfaceState, effortNeedsWorkSurface, javascriptDialogResponse, menuKeyboardStep, readPowerSliderSelection, sliderRestoreStep, surfaceFromProbe, sliderPressOutcome, sliderDidNotRespond } from "./picker-interaction.js";
 import { projectsWithIdsExpression, recentConversationTitlesExpression } from "./tui.js";
@@ -192,38 +192,242 @@ export const CHATGPT_BLOCKER_SCAN_EXCLUDED_ANCESTORS = `${'[data-message-author-
  * attribute went with it; where it is absent the model is simply not known.
  */
 /**
- * A message's text with its source pills spelled out.
+ * An assistant message as markdown, read from its rendered DOM.
  *
- * Measured 2026-10-06: ChatGPT renders each source as an inline pill
- * ([data-chatgpt-copy-reference]) and innerText puts its label on a line of
- * its own, so a page-read answer came back as "walnut-9" plus a line
- * "cont-att", or ended in a bare "blog.rust-lang.org" that read as part of
- * the answer. A web source becomes " [label](url)", as the transcript reader
- * writes it; a file source has no link and becomes " [label]". The label is
- * looked for on its own line first, so the same words earlier in the prose
- * are left alone.
+ * innerText drops what markdown carries. Measured 2026-10-06/07: headings lost
+ * their #, numbered lists their numbers, bullets their markers, links their
+ * urls, code blocks their fences (gaining the toolbar's "Python"/"Run"),
+ * tables their structure, KaTeX math came back one glyph per line and twice,
+ * and source pills became loose lines. The transcript API that held the
+ * markdown is not used (internal endpoints were removed on purpose), so the
+ * rendered tree is walked instead: block elements become markdown blocks,
+ * ChatGPT's own copy markers ([data-markdown-copy]) identify code blocks,
+ * inline code and the toolbar to leave out, math is written from
+ * [data-math-source], and a source pill becomes " [label](url)" or
+ * " [label]". When nothing could be read, the page text is returned as is.
  */
 export const CHATGPT_RENDERED_MESSAGE_TEXT_JS = `
     const renderedMessageText = (root) => {
+      const NL = String.fromCharCode(10);
+      const BT = String.fromCharCode(96);
+      const isSpaceChar = (ch) => ch === " " || ch === NL || ch === String.fromCharCode(9) || ch === String.fromCharCode(13);
+      const tagOf = (node) => (node.tagName || "").toLowerCase();
+      const attr = (node, name) => (node.getAttribute ? node.getAttribute(name) : null);
+      const hasClass = (node, name) => (" " + (attr(node, "class") || "") + " ").includes(" " + name + " ");
+      const children = (node) => [...(node.childNodes || [])];
+      const findAll = (node, test, out = []) => {
+        for (const child of children(node)) {
+          if (child.nodeType !== 1) continue;
+          if (test(child)) out.push(child);
+          findAll(child, test, out);
+        }
+        return out;
+      };
+      const collapse = (value) => {
+        let out = "";
+        let space = false;
+        for (const ch of value) {
+          if (isSpaceChar(ch)) { space = true; continue; }
+          if (space) out += " ";
+          space = false;
+          out += ch;
+        }
+        return space ? out + " " : out;
+      };
+      const trimEnd = (value) => { let end = value.length; while (end > 0 && isSpaceChar(value[end - 1])) end -= 1; return value.slice(0, end); };
+      const isCheckbox = (node) => attr(node, "role") === "checkbox" || (tagOf(node) === "input" && attr(node, "type") === "checkbox");
+      const skipped = (node) => {
+        const tag = tagOf(node);
+        if (isCheckbox(node)) return false;
+        return tag === "button" || tag === "svg" || tag === "script" || tag === "style" || tag === "img" ||
+          attr(node, "hidden") !== null || attr(node, "data-markdown-copy") === "exclude";
+      };
+      const isMath = (node) => attr(node, "data-math-source") !== null || hasClass(node, "katex") || hasClass(node, "katex-display");
+      const mathSource = (node) => {
+        const source = attr(node, "data-math-source");
+        if (source !== null) return source;
+        const annotation = findAll(node, (n) => tagOf(n) === "annotation")[0];
+        return annotation ? annotation.textContent || "" : node.textContent || "";
+      };
+      // Inline math carries data-math-display="false" (measured), so the value counts, not its presence.
+      const isDisplayMath = (node) => attr(node, "data-math-display") === "true" || hasClass(node, "katex-display");
+      const isCodeBlock = (node) => attr(node, "data-markdown-copy") === "code-block" || tagOf(node) === "pre";
+      const BLOCK_TAGS = ["p", "div", "section", "article", "figure", "ul", "ol", "li", "table", "blockquote", "pre", "hr", "h1", "h2", "h3", "h4", "h5", "h6"];
+      const isBlock = (node) => node.nodeType === 1 && !skipped(node) &&
+        (BLOCK_TAGS.includes(tagOf(node)) || isCodeBlock(node) || (isMath(node) && isDisplayMath(node)) ||
+          (tagOf(node) === "span" && findAll(node, (n) => BLOCK_TAGS.includes(tagOf(n))).length > 0));
+      const pill = (node) => {
+        const label = collapse(node.textContent || "").trim();
+        if (!label) return "";
+        const link = findAll(node, (n) => tagOf(n) === "a" && (attr(n, "href") || "").startsWith("http"))[0];
+        return link ? "[" + label + "](" + attr(link, "href") + ")" : "[" + label + "]";
+      };
+      const inline = (node) => {
+        let out = "";
+        for (const child of children(node)) {
+          const piece = inlineNode(child);
+          if (!piece) continue;
+          // A source pill sits right after its sentence; keep one space before it.
+          if (child.nodeType === 1 && attr(child, "data-chatgpt-copy-reference") !== null && out && !isSpaceChar(out[out.length - 1])) out += " ";
+          out += piece;
+        }
+        return out;
+      };
+      const inlineNode = (node) => {
+        if (node.nodeType === 3) return collapse(node.textContent || "");
+        if (node.nodeType !== 1 || skipped(node)) return "";
+        const tag = tagOf(node);
+        // A task list item's box (measured: button[role=checkbox][aria-checked]).
+        if (isCheckbox(node)) return (attr(node, "aria-checked") === "true" || attr(node, "checked") !== null ? "[x]" : "[ ]") + " ";
+        if (isMath(node)) return isDisplayMath(node) ? "$$" + mathSource(node) + "$$" : "$" + mathSource(node) + "$";
+        if (attr(node, "data-chatgpt-copy-reference") !== null) return pill(node);
+        if (attr(node, "data-markdown-copy") === "inline-code" || tag === "code") return BT + (node.textContent || "") + BT;
+        if (tag === "br") return NL;
+        const inner = inline(node);
+        if (tag === "strong" || tag === "b") return inner.trim() ? "**" + inner.trim() + "**" : "";
+        if (tag === "em" || tag === "i") return inner.trim() ? "*" + inner.trim() + "*" : "";
+        if (tag === "del" || tag === "s") return inner.trim() ? "~~" + inner.trim() + "~~" : "";
+        if (tag === "a") {
+          const href = attr(node, "href") || "";
+          return href.startsWith("http") && inner.trim() ? "[" + inner.trim() + "](" + href + ")" : inner;
+        }
+        return inner;
+      };
+      const codeBlock = (node) => {
+        // CodeMirror renders only the lines in view: a 150-line block came back
+        // with 36 (measured 2026-10-07). Its editor holds the whole document.
+        const editorContent = findAll(node, (n) => hasClass(n, "cm-content"))[0];
+        let fullCode = null;
+        try {
+          const view = editorContent && ((editorContent.cmTile && editorContent.cmTile.view) || (editorContent.cmView && editorContent.cmView.view));
+          const doc = view && view.state && view.state.doc;
+          if (doc && typeof doc.toString === "function") fullCode = String(doc.toString());
+        } catch (error) {
+          fullCode = null;
+        }
+        const lines = findAll(node, (n) => hasClass(n, "cm-line")).map((line) => line.textContent || "");
+        const pre = tagOf(node) === "pre" ? node : findAll(node, (n) => tagOf(n) === "pre")[0];
+        const code = fullCode !== null ? trimEnd(fullCode) : lines.length > 0 ? lines.join(NL) : trimEnd(pre ? pre.textContent || "" : node.textContent || "");
+        const editor = findAll(node, (n) => attr(n, "data-language") !== null)[0];
+        const toolbar = findAll(node, (n) => attr(n, "data-markdown-copy") === "exclude")[0];
+        const label = toolbar ? collapse(findAll(toolbar, (n) => n.nodeType === 1 && tagOf(n) === "div" && children(n).every((c) => c.nodeType === 3)).map((n) => n.textContent || "")[0] || "").trim() : "";
+        const language = ((editor && attr(editor, "data-language")) || label).trim().toLowerCase();
+        return BT + BT + BT + language + NL + code + NL + BT + BT + BT;
+      };
+      const table = (node) => {
+        const cell = (value) => collapse(value).trim().split("|").join(String.fromCharCode(92) + "|");
+        const rows = findAll(node, (n) => tagOf(n) === "tr").map((row) => children(row).filter((c) => c.nodeType === 1).map((c) => cell(inline(c))));
+        if (rows.length === 0) return "";
+        const line = (cells) => "| " + cells.join(" | ") + " |";
+        return [line(rows[0]), line(rows[0].map(() => "---")), ...rows.slice(1).map(line)].join(NL);
+      };
+      const list = (node, depth) => {
+        const ordered = tagOf(node) === "ol";
+        let number = parseInt(attr(node, "start") || "1", 10);
+        if (!Number.isFinite(number)) number = 1;
+        const indent = "   ".repeat(depth);
+        const items = [];
+        for (const item of children(node)) {
+          if (item.nodeType !== 1 || tagOf(item) !== "li") continue;
+          const marker = ordered ? number + "." : "-";
+          number += 1;
+          const words = [];
+          const nested = [];
+          let buffer = "";
+          for (const child of children(item)) {
+            const tag = child.nodeType === 1 ? tagOf(child) : "";
+            if (tag === "ul" || tag === "ol") { nested.push(list(child, depth + 1)); continue; }
+            if (isBlock(child)) { if (buffer.trim()) words.push(buffer.trim()); buffer = ""; const b = block(child, depth + 1); if (b) words.push(b); continue; }
+            buffer += inlineNode(child);
+          }
+          if (buffer.trim()) words.push(buffer.trim());
+          items.push(indent + marker + " " + words.join(" ") + (nested.length ? NL + nested.join(NL) : ""));
+        }
+        return items.join(NL);
+      };
+      const block = (node, depth) => {
+        if (node.nodeType === 3) return collapse(node.textContent || "").trim();
+        if (node.nodeType !== 1 || skipped(node)) return "";
+        const tag = tagOf(node);
+        if (isMath(node)) return isDisplayMath(node) ? "$$" + NL + mathSource(node) + NL + "$$" : "$" + mathSource(node) + "$";
+        if (isCodeBlock(node)) return codeBlock(node);
+        if (tag === "table") return table(node);
+        if (/^h[1-6]$/.test(tag)) return "#".repeat(Number(tag[1])) + " " + inline(node).trim();
+        if (tag === "ul" || tag === "ol") return list(node, depth);
+        if (tag === "hr") return "---";
+        if (tag === "blockquote") return blocks(node, depth).split(NL).map((line) => "> " + line).join(NL);
+        if (tag === "p") return inline(node).trim();
+        return blocks(node, depth);
+      };
+      const blocks = (node, depth) => {
+        const parts = [];
+        let buffer = "";
+        const flush = () => { if (buffer.trim()) parts.push(buffer.trim()); buffer = ""; };
+        for (const child of children(node)) {
+          if (isBlock(child)) { flush(); const b = block(child, depth); if (b) parts.push(b); continue; }
+          buffer += inlineNode(child);
+        }
+        flush();
+        return parts.join(NL + NL);
+      };
+      const markdown = blocks(root, 0).trim();
+      return markdown || root.innerText || "";
+    };
+    // A sent user turn renders inline code as <code>, dropping its backticks
+    // from innerText (measured 2026-10-07), and the request is matched against
+    // what was typed. Each inline code span gets its backticks back, in page order.
+    const userMessageText = (root) => {
       let text = root.innerText || "";
-      const newline = String.fromCharCode(10);
-      const isSpace = (ch) => ch === " " || ch === newline || ch === String.fromCharCode(9) || ch === String.fromCharCode(13);
+      const tick = String.fromCharCode(96);
       let cursor = 0;
-      for (const pill of [...root.querySelectorAll('[data-chatgpt-copy-reference]')]) {
-        const label = (pill.innerText || "").trim();
-        if (!label) continue;
-        const onOwnLine = text.indexOf(newline + label, cursor);
-        const at = onOwnLine >= 0 ? onOwnLine + 1 : text.indexOf(label, cursor);
+      for (const code of [...root.querySelectorAll('code')]) {
+        if (code.closest('pre')) continue;
+        const value = code.textContent || "";
+        // A fenced block in a user turn is one <code> outside any <pre>
+        // (measured); inline code is a single line.
+        if (!value || value.includes(String.fromCharCode(10))) continue;
+        // The span's text can also occur inside a word earlier on ("x" in
+        // "exact"), so only an occurrence on word boundaries counts.
+        const wordChar = (ch) => !!ch && ((ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z") || (ch >= "0" && ch <= "9") || ch === "_");
+        let at = text.indexOf(value, cursor);
+        while (at >= 0 && ((wordChar(value[0]) && wordChar(text[at - 1])) || (wordChar(value[value.length - 1]) && wordChar(text[at + value.length])))) {
+          at = text.indexOf(value, at + 1);
+        }
         if (at < 0) continue;
-        let start = at;
-        while (start > cursor && isSpace(text[start - 1])) start -= 1;
-        const link = pill.querySelector('a[href^="http"]');
-        const rendered = link ? " [" + label + "](" + link.getAttribute("href") + ")" : " [" + label + "]";
-        text = text.slice(0, start) + rendered + text.slice(at + label.length);
-        cursor = start + rendered.length;
+        if (text[at - 1] === tick && text[at + value.length] === tick) { cursor = at + value.length + 1; continue; }
+        const rendered = tick + value + tick;
+        text = text.slice(0, at) + rendered + text.slice(at + value.length);
+        cursor = at + rendered.length;
       }
       return text;
     };`;
+/**
+ * Lines that say which model or effort the composer is on, for the hints a
+ * consult reports and saves.
+ *
+ * They were every line of the whole page matching /GPT|Pro|.../i, so the saved
+ * answer of every consult listed sidebar project names, conversation titles
+ * and the request marker (measured 2026-10-07: 179 saved answers in one test
+ * repo carried a project name). They now come only from the model selector
+ * and the visible composer form, matched on word boundaries.
+ */
+export const CHATGPT_MODEL_HINTS_JS = `
+    const modelHintLines = () => {
+      const sources = [];
+      const trigger = document.querySelector('button[aria-label="Select ChatGPT model"],[data-testid="model-switcher-dropdown-button"]');
+      // The trigger's text names the model; its aria-label only names the control.
+      if (trigger) sources.push(trigger.innerText || "");
+      for (const form of [...document.querySelectorAll("form")]) {
+        if (form.getClientRects().length > 0) sources.push(form.innerText || "");
+      }
+      const modelish = /\\b(?:ChatGPT|GPT(?:-[\\w.]+)?|Pro|Plus|Thinking|Instant|Extra High|High|Medium|Auto|Latest)\\b/i;
+      const seen = [];
+      for (const line of sources.join(String.fromCharCode(10)).split(String.fromCharCode(10))) {
+        const trimmed = line.trim();
+        if (trimmed && trimmed.length <= 80 && modelish.test(trimmed) && !seen.includes(trimmed)) seen.push(trimmed);
+      }
+      return seen.slice(0, 30);
+    };`;
 const CHATGPT_MESSAGE_NODES_JS = `${CHATGPT_RENDERED_MESSAGE_TEXT_JS}
     // ChatGPT keeps a previously opened conversation mounted but hidden
     // (measured 2026-10-06: two turns without a box on a project home), and
@@ -1671,7 +1875,9 @@ async function openChatGptThread(cdp, url) {
     if (await cdp.evaluate(chatGptThreadReadyExpression(conversationId)))
         return;
     await cdp.evaluate(`location.assign(${JSON.stringify(url)})`);
-    const deadline = Date.now() + RELOAD_SETTLE_TIMEOUT_MS;
+    // A thread with many turns took 13.9 s to finish loading (2026-10-06), and
+    // readiness waits for a loaded document, so the reload ceiling was too short.
+    const deadline = Date.now() + COMPOSER_RENDER_TIMEOUT_MS;
     while (Date.now() < deadline) {
         await sleep(250);
         try {
@@ -2473,6 +2679,20 @@ const POWER_SLIDER_SWALLOWED_PRESS_RETRIES = 6;
  * Anything else (a menu that would not open, a click that would not land) is a
  * real failure and stays one, so a genuine break is not buried under a warning.
  */
+/**
+ * The models to name in a model_not_applied warning: the model rows as
+ * `pro browser models` reads them (a submenu row by its value), else whatever
+ * the menu lookup saw. The lookup's list also carries the effort slider's row,
+ * which put "Medium" among the models (measured 2026-10-07).
+ */
+export function offeredModelLabels(options, fallback) {
+    // A submenu row is named by its value; a radio row's second line is a note
+    // ("Leaving on October 14"), so it is named by its label.
+    const labels = (options ?? [])
+        .map((option) => (option.kind === "submenu" ? option.value || option.label : option.label))
+        .filter((label) => label.length > 0);
+    return labels.length > 0 ? [...new Set(labels)] : fallback ? [...fallback] : undefined;
+}
 export function modelSelectionUnavailableWarning(requested, reason, available) {
     if (!/menu item not found|not clickable/i.test(reason))
         return undefined;
@@ -2607,7 +2827,15 @@ async function selectPickerModel(cdp, requested, warnings = []) {
         return;
     const hit = await cdp.evaluate(menuItemRectExpression(requested));
     if (!hit.ok || hit.x === undefined || hit.y === undefined) {
-        const unavailable = modelSelectionUnavailableWarning(requested, hit.reason ?? "", hit.available);
+        let models;
+        try {
+            models = await cdp.evaluate(modelMenuOptionsExpression());
+        }
+        catch (error) {
+            if (cdpCommandTimedOut(error))
+                throw error;
+        }
+        const unavailable = modelSelectionUnavailableWarning(requested, hit.reason ?? "", offeredModelLabels(models, hit.available));
         if (unavailable) {
             warnings.push(unavailable);
             return;
@@ -3956,7 +4184,7 @@ export async function sendChatGptPrompt(options) {
         // prompt posts the composer clears and no send button is found.
         const promptPostedExpression = `(() => {${CHATGPT_MESSAGE_NODES_JS}
       const last = chatMessageNodes().filter((message) => message.role === "user").at(-1);
-      return Boolean(last && (last.textNode.innerText || "").includes(${JSON.stringify(`[prodex-request:${requestId}]`)}));
+      return Boolean(last && userMessageText(last.textNode).includes(${JSON.stringify(`[prodex-request:${requestId}]`)}));
     })()`;
         // A dispatch can reach Chrome even if its acknowledgement is lost.
         submissionAttempted = true;
@@ -4087,7 +4315,9 @@ export async function sendChatGptPrompt(options) {
                     code: "thread_navigated_away",
                     message: "The browser tab was moved to a different ChatGPT conversation while this consult was waiting for its answer.",
                     retryable: false,
-                    next_step: `Do not resend automatically. After other sessions finish, inspect the original request [prodex-request:${requestId}] in ${pinnedThreadUrl}.`,
+                    // The answer keeps coming in that thread and recovers by its request id
+                    // once it finishes (verified 2026-10-07), so name the exact command.
+                    next_step: `Do not resend automatically. After other sessions finish with the tab, recover this request's answer: \`prodex pro browser recover --target-url ${pinnedThreadUrl} --request-id ${requestId}\`.`,
                     thread: pinnedThreadUrl
                 });
             }
@@ -4332,7 +4562,7 @@ export function resolveConversationToDelete(conversations, request) {
  * The port cannot tell a dead browser from an absent one; the process list can.
  */
 export function findLaunchedBrowserProcesses(psOutput, input) {
-    return findBrowserProcessesByPort(parsePosixProcessList(psOutput), {
+    return findBrowserProcessesByPort(inOwnNetworkNamespace(parsePosixProcessList(psOutput)), {
         platform: "linux",
         port: input.port,
         fallbackProfileDir: input.profileDir
@@ -4633,7 +4863,14 @@ export async function listChatGptModelOptions(input = {}) {
     input.signal?.addEventListener("abort", abandon, { once: true });
     try {
         await cdp.send("Runtime.enable");
-        const button = await cdp.evaluate(modelButtonRectExpression());
+        // Right after a send the composer is still rendering, and a single look
+        // failed with "the composer has no form around it" (measured 2026-10-07).
+        let button = await cdp.evaluate(modelButtonRectExpression());
+        const buttonDeadline = Date.now() + COMPOSER_RENDER_TIMEOUT_MS;
+        while ((!button.ok || button.x === undefined || button.y === undefined) && Date.now() < buttonDeadline && !input.signal?.aborted) {
+            await sleep(300);
+            button = await cdp.evaluate(modelButtonRectExpression());
+        }
         if (!button.ok || button.x === undefined || button.y === undefined) {
             throw new Error(button.reason ?? "Could not open the ChatGPT model selector");
         }
@@ -5027,7 +5264,7 @@ export function statusExpression() {
     const responseChoiceSelector = JSON.stringify(CHATGPT_RESPONSE_CHOICE_SELECTOR);
     const generatingControlPattern = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.source);
     const generatingControlFlags = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.flags);
-    return `(() => {
+    return `(() => {${CHATGPT_MODEL_HINTS_JS}
     ${composerExpressionHelpers()}
     const text = document.body?.innerText || "";
     const runtimeExcludedTextSelector = ${excludedTextSelector};
@@ -5061,7 +5298,7 @@ export function statusExpression() {
     ${CHATGPT_MESSAGE_NODES_JS}
     const messages = chatMessageNodes().map((message) => ({
       role: message.role,
-      text: message.textNode.innerText || ""
+      text: message.role === "assistant" ? renderedMessageText(message.textNode) : userMessageText(message.textNode)
     }));
     const assistant = messages.filter((message) => message.role === "assistant").at(-1);
     const answer = assistant?.text || "";
@@ -5080,7 +5317,7 @@ export function statusExpression() {
       hasComposer,
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || visibleButtonLabels.some((label) => generatingControlPattern.test(label)),
       awaitingResponseChoice: Boolean(document.querySelector(${responseChoiceSelector})),
-      modelHints: lines.filter((line) => /GPT|Pro|Thinking|ChatGPT|Extra High|Auto/i.test(line)).slice(0, 30),
+      modelHints: modelHintLines(),
       openDialogText: (([...document.querySelectorAll('[role="dialog"]')].find((d) => d.offsetWidth || d.offsetHeight || d.getClientRects().length)?.innerText) || "").trim().slice(0, 200)
     };
   })()`;
@@ -5166,6 +5403,7 @@ export function composerFileInputSelector() {
     return 'input[type="file"]:not([accept*="image"])';
 }
 const COMPOSER_TOOLS_MENU_ATTEMPTS = 3;
+const LEFTOVER_ATTACHMENT_REMOVE_ATTEMPTS = 5;
 export const PRODEX_ATTACH_INPUT_ATTRIBUTE = "data-prodex-attach-input";
 /**
  * Tags the general file input of the form that holds the VISIBLE composer, so
@@ -5257,6 +5495,22 @@ export function attachmentPresenceExpression() {
     return { ok: true, removed: buttons.length };
   })()`;
 }
+/**
+ * Where to click to remove one leftover attachment chip: the first rendered
+ * "Remove <file name>" button in a composer form, or { ok: false }.
+ */
+export function leftoverAttachmentRemovePointExpression() {
+    return `(() => {
+    const button = [...document.querySelectorAll('form button[aria-label]')].find((b) => {
+      const label = b.getAttribute("aria-label") || "";
+      if (!(/remove file|파일 제거|첨부 제거/i.test(label) || /^remove\\s+\\S.*\\.[A-Za-z0-9]{1,8}$/i.test(label))) return false;
+      return b.getClientRects().length > 0;
+    });
+    if (!button) return { ok: false };
+    const r = button.getBoundingClientRect();
+    return { ok: true, x: r.x + r.width / 2, y: r.y + r.height / 2 };
+  })()`;
+}
 /**
  * Attach files to the composer and wait until ChatGPT has taken them. The
  * files must be readable by the BROWSER process, so a browser on another
@@ -5303,12 +5557,32 @@ export async function attachFilesToComposer(cdp, absolutePaths, options = {}) {
         }
     };
     let marked = await waitForComposerFileInput();
-    const stale = await cdp.evaluate(attachmentPresenceExpression());
-    if ((stale?.removed ?? 0) > 0) {
-        // A fixed sleep and a composer check could both pass on the document being
-        // left (a reload takes 5-8 s here), and the file then went into a page that
-        // was replaced under it. The marked reload waits for the new document.
-        await reloadAndAwaitComposer(cdp, 20_000);
+    const leftoverCount = async () => (await cdp.evaluate(attachmentPresenceExpression()))?.removed ?? 0;
+    if (await leftoverCount() > 0) {
+        // A leftover chip now survives a reload (measured 2026-10-06), and a send
+        // went out carrying it next to the file it was asked for. Its own remove
+        // button works and later attaches still work, so it is clicked first; the
+        // marked reload stays as a fallback, and a chip that survives both stops
+        // the send rather than riding along.
+        for (let attempt = 0; attempt < LEFTOVER_ATTACHMENT_REMOVE_ATTEMPTS; attempt += 1) {
+            const point = await cdp.evaluate(leftoverAttachmentRemovePointExpression());
+            if (!point?.ok || point.x === undefined || point.y === undefined)
+                break;
+            await dispatchMouseClickAt(cdp, point.x, point.y);
+            await sleep(1_000);
+        }
+        if (await leftoverCount() > 0) {
+            await reloadAndAwaitComposer(cdp, 20_000);
+            await waitForComposerFileInput();
+        }
+        if (await leftoverCount() > 0) {
+            throw new ChatGptBrowserBlockerError({
+                code: "leftover_attachment",
+                message: "The ChatGPT composer still holds an attachment from an earlier send, and it could not be removed. Nothing was sent.",
+                retryable: false,
+                next_step: "Remove the attachment from the composer in the dedicated browser, then retry."
+            });
+        }
         marked = await waitForComposerFileInput();
     }
     const document = await cdp.send("DOM.getDocument", { depth: -1, pierce: true });
@@ -5485,7 +5759,11 @@ export function composerTextStateExpression(expectedText, toolLabels = []) {
     if (!raw) return { ok: false, reason: "Composer stayed empty after text insertion" };
     const expected = ${expectedJson};
     if (expected === null) return { ok: true, actualText: raw.slice(0, 120) };
-    const norm = (s) => s.replace(/\\s+/g, " ").trim();
+    // Whitespace is left out of the comparison altogether: the editor adds line
+    // breaks of its own, around blank lines and inside an autolinked url
+    // ("[link](" then a break then "https://..."), and leftover text still
+    // differs in the characters that are not whitespace.
+    const norm = (s) => s.replace(/\\s+/g, "");
     if (norm(raw) !== norm(expected)) {
       return { ok: false, reason: "Composer text did not match the prompt after insertion (possible leftover text in the composer)", actualText: raw.slice(0, 120) };
     }
@@ -5756,6 +6034,7 @@ export function pickLandedConversation(candidates, sentPrompt) {
  */
 export function transcriptContainsWholeSentPrompt(userText, sentPrompt) {
     const normalize = (value) => value
+        .replace(AUTOLINKED_URL_PATTERN, "$1")
         .replace(/\\([\\`*_{}[\]()#+\-.!>~|])/g, "$1")
         .replace(/\s+/g, " ")
         .trim();
@@ -5766,8 +6045,11 @@ export function transcriptContainsWholeSentPrompt(userText, sentPrompt) {
     return seen.includes(sent);
 }
 const NORMALIZED_PROMPT_MATCH_CHARS = 120;
+// The composer can autolink a url before the send, storing "[url](url)" in
+// place of the bare url (measured 2026-10-07, under load).
+const AUTOLINKED_URL_PATTERN = /\[(https?:\/\/[^\]\s]+)\]\(\1\)/g;
 function normalizeChatGptPromptText(value) {
-    const unescaped = value.replace(/\\([\\`*_{}[\]()#+\-.!>~|])/g, "$1");
+    const unescaped = value.replace(AUTOLINKED_URL_PATTERN, "$1").replace(/\\([\\`*_{}[\]()#+\-.!>~|])/g, "$1");
     const renderedFences = unescaped.replace(/(^|\r?\n)```text[ \t]*\r?\n([\s\S]*?)\r?\n```(?=\r?\n|$)/g, "$1text\n$2");
     return renderedFences.replace(/\s+/g, " ").trim();
 }
@@ -6035,7 +6317,7 @@ export function answerExpression() {
     const responseChoiceSelector = JSON.stringify(CHATGPT_RESPONSE_CHOICE_SELECTOR);
     const generatingControlPattern = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.source);
     const generatingControlFlags = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.flags);
-    return `(() => {
+    return `(() => {${CHATGPT_MODEL_HINTS_JS}
     const text = document.body?.innerText || "";
     const excludedTextSelector = ${excludedTextSelector};
     const blockerScanExcludedSelector = ${blockerScanExcludedSelector};
@@ -6068,7 +6350,8 @@ export function answerExpression() {
         const tagged = node.closest('[data-message-model-slug]');
         if (tagged) modelSlug = tagged.getAttribute('data-message-model-slug') || undefined;
       }
-      return { role, node, text: renderedMessageText(textNode), modelSlug };
+      // User turns stay as typed: the request marker is matched against them.
+      return { role, node, text: role === "assistant" ? renderedMessageText(textNode) : userMessageText(textNode), modelSlug };
     });
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     const userMessages = messages.filter((message) => message.role === "user");
@@ -6124,7 +6407,7 @@ export function answerExpression() {
       // ChatGPT tags each assistant message with the model that produced it -
       // the only ground truth for "did the Pro selection actually take".
       modelSlug: assistant ? assistant.modelSlug : undefined,
-      modelHints: lines.filter((line) => /GPT|Pro|Thinking|ChatGPT|Extra High|Auto/i.test(line)).slice(0, 30)
+      modelHints: modelHintLines()
     };
   })()`;
 }

package/dist/cli-pro.js

@@ -2623,7 +2623,10 @@ export function browserSendBlockerFromError(error) {
         return {
             code: "send_timeout",
             message,
-            retryable: true,
+            // A marked request in a thread was posted: resending puts the question in
+            // a second conversation, which next_step already says not to do. The
+            // flag said the opposite (measured 2026-10-07).
+            retryable: !(thread && requestId),
             ...(thread ? { thread } : {}),
             next_step: thread && requestId
                 ? `Do not resend automatically. ChatGPT often finishes after prodex gives up; recover that exact request instead: \`prodex pro browser recover --target-url ${thread} --request-id ${requestId}\`.`
@@ -2892,8 +2895,11 @@ export function formatProAnswer(consult, sourceCli, options = {}) {
 }
 export function formatProConsultArtifact(consult) {
     const lines = [`# ChatGPT Pro Consult`, "", `Thread: ${consult.url}`, `Title: ${consult.title}`, ""];
-    if (consult.modelHints.length > 0) {
-        lines.push("Model hints:", ...consult.modelHints.map((hint) => `- ${hint}`), "");
+    // Filtered again on the way to disk: a saved answer must not carry page text
+    // such as sidebar project names or the request marker.
+    const savedHints = consult.modelHints.filter((hint) => MODEL_HINT_PATTERN.test(hint) && hint.length <= 80 && !hint.includes("prodex-request:"));
+    if (savedHints.length > 0) {
+        lines.push("Model hints:", ...savedHints.map((hint) => `- ${hint}`), "");
     }
     if (consult.warnings.length > 0) {
         lines.push("Warnings:", ...consult.warnings.map((warning) => `- ${warning}`), "");
@@ -3048,18 +3054,19 @@ async function listConsultRecordsNewestFirst(store, options = { readOnly: true }
 }
 export async function listConsultListEntries(store, options = { readOnly: true }) {
     const records = await listConsultRecordsNewestFirst(store, options);
+    // One pass over the receipts for the whole list (see getFinalizedResultsReadOnly).
+    const finalized = await store.getFinalizedResultsReadOnly(records.map((record) => record.result.task_id));
     const entries = [];
     for (const record of records) {
-        try {
-            entries.push({ kind: "trusted", consult: { ...record, result: await store.getFinalizedResultReadOnly(record.result.task_id) } });
-        }
-        catch (error) {
-            if (isUntrustedResultError(error)) {
-                entries.push({ kind: "untrusted", task: record.task, result: record.result, error });
+        const outcome = finalized.get(record.result.task_id);
+        if (outcome instanceof Error || !outcome) {
+            if (isUntrustedResultError(outcome)) {
+                entries.push({ kind: "untrusted", task: record.task, result: record.result, error: outcome });
                 continue;
             }
-            throw error;
+            throw outcome ?? new Error(`No finalized result was read for ${record.result.task_id}`);
         }
+        entries.push({ kind: "trusted", consult: { ...record, result: outcome } });
     }
     return entries;
 }
@@ -3442,9 +3449,9 @@ export function formatBrowserEarlyExit(exit) {
         return "no exit details";
     return exit.error ?? `exit code ${exit.code ?? "null"}${exit.signal ? ` signal ${exit.signal}` : ""}`;
 }
+const MODEL_HINT_PATTERN = /\b(?:ChatGPT|GPT(?:-[\w.]+)?|Pro|Plus|Team|Enterprise|Thinking|Instant|Extra High|High|Medium|Auto|Latest)\b/i;
 export function formatBrowserModelHints(modelHints) {
-    const modelish = /\b(?:ChatGPT|GPT(?:-[\w.]+)?|Pro|Plus|Team|Enterprise|Thinking|Extra High|Auto)\b/i;
-    const hints = [...new Set(modelHints.map((hint) => hint.trim()).filter((hint) => modelish.test(hint)))]
+    const hints = [...new Set(modelHints.map((hint) => hint.trim()).filter((hint) => MODEL_HINT_PATTERN.test(hint)))]
         .map((hint) => (hint.length > 80 ? `${hint.slice(0, 77)}...` : hint))
         .slice(0, 6);
     return hints.length > 0 ? hints.join(" | ") : undefined;

package/dist/cli-server.js

@@ -49,7 +49,11 @@ export async function runSetupCommand(rest, io) {
     io.stdout("Saved local ChatGPT Developer Mode MCP profile.");
     io.stdout(`Server URL: ${redactServerUrl(config.server_url)}`);
     io.stdout(formatTokenExpiryLine(config));
-    io.stdout("The token is stored (once) in .bridge/config.local.json; print the full URL with `prodex status --show-token --url-only`.");
+    // A token without expiry is refused by plain `status --show-token`, which
+    // is what setup creates by default; the hint has to be one that works.
+    io.stdout(getTokenExpiryStatus(config).status === "valid"
+        ? "The token is stored (once) in .bridge/config.local.json; print the full URL with `prodex status --show-token --url-only`."
+        : "The token is stored (once) in .bridge/config.local.json; it never expires, so keep it local. Print the full URL with `prodex status --show-token --url-only --unsafe-show-non-expiring-token`, or rerun setup with --token-ttl-hours <hours> before sharing it.");
     if (config.browser_defaults) {
         io.stdout(`Browser send defaults: ${formatBrowserDefaults(config.browser_defaults)}`);
         // Ask the picker whether it can actually provide what was just pinned.

package/dist/store.js

@@ -346,6 +346,41 @@ export class BridgeStore {
         await this.assertTrustedTaskCompletionReceiptReadOnly(taskId, result);
         return result;
     }
+    /**
+     * getFinalizedResultReadOnly for many tasks, reading the receipts once.
+     *
+     * Each single call reads every receipt to find its task's completion
+     * receipt, so listing N consults read the receipt directory N times: 238 s
+     * for 260 consults and 969 receipts (measured 2026-10-07). The checks are
+     * the same; a task that fails them maps to its error instead of a result.
+     */
+    async getFinalizedResultsReadOnly(taskIds) {
+        const ready = await this.hasReadyStorageDirReadOnly("receipts");
+        const byTask = new Map();
+        if (ready) {
+            for (const receipt of await this.readAll("receipts", parseReceiptRecord, { cleanupTempHardLinks: false })) {
+                if (receipt.kind !== "task_completed" || !receipt.task_id)
+                    continue;
+                const list = byTask.get(receipt.task_id) ?? [];
+                list.push(receipt);
+                byTask.set(receipt.task_id, list);
+            }
+        }
+        const results = new Map();
+        for (const taskId of taskIds) {
+            try {
+                const result = await this.getResultReadOnly(taskId);
+                if (!ready)
+                    throw untrustedResultError(this.root, taskId, "has no trusted task_completed receipt");
+                await this.assertReceiptsTrustCompletion(taskId, result, byTask.get(taskId) ?? []);
+                results.set(taskId, result);
+            }
+            catch (error) {
+                results.set(taskId, error);
+            }
+        }
+        return results;
+    }
     async resealResult(taskId) {
         const task = await this.getTask(taskId);
         if (task.status !== "done" && task.status !== "blocked") {

package/docs/releasing.md

@@ -16,6 +16,32 @@ Release target: `v0.40.13` on `main`. The GitHub Release records the resolved co
 
 The release adds a guarded, opt-in transition and more accurate blocker reporting. It does not claim that headless Pro consultation is verified on either deployment target or that authentication can be retained indefinitely.
 
+## 0.40.28 Release Record
+
+Release commit `8100c37` on `main` (cut after PR #18, merge `8afda89`); tag `v0.40.28`.
+
+**Publishing**
+- `publish.yml` run 37432329959 passed all six platforms on the first attempt, then npm publish with SLSA v1 provenance and the GitHub Release (2026-10-06 08:11 UTC).
+- PR #18's CI on its docs-only head commit passed macOS Intel only on the third attempt:
+  - The first attempt was an unrelated 30 s timeout in `tests/cli-pro-browser-send.test.ts`.
+  - The second ended with "npm test" failing without naming a test; the output was cut off mid-run.
+  - The code commit before it had passed all six platforms.
+- `npm run release:verify` passed on the release commit after a build.
+
+**What it fixes**
+- On a heavily loaded host, the new-chat page and the composer's controls get 30 s ceilings. Before, back-to-back sends were refused as `composer_not_ready` or `fresh_chat_not_ready` before anything was sent.
+
+**Installation on 2026-10-06**
+- Global npm, each verified with `prodex --version` = 0.40.28.
+- WSL, M3, Mac mini: installed. Running services were not restarted: 11 stdio MCP servers on WSL and 4 on M3 keep older code until their clients reconnect. The Mac mini had none running.
+- M4: not reachable (hostname does not resolve); not updated.
+- The browser container already runs the same ceilings (see the afternoon rebuild).
+
+**Live check after install (installed 0.40.28, shared WSL browser, host load average 5.5)**
+- Three back-to-back `--model Pro --pro-mode` new-chat sends answered.
+- A project send with an attachment answered.
+- A create-image send answered.
+
 ## Browser Container Rebuild 2026-10-06 (afternoon)
 
 **Patches now committed**

package/package.json

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