@youdie006/prodex 0.27.2 → 0.28.0

package/dist/chatgpt-browser.js

@@ -1915,6 +1915,23 @@ async function readTranscriptAnswer(page, conversationId, sentPrompt) {
         ? { classification: "answer", answer: { answer, modelSlug: transcript.modelSlug } }
         : { classification: "pending" };
 }
+// A page that has not reported the prompt posting within this long is worth
+// double-checking against the transcript; the probe is a couple of small fetches.
+const ACCEPTANCE_TRANSCRIPT_PROBE_AFTER_MS = 20_000;
+const ACCEPTANCE_TRANSCRIPT_PROBE_EVERY_MS = 10_000;
+/** Which conversation, if any, already holds the prompt this send posted. */
+async function findLandedConversation(page, prompt) {
+    try {
+        const candidates = await evaluateOnPage(page, recentConversationsExpression(4), {
+            timeoutMs: 30_000
+        });
+        return pickLandedConversation(candidates ?? [], prompt);
+    }
+    catch {
+        // Transcript unavailable: the caller falls back to the page.
+        return undefined;
+    }
+}
 export async function sendChatGptPrompt(options) {
     const port = resolveCdpPort(options.port);
     const timeoutMs = options.timeoutMs ?? 90_000;
@@ -2135,8 +2152,27 @@ export async function sendChatGptPrompt(options) {
     const acceptDeadline = computePromptAcceptanceDeadline(timeoutMs, started);
     let accepted = false;
     let finalState;
+    // Seeded either from the url once ChatGPT rewrites it, or - when the page
+    // never showed the prompt post - from the transcript that proves it did.
+    let transcriptConversationId;
+    // Ask the transcript early rather than only at the deadline. Acceptance runs
+    // on the full send budget, so a page that stops reporting the prompt posting
+    // used to burn all twenty minutes before saying anything - while the prompt
+    // sat in a conversation the whole time.
+    let nextTranscriptProbeAt = started + ACCEPTANCE_TRANSCRIPT_PROBE_AFTER_MS;
     while (Date.now() < acceptDeadline) {
         await sleep(500);
+        if (Date.now() >= nextTranscriptProbeAt) {
+            nextTranscriptProbeAt = Date.now() + ACCEPTANCE_TRANSCRIPT_PROBE_EVERY_MS;
+            const landed = await findLandedConversation(page, options.prompt);
+            if (landed) {
+                transcriptConversationId = landed;
+                accepted = true;
+                sendWarnings.push("prompt_acceptance_unreadable: the page never showed the prompt posting, but the transcript has it - continuing on the conversation the transcript names.");
+                dbgSend(`acceptance recovered from transcript conversation=${landed}`);
+                break;
+            }
+        }
         try {
             finalState = await evaluateOnPage(page, answerExpression());
         }
@@ -2186,7 +2222,19 @@ export async function sendChatGptPrompt(options) {
         catch {
             // best effort: fall back to submit-button signal only
         }
-        throw acceptanceTimeoutError({ timeoutMs, composerStillHasText, submitButtonFound });
+        // Before calling this a failed send: did the prompt actually land? Reading
+        // acceptance off the page means a changed DOM reports "never posted" for a
+        // prompt that posted fine, and the caller's retry asks ChatGPT the same
+        // question twice. The transcript is the ground truth.
+        const landed = await findLandedConversation(page, options.prompt);
+        if (landed) {
+            transcriptConversationId = landed;
+            accepted = true;
+            sendWarnings.push("prompt_acceptance_unreadable: the page never showed the prompt posting, but the transcript has it - continuing on the conversation the transcript names.");
+            dbgSend(`acceptance recovered from transcript conversation=${landed}`);
+        }
+        if (!accepted)
+            throw acceptanceTimeoutError({ timeoutMs, composerStillHasText, submitButtonFound });
     }
     // Pin the conversation the prompt actually landed in. The browser is shared
     // (other agents, the user, tooling), and a tab that moves mid-wait made
@@ -2199,7 +2247,9 @@ export async function sendChatGptPrompt(options) {
     // a finished answer was lost: the tab returned to the project page, the url
     // still matched the pin taken before ChatGPT rewrote it, and the DOM reader
     // sat on zero assistant messages until the budget ran out.
-    let transcriptConversationId = pinnedThreadUrl ? conversationIdFromThreadUrl(pinnedThreadUrl) : undefined;
+    // Acceptance may already have adopted one from the transcript; otherwise take
+    // it from the url ChatGPT rewrote to.
+    transcriptConversationId ??= pinnedThreadUrl ? conversationIdFromThreadUrl(pinnedThreadUrl) : undefined;
     const transcriptResult = (transcript) => {
         emitProgress("answered", `transcript (${transcript.answer.length} chars)`);
         return {
@@ -3218,12 +3268,70 @@ export function deepResearchUnreadableBlocker(threadUrl) {
     };
 }
 /**
- * The transcript is the same data the UI renders, minus the rendering: it
- * carries the answer as markdown (tables and fenced code survive, which
- * innerText flattens), an explicit finish state, and the model that actually
- * answered. Walk from `current_node` up the parents so a regenerated turn reads
- * the branch the UI is on, not an abandoned sibling.
+ * The most recently updated conversations, each with the prompt it opens with.
+ *
+ * Acceptance is otherwise read off the page: if the DOM changes shape, a prompt
+ * that DID post looks like one that never left, the send fails, and the
+ * caller's retry asks ChatGPT the same question twice. The transcript settles
+ * it - the conversation either holds our prompt or it does not.
+ *
+ * Only the head of each prompt is returned: a research transcript runs to
+ * hundreds of KB and none of that is needed to recognise it.
  */
+export function recentConversationsExpression(limit = 4) {
+    return `(async () => {
+  const out = [];
+  let token = "";
+  try {
+    const session = await fetch("/api/auth/session", { credentials: "include" });
+    if (!session.ok) return out;
+    const parsed = await session.json();
+    token = (parsed && parsed.accessToken) || "";
+  } catch (error) {
+    return out;
+  }
+  const headers = token ? { Authorization: "Bearer " + token } : {};
+  let items = [];
+  try {
+    const response = await fetch("/backend-api/conversations?offset=0&limit=${limit}&order=updated", {
+      credentials: "include",
+      headers
+    });
+    if (!response.ok) return out;
+    const listed = await response.json();
+    items = (listed && listed.items) || [];
+  } catch (error) {
+    return out;
+  }
+  for (const item of items) {
+    if (!item || !item.id) continue;
+    try {
+      const response = await fetch("/backend-api/conversation/" + item.id, { credentials: "include", headers });
+      if (!response.ok) continue;
+      const conversation = await response.json();
+      const mapping = (conversation && conversation.mapping) || {};
+      const chain = [];
+      let nodeId = conversation && conversation.current_node;
+      let guard = 0;
+      while (nodeId && mapping[nodeId] && guard < 2000) {
+        guard += 1;
+        if (mapping[nodeId].message) chain.push(mapping[nodeId].message);
+        nodeId = mapping[nodeId].parent;
+      }
+      const user = chain.find((entry) => entry && entry.author && entry.author.role === "user" && entry.content);
+      const text = user ? (user.content.parts || []).filter((part) => typeof part === "string").join("") : "";
+      out.push({ id: item.id, userText: text.slice(0, 600) });
+    } catch (error) {
+      // A conversation we cannot read is simply not a match.
+    }
+  }
+  return out;
+})()`;
+}
+/** Which of those conversations is the one this send posted into, if any. */
+export function pickLandedConversation(candidates, sentPrompt) {
+    return candidates.find((candidate) => transcriptMatchesSentPrompt(candidate.userText, sentPrompt))?.id;
+}
 export function transcriptAnswerExpression(conversationId) {
     return `(async () => {
   const fail = (reason, extra) => Object.assign({ ok: false, reason, status: "", endTurn: false, isComplete: false, text: "", modelSlug: "", references: [], userText: "" }, extra || {});

package/dist/tui-run.js

@@ -7,7 +7,7 @@
  * what keeps the interactive path from drifting away from the documented flags.
  */
 import readline from "node:readline";
-import { consultArgsFromChoices, moveCursor, renderContextPanel, renderProgressBar, renderSelectList, toggleSelection } from "./tui.js";
+import { consultArgsFromChoices, moveCursor, progressLabel, renderContextPanel, renderProgressBar, renderSelectList, toggleSelection } from "./tui.js";
 const ESC = "";
 const CLEAR = `${ESC}[2J${ESC}[H`;
 // The alternate screen buffer: the terminal comes back exactly as it was, so a
@@ -272,7 +272,7 @@ export async function runInteractiveConsult(io, deps) {
         }, 250);
         try {
             const code = await deps.runConsult(args, (line) => {
-                label = line.replace(/^progress:\s*/, "").slice(0, 60);
+                label = progressLabel(line).slice(0, 60);
             });
             clearInterval(timer);
             io.write(CLEAR_LINE);

package/dist/tui.js

@@ -115,6 +115,25 @@ function formatElapsed(ms) {
     const rest = seconds % 60;
     return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
 }
+/**
+ * Turn a `progress:` line from the send into the label beside the bar.
+ *
+ * The bar already carries the elapsed clock, so a label that opens with
+ * "waiting 2m 57s" prints the same number twice and pushes the part worth
+ * reading off to the right. Keep the detail, drop the duplicate.
+ */
+export function progressLabel(line) {
+    const text = line.replace(/^progress:\s*/, "").trim();
+    const waiting = /^waiting\s+[0-9]+[a-z]*(?:\s+[0-9]+[a-z]*)*\s*(.*)$/i.exec(text);
+    if (!waiting)
+        return text;
+    const detail = waiting[1].trim();
+    if (detail.length === 0)
+        return "waiting";
+    // The send wraps its detail in parentheses; the bar reads better without them.
+    const unwrapped = /^\((.*)\)$/.exec(detail);
+    return (unwrapped ? unwrapped[1] : detail).trim();
+}
 const SPINNER = ["|", "/", "-", "\\"];
 /**
  * A Pro consult can run for many minutes with nothing on screen. The bar fills

package/package.json

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