@youdie006/prodex 0.24.0 → 0.25.1

package/dist/bundle.js

@@ -12,10 +12,14 @@ export async function buildDryRunBundle(root, input) {
         input.prompt.trim()
     ];
     const files = [];
+    // 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 });
         files.push({ path: file, role: "context", bytes: Buffer.byteLength(content.content, "utf8") });
-        sections.push("", `## File: ${file}`, "", "```text", content.content, "```");
+        const fileSection = ["", `## File: ${file}`, "", "```text", content.content, "```"];
+        sections.push(...fileSection);
+        sendSections.push(...fileSection);
     }
     return {
         schema_version: SCHEMA_VERSION,
@@ -24,6 +28,7 @@ export async function buildDryRunBundle(root, input) {
         prompt: input.prompt,
         files,
         text: sections.join("\n"),
+        sendText: sendSections.join("\n"),
         created_at: nowIso()
     };
 }

package/dist/chatgpt-browser.js

@@ -402,8 +402,63 @@ export function isUsableChatGptAnswer(answer) {
         if (headerOnly)
             return false;
     }
+    // A composer tool renders its own progress panel into the assistant turn
+    // before any text exists. Measured on a --tool web-search send: "Searching
+    // the web" over an "Answer now" button, which the page reports as a settled
+    // two-line answer. Only treat it as a placeholder when it is the WHOLE
+    // content, so an answer that discusses searching still counts.
+    if (lineCount <= 2) {
+        const toolPanelOnly = normalized
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .every((line) => /^(searching the web|웹\s*검색\s*중|answer now|지금\s*답변|검색\s*중)$/i.test(line));
+        if (toolPanelOnly)
+            return false;
+    }
     return true;
 }
+/**
+ * Who decides the answer is finished: the transcript, when it can be read.
+ *
+ * The page only guesses - a tool's progress panel looks exactly like a settled
+ * two-line answer, and a consult once returned "Searching the web / Answer now"
+ * as its result. When the transcript is reachable AND belongs to this consult,
+ * its state is authoritative: "pending" keeps the wait alive even if the page
+ * looks done. "unavailable" (unreachable, or a different conversation) is the
+ * only case that falls back to reading the page.
+ */
+export function classifyTranscriptRead(state, sentPrompt) {
+    if (!state)
+        return "unavailable";
+    if (!transcriptMatchesSentPrompt(state.userText, sentPrompt))
+        return "unavailable";
+    if (state.ok)
+        return "answer";
+    return state.reason === "answer_not_finished" || state.reason === "no_assistant_message" || state.reason === "answer_empty"
+        ? "pending"
+        : "unavailable";
+}
+/**
+ * Should prodex drag the tab back to the thread it pinned?
+ *
+ * Only when the pin is a real conversation, and only when the page is the only
+ * way left to read the answer. Pinning a project or new-chat page (the url a
+ * send starts on, before ChatGPT rewrites it to /c/<id>) made prodex treat its
+ * OWN conversation as a stray tab and navigate away from the answer it was
+ * waiting for. And while the transcript can answer, moving someone else's tab
+ * back buys nothing.
+ */
+export function shouldRecoverThreadNavigation(args) {
+    const { pinnedThreadUrl, currentUrl, lastTranscriptClassification } = args;
+    if (!pinnedThreadUrl || !currentUrl)
+        return false;
+    if (!conversationIdFromThreadUrl(pinnedThreadUrl))
+        return false;
+    if (lastTranscriptClassification === "pending" || lastTranscriptClassification === "answer")
+        return false;
+    return !chatGptUrlsReferToSameTarget(currentUrl, pinnedThreadUrl);
+}
 export function hasFreshChatGptAnswer(previousAssistantMessageCount, state) {
     return state.assistantMessageCount > previousAssistantMessageCount && isUsableChatGptAnswer(state.answer) && !state.generating;
 }
@@ -1750,25 +1805,23 @@ export async function recoverChatGptAnswerFromThread(options) {
         warnings: []
     };
 }
-/**
- * Read the answer from the conversation transcript, or undefined when it is not
- * there yet. The transcript trails the rendered stream by a beat, so callers
- * either poll it or fall back to the DOM text.
- */
-async function readTranscriptAnswer(page, conversationId) {
+async function readTranscriptAnswer(page, conversationId, sentPrompt) {
     let transcript;
     try {
         transcript = await evaluateOnPage(page, transcriptAnswerExpression(conversationId), { timeoutMs: 30_000 });
     }
     catch {
-        // Transcript unavailable (endpoint changed, transient failure): the DOM
+        // Transcript unreachable (endpoint changed, transient failure): the DOM
         // reader still runs, so this never blocks a send.
-        return undefined;
+        return { classification: "unavailable" };
     }
-    if (!transcript.ok || transcript.text.trim().length === 0)
-        return undefined;
+    const classification = classifyTranscriptRead(transcript, sentPrompt);
+    if (classification !== "answer")
+        return { classification };
     const answer = resolveTranscriptCitations(transcript.text, transcript.references).trim();
-    return answer.length > 0 ? { answer, modelSlug: transcript.modelSlug } : undefined;
+    return answer.length > 0
+        ? { classification: "answer", answer: { answer, modelSlug: transcript.modelSlug } }
+        : { classification: "pending" };
 }
 export async function sendChatGptPrompt(options) {
     const port = resolveCdpPort(options.port);
@@ -2084,7 +2137,7 @@ export async function sendChatGptPrompt(options) {
                 await sleep(5_000);
                 continue;
             }
-            if (lastState.ok && lastState.report.trim().length > 0) {
+            if (lastState.ok && lastState.report.trim().length > 0 && transcriptMatchesSentPrompt(lastState.userText, options.prompt)) {
                 const report = resolveTranscriptCitations(lastState.report, lastState.references).trim();
                 emitProgress("answered", `deep research report (${report.length} chars)`);
                 return {
@@ -2110,24 +2163,28 @@ export async function sendChatGptPrompt(options) {
         });
     }
     let recoveredNavigations = 0;
+    let lastTranscriptClassification;
     const answerIsStable = createChatGptAnswerStabilityTracker();
     while (Date.now() - started < timeoutMs) {
         await sleep(1000);
         try {
             finalState = await evaluateOnPage(page, answerExpression());
+            // First conversation id wins. Re-deriving it every poll would let a tab
+            // that wandered to another thread redirect the read to a stranger's
+            // conversation - and the prompt check below is the second line of defence,
+            // not the first.
             if (!transcriptConversationId && finalState?.url)
                 transcriptConversationId = conversationIdFromThreadUrl(finalState.url);
             // The transcript is the same data the page renders, minus the rendering:
             // markdown instead of flattened innerText, an explicit finish state
             // instead of caret heuristics, and the model that actually answered.
             if (transcriptConversationId && !finalState.generating) {
-                const transcript = await readTranscriptAnswer(page, transcriptConversationId);
-                if (transcript)
-                    return transcriptResult(transcript);
+                const transcript = await readTranscriptAnswer(page, transcriptConversationId, options.prompt);
+                lastTranscriptClassification = transcript.classification;
+                if (transcript.answer)
+                    return transcriptResult(transcript.answer);
             }
-            // Only the DOM reader depends on which thread the tab is showing; once the
-            // conversation id is known, a wandering tab is harmless.
-            if (!transcriptConversationId && pinnedThreadUrl && finalState?.url && !chatGptUrlsReferToSameTarget(finalState.url, pinnedThreadUrl)) {
+            if (shouldRecoverThreadNavigation({ pinnedThreadUrl, currentUrl: finalState?.url, lastTranscriptClassification })) {
                 if (recoveredNavigations >= 2) {
                     throw new ChatGptBrowserBlockerError({
                         code: "thread_navigated_away",
@@ -2167,12 +2224,16 @@ export async function sendChatGptPrompt(options) {
             // Give the transcript that beat: it carries markdown (tables and fenced
             // code that innerText flattens) and the model that actually answered.
             if (transcriptConversationId) {
-                for (let attempt = 0; attempt < 6; attempt += 1) {
-                    const transcript = await readTranscriptAnswer(page, transcriptConversationId);
-                    if (transcript)
-                        return transcriptResult(transcript);
-                    await sleep(1_500);
-                }
+                const transcript = await readTranscriptAnswer(page, transcriptConversationId, options.prompt);
+                lastTranscriptClassification = transcript.classification;
+                if (transcript.answer)
+                    return transcriptResult(transcript.answer);
+                // The transcript can read this conversation and says it is not done:
+                // believe it over a page that merely looks settled. A tool's progress
+                // panel renders exactly like a two-line answer, and that is how a
+                // consult once returned "Searching the web / Answer now" as its result.
+                if (transcript.classification === "pending")
+                    continue;
             }
             break;
         }
@@ -3030,7 +3091,7 @@ export function deepResearchUnreadableBlocker(threadUrl) {
  */
 export function transcriptAnswerExpression(conversationId) {
     return `(async () => {
-  const fail = (reason, extra) => Object.assign({ ok: false, reason, status: "", endTurn: false, isComplete: false, text: "", modelSlug: "", references: [] }, extra || {});
+  const fail = (reason, extra) => Object.assign({ ok: false, reason, status: "", endTurn: false, isComplete: false, text: "", modelSlug: "", references: [], userText: "" }, extra || {});
   let token = "";
   try {
     const session = await fetch("/api/auth/session", { credentials: "include" });
@@ -3063,7 +3124,9 @@ export function transcriptAnswerExpression(conversationId) {
   const message = chain.find(
     (entry) => entry && entry.author && entry.author.role === "assistant" && entry.content && entry.content.content_type === "text"
   );
-  if (!message) return fail("no_assistant_message");
+  const userMessage = chain.find((entry) => entry && entry.author && entry.author.role === "user" && entry.content);
+  const userText = userMessage ? (userMessage.content.parts || []).filter((part) => typeof part === "string").join("") : "";
+  if (!message) return fail("no_assistant_message", { userText });
   const parts = (message.content.parts || []).filter((part) => typeof part === "string");
   const text = parts.join("");
   const metadata = message.metadata || {};
@@ -3073,13 +3136,41 @@ export function transcriptAnswerExpression(conversationId) {
     isComplete: metadata.is_complete === true,
     text,
     modelSlug: metadata.model_slug || "",
-    references: Array.isArray(metadata.content_references) ? metadata.content_references : []
+    references: Array.isArray(metadata.content_references) ? metadata.content_references : [],
+    userText
   };
   if (state.status !== "finished_successfully" || !state.endTurn) return fail("answer_not_finished", state);
   if (!text) return fail("answer_empty", state);
   return Object.assign({ ok: true, reason: "" }, state);
 })()`;
 }
+const NORMALIZED_PROMPT_MATCH_CHARS = 120;
+/**
+ * Does this transcript belong to the consult that is waiting on it?
+ *
+ * The browser is shared with the user and other agents. Reading "whatever
+ * conversation the tab shows" once cost a consult its answer - prodex saved a
+ * different conversation as the result. Identity is checked against the prompt
+ * that was actually sent, normalized because ChatGPT re-wraps whitespace, and
+ * as a containment test because the transcript wraps the prompt: a composer
+ * tool prefixes it ("@Deep research ...") and attachments append to it.
+ */
+export function transcriptMatchesSentPrompt(userText, sentPrompt) {
+    // The composer escapes markdown when it stores what was typed ("## File" is
+    // kept as "\\## File", fences as escaped backticks), so undo that before
+    // comparing - otherwise every prompt carrying markdown, which is every
+    // --file send, looks like a different conversation.
+    const normalize = (value) => value
+        .replace(/\\([\\`*_{}[\]()#+\-.!>~|])/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim();
+    const seen = normalize(userText);
+    const sent = normalize(sentPrompt);
+    if (seen.length === 0 || sent.length === 0)
+        return false;
+    const expected = sent.slice(0, NORMALIZED_PROMPT_MATCH_CHARS);
+    return seen.includes(expected);
+}
 // ChatGPT marks citations with private-use delimiters (U+E200 opens, U+E202
 // separates, U+E201 closes) and keeps the real sources in content_references.
 const CITATION_DELIMITER_PATTERN = /[\uE200-\uE206]/;
@@ -3122,7 +3213,7 @@ export function resolveTranscriptCitations(text, references = []) {
 }
 export function deepResearchReportExpression(conversationId) {
     return `(async () => {
-  const fail = (reason, status) => ({ ok: false, reason, status: status || "", report: "", chars: 0, references: [] });
+  const fail = (reason, status, userText) => ({ ok: false, reason, status: status || "", report: "", chars: 0, references: [], userText: userText || "" });
   let token = "";
   try {
     const session = await fetch("/api/auth/session", { credentials: "include" });
@@ -3143,7 +3234,8 @@ export function deepResearchReportExpression(conversationId) {
   } catch (error) {
     return fail("conversation_error");
   }
-  const nodes = Object.keys((conversation && conversation.mapping) || {}).map((key) => conversation.mapping[key]);
+  const mapping = (conversation && conversation.mapping) || {};
+  const nodes = Object.keys(mapping).map((key) => mapping[key]);
   const widgetNode = nodes.find(
     (node) => node && node.message && node.message.metadata && node.message.metadata.chatgpt_sdk && node.message.metadata.chatgpt_sdk.widget_state
   );
@@ -3155,12 +3247,22 @@ export function deepResearchReportExpression(conversationId) {
     return fail("widget_state_unparsable");
   }
   const status = (state && state.status) || "";
+  const chain = [];
+  let walkId = conversation && conversation.current_node;
+  let walkGuard = 0;
+  while (walkId && mapping[walkId] && walkGuard < 2000) {
+    walkGuard += 1;
+    if (mapping[walkId].message) chain.push(mapping[walkId].message);
+    walkId = mapping[walkId].parent;
+  }
+  const userNode = chain.find((entry) => entry && entry.author && entry.author.role === "user" && entry.content);
+  const userText = userNode ? (userNode.content.parts || []).filter((part) => typeof part === "string").join("") : "";
   const message = (state && state.report_message) || null;
   const parts = message && message.content && message.content.parts;
   const report = Array.isArray(parts) ? parts.filter((part) => typeof part === "string").join("") : "";
   const references = message && message.metadata && Array.isArray(message.metadata.content_references) ? message.metadata.content_references : [];
-  if (!report) return fail("report_not_ready", status);
-  return { ok: true, reason: "", status, report, chars: report.length, references };
+  if (!report) return fail("report_not_ready", status, userText);
+  return { ok: true, reason: "", status, report, chars: report.length, references, userText };
 })()`;
 }
 /**
@@ -3296,17 +3398,11 @@ export function answerExpression() {
     });
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     const userMessages = messages.filter((message) => message.role === "user");
-    // Deep research renders no assistant-role node at all: the thread is
-    // conversation-turn sections, the prompt in the first and the report in a
-    // later one (measured live - roles were ["user"] only while a research ran).
-    // Fall back to the last turn that is NOT the user's, so such an answer is
-    // readable instead of looking like "no answer" forever.
-    const turnAnswers = assistantMessages.length > 0 ? [] : [...document.querySelectorAll('[data-testid^="conversation-turn"]')]
-      .filter((turn) => !turn.querySelector('[data-message-author-role="user"]'))
-      .map((turn) => ({ role: "assistant", text: (turn.innerText || "").trim(), modelSlug: undefined }))
-      .filter((turn) => turn.text.length > 0);
-    const effectiveAssistants = assistantMessages.length > 0 ? assistantMessages : turnAnswers;
-    const assistant = effectiveAssistants.at(-1);
+    // 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
+    // "answer" that a consult returned as its result.
+    const assistant = assistantMessages.at(-1);
     const buttons = [...document.querySelectorAll('button,[role="button"]')]
       .filter((node) => !!(node.offsetWidth || node.offsetHeight || node.getClientRects().length))
       .filter((node) => !node.closest(excludedTextSelector))
@@ -3319,13 +3415,16 @@ export function answerExpression() {
     return {
       title: document.title,
       url: location.href,
-      answer: assistant ? answer : text.slice(-4000),
+      // No assistant message means no answer. This used to hand back the last
+      // 4000 characters of the page, which reads as sidebar and navigation text
+      // dressed up as a reply.
+      answer,
       textSample: text.slice(0, 12000),
       blockerTextSample: visibleTextOutsideMessages(excludedTextSelector).slice(0, 12000),
       blockerScanTextSample: visibleTextOutsideMessages(blockerScanExcludedSelector).slice(0, 12000),
       visibleButtonLabels: buttons,
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || buttons.some((label) => generatingControlPattern.test(label)),
-      assistantMessageCount: effectiveAssistants.length,
+      assistantMessageCount: assistantMessages.length,
       userMessageCount: userMessages.length,
       // ChatGPT tags each assistant message with the model that produced it -
       // the only ground truth for "did the Pro selection actually take".

package/dist/cli-pro.js

@@ -52,7 +52,7 @@ export async function runChatgptCommand(rest, io) {
             const task = await targetStore.createTask({
                 source: "codex",
                 title: "GPT Pro smoke",
-                prompt: bundle.text,
+                prompt: bundle.sendText,
                 repo_id: "default",
                 provenance: {
                     adapter: "chatgpt-control",
@@ -852,7 +852,8 @@ export async function runAskProCommand(rest, io) {
         const task = await targetStore.createTask({
             source: "codex",
             title: "GPT Pro consult",
-            prompt: bundle.text,
+            // Record what ChatGPT actually received, not the preview rendering.
+            prompt: bundle.sendText,
             repo_id: "default",
             files: files.map((file) => ({ path: file, role: "context" })),
             provenance: {
@@ -901,7 +902,7 @@ export async function runAskProCommand(rest, io) {
         // fast. A dead holder is still reaped immediately.
         const sendOnce = () => withBrowserSendLock(busyWaitMs ?? browserTimeoutMs ?? 0, (detail) => io.stderr(`progress: ${detail}`), () => sendChatGptPrompt({
             port: browserPort,
-            prompt: bundle.text,
+            prompt: bundle.sendText,
             targetUrl: normalizedTargetUrl,
             timeoutMs: browserTimeoutMs,
             ...(attachments.length > 0 ? { attachments } : {}),

package/package.json

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