@youdie006/prodex 0.27.3 → 0.28.1

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/cli-help.js

@@ -27,9 +27,9 @@ Ask / consult commands:
   prodex pro browser projects [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of sidebar project names (for --project)
   prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # recover a finished answer from a thread whose send timed out
   prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"] "prompt"  # explicit visible-browser send
-  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
-  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
 
 Bridge ledger (durable tasks/results/receipts/sessions under .bridge/):
   prodex init [--cwd /absolute/path/to/repo]
@@ -168,9 +168,9 @@ Commands:
   prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js]
   prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--target-url url --confirm-target] [--new-chat] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"] "prompt"
-  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
-  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
 
 Use \`prodex pro ask\` for dry-run/manual previews.
 Use \`prodex pro browser ask\` only when you want an explicit visible-browser send.

package/dist/cli-pro.js

@@ -575,7 +575,7 @@ export async function runProCommand(rest, io, runCliFn) {
     if (subcommand === "latest") {
         if (printHelpIfRequested(proArgs, "pro latest", io.stdout, printProHelp, { valueFlags: ["--cwd", "--source-cli"] }))
             return 0;
-        assertOnlyOptions(proArgs, "pro latest", ["--cwd", "--source-cli"]);
+        assertOnlyOptions(proArgs, "pro latest", ["--cwd", "--source-cli"], ["--json"]);
         const targetCwd = resolveCwdFlag(io.cwd, proArgs);
         const targetStore = new BridgeStore(targetCwd);
         const sourceCli = resolveOptionalFileFlag(io.cwd, proArgs, "--source-cli");
@@ -589,13 +589,19 @@ export async function runProCommand(rest, io, runCliFn) {
         }
         if (!consult)
             throw new Error("No GPT Pro answers found");
-        io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+        if (proArgs.includes("--json")) {
+            const modelUsed = await recordedModelUsed(targetStore, consult.task.id);
+            io.stdout(formatProAnswerJson(consult, sourceCli, answerOptions, modelUsed ? { modelUsed } : {}));
+        }
+        else {
+            io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+        }
         return 0;
     }
     if (subcommand === "show") {
         if (printHelpIfRequested(proArgs, "pro show", io.stdout, printProHelp, { valueFlags: ["--cwd", "--source-cli"], maxPositionals: 1 }))
             return 0;
-        const [taskId] = readPositionalsWithOptions(proArgs, "pro show", 1, ["--cwd", "--source-cli"]);
+        const [taskId] = readPositionalsWithOptions(proArgs, "pro show", 1, ["--cwd", "--source-cli"], ["--json"]);
         if (!taskId)
             throw new Error("pro show requires <task-id|latest>");
         const targetCwd = resolveCwdFlag(io.cwd, proArgs);
@@ -611,7 +617,13 @@ export async function runProCommand(rest, io, runCliFn) {
         }
         if (!consult)
             throw new Error(taskId === "latest" ? "No GPT Pro answers found" : `GPT Pro answer not found: ${taskId}`);
-        io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+        if (proArgs.includes("--json")) {
+            const modelUsed = await recordedModelUsed(targetStore, consult.task.id);
+            io.stdout(formatProAnswerJson(consult, sourceCli, answerOptions, modelUsed ? { modelUsed } : {}));
+        }
+        else {
+            io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+        }
         return 0;
     }
     if (subcommand === "debate-prompt") {
@@ -1432,6 +1444,42 @@ export function browserSendBlockerFromError(error) {
         next_step: "Resolve the visible browser issue manually, then rerun the consult if needed."
     };
 }
+/**
+ * The same answer as `formatProAnswer`, shaped for a program.
+ *
+ * Every other read path is JSON; these two printed only the human rendering,
+ * so an agent after the thread or the model that produced an answer had to
+ * scrape prose.
+ */
+export function formatProAnswerJson(consult, sourceCli, options = {}, extras = {}) {
+    const blocker = sourceAwareProAnswerBlocker(consult, sourceCli, options);
+    return JSON.stringify({
+        task_id: consult.task.id,
+        status: consult.result.status,
+        thread: consult.task.provenance.thread ?? null,
+        created_at: consult.result.created_at,
+        answer: consult.result.summary,
+        ...(extras.modelUsed ? { model_used: extras.modelUsed } : {}),
+        warnings: consult.result.warnings ?? [],
+        ...(blocker ? { blocker } : {})
+    }, null, 2);
+}
+/**
+ * Which model actually answered, from the receipt that recorded the answer.
+ * It lives there rather than on the task because it is what ChatGPT tagged the
+ * message with, not what prodex asked for.
+ */
+async function recordedModelUsed(store, taskId) {
+    try {
+        const receipts = await store.listReceiptsReadOnly({ kind: "consult_answer_saved", task_id: taskId });
+        const value = receipts[0]?.metadata?.model_used;
+        return typeof value === "string" ? value : undefined;
+    }
+    catch {
+        // A missing or unreadable receipt just means the field is unknown.
+        return undefined;
+    }
+}
 export function formatProAnswer(consult, sourceCli, options = {}) {
     const blocker = sourceAwareProAnswerBlocker(consult, sourceCli, options);
     const summary = sourceAwareProAnswerSummary(consult.result.summary, consult.result.blocker, blocker);

package/package.json

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