@youdie006/prodex 0.40.31 → 0.40.32

package/README.md

@@ -93,7 +93,7 @@ Useful flags on every send:
 |---|---|
 | `--new-chat` | Explicitly request the default: ordinary consults start in a fresh chat. The shared current tab is never an implicit destination. |
 | `--session-key id` | Identify one caller for scoped `--continue`. Falls back to `PRODEX_SESSION_KEY`, then `CODEX_THREAD_ID`. |
-| `--file path` | Inline a text file's contents into the prompt. Repeatable. |
+| `--file path` | Inline a text file's contents into the prompt, up to 500 lines; a longer file is refused with a pointer to `--attach`. Repeatable. |
 | `--attach path` | Upload the file itself: the only way to hand ChatGPT a pdf, pptx, xlsx or image. Paths must live inside the repo. |
 | `--tool web-search` | Select a rendered composer tool. Automatic deep-research report retrieval is currently unsupported and is blocked before sending. |
 | `--project "name"` | Send inside an existing sidebar project. `--project-new` creates one first. `prodex pro browser projects` lists exact names. |

package/dist/bundle.js

@@ -32,6 +32,8 @@ export function looksLikeBinaryFileContent(content) {
     }
     return control / sample.length > 0.1;
 }
+/** The most lines `--file` puts into a prompt; longer files go through --attach. */
+export const INLINE_FILE_MAX_LINES = 500;
 export async function buildDryRunBundle(root, input) {
     const sections = [
         "# prodex consult dry run",
@@ -46,7 +48,13 @@ export async function buildDryRunBundle(root, input) {
     // The prompt leads so the instruction is never buried under file dumps.
     const sendSections = [input.prompt.trim()];
     for (const file of input.files) {
-        const content = await readRepoFile(root, file, { maxLines: 500 });
+        const content = await readRepoFile(root, file, { maxLines: INLINE_FILE_MAX_LINES });
+        // Sending only the first lines without saying so made ChatGPT answer
+        // confidently about a file it never saw whole (measured 2026-10-13).
+        if (content.total_lines > content.end_line) {
+            throw new Error(`--file ${file} has ${content.total_lines} lines; --file inlines at most ${INLINE_FILE_MAX_LINES}. ` +
+                `Upload the whole file instead: --attach ${file}.`);
+        }
         if (looksLikeBinaryFileContent(content.content)) {
             throw new Error(`--file ${file} is not a text file, and --file inlines a file's TEXT into the prompt. ` +
                 `Upload it instead: --attach ${file}.`);

package/dist/chatgpt-browser.js

@@ -432,7 +432,21 @@ export const CHATGPT_MODEL_HINTS_JS = `
       }
       return seen.slice(0, 30);
     };`;
-const CHATGPT_MESSAGE_NODES_JS = `${CHATGPT_RENDERED_MESSAGE_TEXT_JS}
+/**
+ * ChatGPT collapses a long user turn behind "Show more" and leaves the rest
+ * out of the DOM (measured 2026-10-13: 10,250 of 12,095 characters, the request
+ * marker among the missing). Clicking it only changes what is displayed, and
+ * the full text renders after the click returns, so the caller reads again.
+ */
+export const CHATGPT_EXPAND_USER_TURN_JS = `
+    const expandCollapsedUserTurn = (node) => {
+      if (!node || typeof node.querySelector !== 'function') return false;
+      const more = node.querySelector('button[aria-expanded="false"]');
+      if (!more) return false;
+      more.click();
+      return true;
+    };`;
+const CHATGPT_MESSAGE_NODES_JS = `${CHATGPT_RENDERED_MESSAGE_TEXT_JS}${CHATGPT_EXPAND_USER_TURN_JS}
     // ChatGPT keeps a previously opened conversation mounted but hidden
     // (measured 2026-10-06: two turns without a box on a project home), and
     // counting them made a fresh chat look like an existing conversation.
@@ -3679,6 +3693,7 @@ export async function recoverChatGptAnswerFromThread(options) {
     let state;
     let generating = false;
     let stableRuns = 0;
+    let expandingPolls = 0;
     let lastAnswer = "";
     let lastObservedUrl = "";
     let completed = false;
@@ -3719,6 +3734,12 @@ export async function recoverChatGptAnswerFromThread(options) {
                 lastAnswer = "";
                 continue;
             }
+            if (chatGptUserTurnStillExpanding(state, expandingPolls)) {
+                expandingPolls += 1;
+                stableRuns = 0;
+                lastAnswer = "";
+                continue;
+            }
             if (options.requestId && !chatGptRequestMarkerMatches(state.lastUserText ?? "", options.requestId)) {
                 throw new ChatGptBrowserBlockerError({
                     code: "request_mismatch",
@@ -4188,6 +4209,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);
+      if (last && expandCollapsedUserTurn(last.textNode)) return false;
       return Boolean(last && userMessageText(last.textNode).includes(${JSON.stringify(`[prodex-request:${requestId}]`)}));
     })()`;
         // A dispatch can reach Chrome even if its acknowledgement is lost.
@@ -4232,6 +4254,7 @@ export async function sendChatGptPrompt(options) {
     const acceptDeadline = computePromptAcceptanceDeadline(timeoutMs, started);
     let accepted = false;
     let finalState;
+    let expandingPolls = 0;
     while (Date.now() < acceptDeadline) {
         await sleep(500);
         try {
@@ -4254,6 +4277,10 @@ export async function sendChatGptPrompt(options) {
             accepted = true;
             break;
         }
+        if (chatGptUserTurnStillExpanding(finalState, expandingPolls)) {
+            expandingPolls += 1;
+            continue;
+        }
         if (hasChatGptPromptAcceptance(beforeSubmit, finalState))
             throw requestMismatch(normalizedTargetUrl);
         emitProgress("waiting", "prompt posting");
@@ -4295,6 +4322,7 @@ export async function sendChatGptPrompt(options) {
         : undefined;
     let consecutiveReadFailures = 0;
     let answerSettled = false;
+    expandingPolls = 0;
     let nonTextPolls = 0;
     let nonTextSettled = false;
     const answerIsStable = createChatGptAnswerStabilityTracker();
@@ -4303,6 +4331,10 @@ export async function sendChatGptPrompt(options) {
         try {
             const observedState = await evaluateOnPage(page, answerExpression());
             consecutiveReadFailures = 0;
+            if (chatGptUserTurnStillExpanding(observedState, expandingPolls)) {
+                expandingPolls += 1;
+                continue;
+            }
             // Freeze the first conversation identity the accepted page exposes. A
             // later tab move must never rewrite result metadata to another thread.
             if (!pinnedConversationId) {
@@ -5905,16 +5937,15 @@ async function insertComposerTextViaCdp(cdp, text, page, toolLabels = []) {
     // Both failures come from crossing the CDP boundary mid-edit, so large text
     // is inserted by a single in-page execCommand instead: the editor applies it
     // as one input event and nothing can interleave. Measured: 67 KB inserted in
-    // ~20s, verified byte-for-byte.
+    // ~20s, verified byte-for-byte; 57 KB took 63-126 s on 2026-10-13.
     if (text.length <= COMPOSER_INSERT_CHUNK_CHARS) {
         await cdp.send("Input.insertText", { text });
     }
     else {
-        // A 67 KB insert measured ~20s in the page, which the default 20s CDP
-        // command budget would cut off, so this one call gets its own connection
-        // with a size-scaled budget instead of loosening the budget for every
-        // command on the shared connection.
-        const budgetMs = Math.max(60_000, Math.ceil(text.length / 1_000) * 1_000);
+        // A large insert outlasts the default 20s CDP command budget, so this one
+        // call gets its own connection with a size-scaled budget instead of
+        // loosening the budget for every command on the shared connection.
+        const budgetMs = composerInsertBudgetMs(text.length);
         const slowCdp = page ? await connectCdp(page.webSocketDebuggerUrl, budgetMs) : undefined;
         try {
             const target = slowCdp ?? cdp;
@@ -5934,6 +5965,16 @@ async function insertComposerTextViaCdp(cdp, text, page, toolLabels = []) {
         throw new Error(state.reason ?? "Composer stayed empty after text insertion");
 }
 export const COMPOSER_INSERT_CHUNK_CHARS = 4_000;
+/**
+ * How long one in-page insert of `chars` characters may take. Measured
+ * 2026-10-13: 10 s for 15 KB, 34 s for 30 KB, and 63 s then 126 s for the same
+ * 57 KB - far slower than when this path was built (67 KB in ~20 s), and the
+ * old one-second-per-KB budget cut a 57 KB prompt off. 5 ms per character
+ * covers the slowest measured run with room to spare.
+ */
+export function composerInsertBudgetMs(chars) {
+    return Math.max(60_000, chars * 5);
+}
 /**
  * Split composer text into insertText-sized pieces. Splits on code points (not
  * UTF-16 units) so a surrogate pair - an emoji, or any astral character - can
@@ -6061,6 +6102,15 @@ function chatGptRequestMarkerMatches(userText, requestId) {
     const markers = [...normalizeChatGptPromptText(userText).matchAll(/\[prodex-request:([a-f0-9]{32})\]/g)];
     return markers.at(-1)?.[1] === requestId && markers.filter((match) => match[1] === requestId).length === 1;
 }
+/**
+ * A collapsed user turn is not judged until its expanded text has rendered.
+ * Bounded, so a turn that collapses again on every render is judged in the end
+ * instead of holding the send until its timeout.
+ */
+export function chatGptUserTurnStillExpanding(state, skippedPolls = 0) {
+    return state.lastUserCollapsed === true && skippedPolls < USER_TURN_EXPAND_MAX_POLLS;
+}
+export const USER_TURN_EXPAND_MAX_POLLS = 10;
 /** Full prompt and per-send identity; wrappers may contain tool/file labels. */
 export function chatGptRequestMatchesUserTurn(userText, sentPrompt, requestId) {
     if (!chatGptRequestMarkerMatches(userText, requestId))
@@ -6370,10 +6420,11 @@ export function answerExpression() {
         if (tagged) modelSlug = tagged.getAttribute('data-message-model-slug') || undefined;
       }
       // User turns stay as typed: the request marker is matched against them.
-      return { role, node, text: role === "assistant" ? renderedMessageText(textNode) : userMessageText(textNode), modelSlug };
+      return { role, node, textNode, text: role === "assistant" ? renderedMessageText(textNode) : userMessageText(textNode), modelSlug };
     });
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     const userMessages = messages.filter((message) => message.role === "user");
+    const lastUserCollapsed = expandCollapsedUserTurn(userMessages.at(-1)?.textNode);
     // A turn without an assistant message is NOT an answer. Treating one as an
     // answer (a 0.21.3 fallback for deep research, which is read from the
     // transcript now) turned a tool's progress panel into a 28-character
@@ -6407,6 +6458,7 @@ export function answerExpression() {
       assistantMessageCount: assistantMessages.length,
       userMessageCount: userMessages.length,
       lastUserText: userMessages.at(-1)?.text || "",
+      lastUserCollapsed,
       // An image result is rendered outside every message unit and leaves no
       // assistant message at all (measured 2026-09-29), so it is reported here
       // for the waiter to recognize: a generated image that comes after the

package/docs/releasing.md

@@ -16,6 +16,40 @@ 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.
 
+## Browser Incident 2026-10-10: earlyoom
+
+**What happened**
+- The host's dedicated browser (port 9333) stopped answering twice: around 11:49 and at 17:45 KST. The browser container exited at 11:49 KST (exit 1, `chromium exited (SIGTRAP)`, restart policy `no`) and stayed down.
+- The hourly canary logged `skipped - the browser is not available` from 18:17 KST on, and filed nothing.
+
+**Cause**
+- The machine's `earlyoom` (override from 2026-08-14: `-m 15 -s 40`) sent SIGTERM to Chrome and Chromium processes: 25 between 11:45 and 11:49, 17 at 17:45. It acts when available memory is under 15% and free swap under 40%. Swap was 88% used (1 GiB free of 8), so every dip under 15% memory picked a process, and Chrome's processes carried the highest badness (800-876).
+- Earlier days show the same: 248 Chrome kills on 2026-10-08 (09:00-11:59 KST), which likely explains that day's browser losses.
+- At 19:03 earlyoom also killed `chrome-headless`, `swapdex`, `ssh` and `dbus-daemon` processes, so the pressure is machine-wide, not prodex's.
+
+**Recovery**
+- Host browser restarted once on the Xvfb display (`login --virtual-display`, logged in, 4 s); the container started from the same image `547e852632b5` and its tab reopened (2 s). The canary from `12aab1e` (PR #24, re-read before reporting broken) then reported `ok` on build `314720d0`.
+
+**Not changed**
+- The earlyoom configuration and the container restart policy. Both are the maintainer's machine-level choices.
+
+## 0.40.31 Release Record
+
+Release commit `0b10dd1` on `main` (cut after PR #23, merge `d5296e0`); tag `v0.40.31`.
+
+**Publishing**
+- `publish.yml` run 38019182789 passed all six platforms on the first attempt, then npm publish with SLSA v1 provenance and the GitHub Release (2026-10-10 03:03 UTC).
+- `npm run release:verify` passed on the release commit after a build.
+
+**Installed**
+- WSL, M3, Mac mini: `prodex --version` reports 0.40.31. Running services were not restarted: 4 stdio MCP servers on WSL and 4 on M3 keep older code until their clients reconnect. The Mac mini had none running.
+- The maintainer watchdog checkout (`~/.local/share/prodex-maint/repo`) was pulled to `0b10dd1` and rebuilt, so the hourly canary now uses the live build check and the renderer markers.
+
+**Verified live**
+- Host 0.40.31: a Markdown `--file` new-chat send answered (`opal-5`).
+- The host's dedicated browser had stopped answering on port 9333 after about 11:18 KST; it was restarted once on the Xvfb display (`login --virtual-display`, logged in, 5 s). Cause not established.
+- The canary's first run right after that restart reported `broken: model selector`, because the composer had not rendered yet; the next run was `ok` on build `314720d0`. The model picker lists GPT-6, GPT-5.6 Sol and GPT-5.5.
+
 ## Browser Container Rebuild 2026-10-10
 
 **Patches**
@@ -60,7 +94,7 @@ Release commit `e566efc` on `main` (cut after PR #22, merge `c0964f2`, plus the
 On the maintainer's WSL machine, cron runs the UI watchdog every hour (since 2026-10-08):
 
 ```
-17 * * * * PATH=<node bin>:/usr/bin:/bin PRODEX_CLI=~/.local/share/prodex-maint/prodex PRODEX_WATCHDOG_CWD=/mnt/d/MyProject/gptprouse <node> ~/.local/share/prodex-maint/repo/scripts/ui-watchdog.mjs --canary --file-issue >> ~/.local/state/prodex-watchdog.log 2>&1
+17 * * * * PATH=<node bin>:/usr/bin:/bin PRODEX_CLI=~/.local/share/prodex-maint/prodex PRODEX_WATCHDOG_CWD=/mnt/d/MyProject/gptprouse <node> ~/.local/share/prodex-maint/repo/scripts/ui-watchdog.mjs --canary --revive --file-issue >> ~/.local/state/prodex-watchdog.log 2>&1
 ```
 
 **What each run does**
@@ -68,8 +102,10 @@ On the maintainer's WSL machine, cron runs the UI watchdog every hour (since 202
   - It records ChatGPT's build id and whether each control prodex relies on is present.
   - It compares with `~/.local/share/prodex/page-canary.json`.
   - It skips while a consult holds the send lock.
+  - A broken read is read again up to twice, 10 s apart, and counts only if it stays broken. Right after a browser restart on 2026-10-10 the first read found no model selector because the composer had not rendered yet.
 - Only when the canary reports changed (3) or broken (2) does the watchdog run `pro browser smoke` (a fresh chat, 5-minute budget). If that fails, it files or extends a GitHub issue by blocker code.
 - A busy browser is logged as skipped and never filed.
+- With `--revive` (since 2026-10-10), a canary that finds the dedicated browser gone, or without a ChatGPT tab, makes the watchdog run `pro browser login --virtual-display --wait` once and read the page again. It does this at most once every 6 hours (`~/.local/state/prodex-maint/revive.json`), so a machine short of memory does not get a new Chrome every hour. A consult holding the lock, or a tab that stopped answering, is never touched. This came from the earlyoom incident below, where the browser stayed down for hours.
 
 **Where it runs from**
 - `~/.local/share/prodex-maint/repo` is a clone of `main`, built with `npm ci && npm run build`.
@@ -84,6 +120,7 @@ On the maintainer's WSL machine, cron runs the UI watchdog every hour (since 202
   - It timed out at 90 s on high efforts (issue #4).
   - It filed a busy browser as broken (issue #20, closed as a false positive).
 - The crontab before the change is saved at `~/.local/state/prodex-maint/crontab.backup-20261008`.
+- `--revive` was added to the cron line on 2026-10-11 after PR #25 (merge `9c9a1b4`); the checkout was pulled to that merge and rebuilt, and one manual run was `ok`. The crontab before that edit is saved at `~/.local/state/prodex-maint/crontab.backup-20261011`.
 
 ## 0.40.29 Release Record
 

package/package.json

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