@youdie006/prodex 0.40.27 → 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
@@ -844,8 +1048,10 @@ async function navigateIdleChatGptPage(page, url) {
  * navigation cannot leave the old thread's state in place. A false result
  * must not be used as permission to send into stale content.
  */
-// Measured 5.2-8.5 s for the new-chat page to settle (2026-09-30).
-const FRESH_CHAT_TIMEOUT_MS = 15_000;
+// Measured 5.2-8.5 s for the new-chat page to settle (2026-09-30), and over
+// 15 s for back-to-back sends with the host at load average 28-32 on 8 cores
+// (2026-10-06). It is only a ceiling: a ready page returns at once.
+const FRESH_CHAT_TIMEOUT_MS = 30_000;
 /** Poll until the document marked before a navigation has been replaced and the new one has a composer. */
 async function waitForReloadedDocument(page, deadline) {
     while (Date.now() < deadline) {
@@ -1669,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 {
@@ -1750,6 +1958,13 @@ async function waitForExpressionTrue(cdp, expression, timeoutMs, intervalMs = 15
 const MENU_OPEN_TIMEOUT_MS = 5_000;
 const MENU_SETTLE_TIMEOUT_MS = 5_000;
 const PROJECT_NAVIGATION_TIMEOUT_MS = 8_000;
+/**
+ * How long the composer's own controls (model selector, tools button, file
+ * input) may take to appear after the editor. Measured over 8 s for the model
+ * selector on back-to-back sends with the host at load average 24-44
+ * (2026-10-06). It is only a ceiling: a rendered control returns at once.
+ */
+const COMPOSER_RENDER_TIMEOUT_MS = 30_000;
 export function menuOpenExpression() {
     return `Boolean(document.querySelector('[data-testid="composer-intelligence-picker-content"],[role="menu"]:has([role="slider"])'))`;
 }
@@ -2464,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;
@@ -2598,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;
@@ -2846,7 +3083,7 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
     // the same pattern succeeded either side of it. The neighbouring waits for
     // the same kind of render already allow six to eight.
     let button = { ok: false };
-    const buttonDeadline = Date.now() + PROJECT_NAVIGATION_TIMEOUT_MS;
+    const buttonDeadline = Date.now() + COMPOSER_RENDER_TIMEOUT_MS;
     for (;;) {
         button = await cdp.evaluate(modelButtonRectExpression());
         if (button.ok && button.x !== undefined && button.y !== undefined)
@@ -3947,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;
@@ -4078,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
                 });
             }
@@ -4323,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
@@ -4624,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");
         }
@@ -5018,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};
@@ -5052,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 || "";
@@ -5071,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)
     };
   })()`;
@@ -5156,8 +5402,8 @@ export function insertComposerTextInPageExpression(text) {
 export function composerFileInputSelector() {
     return 'input[type="file"]:not([accept*="image"])';
 }
-const COMPOSER_FILE_INPUT_TIMEOUT_MS = 15_000;
 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
@@ -5249,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
@@ -5279,7 +5541,7 @@ export async function attachFilesToComposer(cdp, absolutePaths, options = {}) {
     // this point in that window sometimes. Wait for the input itself, before
     // the chip check (chips render with it) and before reading the DOM tree.
     const waitForComposerFileInput = async () => {
-        const inputDeadline = Date.now() + COMPOSER_FILE_INPUT_TIMEOUT_MS;
+        const inputDeadline = Date.now() + COMPOSER_RENDER_TIMEOUT_MS;
         for (;;) {
             try {
                 if (await cdp.evaluate(markComposerFileInputExpression()) === true)
@@ -5295,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 });
@@ -5477,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) };
     }
@@ -5504,7 +5790,7 @@ export async function enableComposerTools(cdp, labels) {
         // The server-rendered editor shows before the app attaches the composer's
         // controls (measured 2026-10-06), so a first miss is usually just early.
         let button = await cdp.evaluate(composerToolsButtonRectExpression());
-        const buttonDeadline = Date.now() + COMPOSER_FILE_INPUT_TIMEOUT_MS;
+        const buttonDeadline = Date.now() + COMPOSER_RENDER_TIMEOUT_MS;
         while ((!button.ok || button.x === undefined || button.y === undefined) && Date.now() < buttonDeadline) {
             await sleep(500);
             button = await cdp.evaluate(composerToolsButtonRectExpression());
@@ -5748,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();
@@ -5758,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();
 }
@@ -6027,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};
@@ -6060,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");
@@ -6116,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,84 @@ 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**
+- The patches the container runs on top of `feat/headless-browser-compatibility` `b5eac7d` are now committed on their own branch, `container/redesign-patches`:
+  - `0c3a9cc`: every patch from 2026-09-30 to 2026-10-06.
+  - `1233603`: the 30 s composer-render ceiling from this change.
+- They had lived only in a scratch worktree.
+- `feat/headless-browser-compatibility` itself is unchanged.
+
+**Image**
+- `sha256:ce0240c0e8a4` was built from `1233603`, and the branch suite passed (2002).
+- The swap was gated on the send lock being free.
+
+**Verified**
+- Three back-to-back `--model Pro --pro-mode` new-chat sends answered (42-50 s each).
+- Before this, a real consult from another session had been refused as `composer_not_ready` (`task_20261006_050125`) under host load average 24-44.
+
+**Host load**
+- The load came from an unrelated container, `apo-neo4j`, which had restarted 57,058 times because it could not resolve its own hostname. The user is handling it.
+
+## 0.40.27 Release Record
+
+Release commit `f84ce2b` on `main` (cut after PR #17, merge `9dad219`); tag `v0.40.27`.
+
+**Publishing**
+- `publish.yml` run 37419470087 passed all six platforms on the first attempt, then npm publish with SLSA v1 provenance and the GitHub Release (2026-10-06 05:57 UTC).
+- `npm run release:verify` on the release commit passed on its second run. The first failed in package smoke, where the fake DevTools endpoint did not answer within 500 ms while the host load average was about 30 (8 cores).
+
+**What it fixes**
+- Source pills in page-read answers are spelled out as markdown links or `[label]`.
+- Recovery waits for the thread's turns instead of refusing its own request right after navigating.
+
+**Installation on 2026-10-06**
+- Global npm, each verified with `prodex --version` = 0.40.27.
+- WSL, M3, Mac mini: installed. Running services were not restarted: 5 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.
+
+**Live check after install (installed 0.40.27, shared WSL browser)**
+- All answered:
+  - a new-chat attachment
+  - a web-search answer, ending in a markdown source link
+  - a project send
+  - `pro browser recover` with the tab on another conversation, which returned the answer
+
+**Browser container, same day**
+- The pill and recovery fixes were adapted to the branch code.
+- A consult from another session (task `task_20261006_050125`, 05:01 UTC) had been refused with `composer_not_ready`. Back-to-back `--model Pro` new-chat sends reproduced a related failure, `fresh_chat_not_ready`: the new-chat page took more than 15 s to settle with the host load average at 28-32. The branch's new-chat ceiling was raised to 30 s. It is only a ceiling.
+- Image `sha256:2b76266ad524`. The earlier interrupted-looking consult `task_20261006_050200` had finished at 05:07, before the swap.
+- The swap was gated on the send lock being free.
+- Two branch tests failed in the pre-build run, and the build script did not stop on test failures, so the image was built and swapped anyway. One test advanced a fake clock 25 s against the new 30 s ceiling; it was fixed. The other was a load-sensitive project-sidebar test, which passed on rerun. After that, the full branch suite passed (2002). The image's runtime code is the code that passed.
+- Verified: three back-to-back `--model Pro --pro-mode` new-chat sends answered (44-50 s each).
+
 ## 0.40.26 Release Record
 
 Release commit `b413c24` on `main` (cut after PR #16, merge `af5cf20`); tag `v0.40.26`.

package/package.json

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