@youdie006/prodex 0.40.5 → 0.40.6

package/dist/chatgpt-browser.js

@@ -5396,7 +5396,10 @@ export function recentConversationsExpression(limit = 4) {
       }
       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) });
+      // Long enough that two consults sharing an opening can still be told
+      // apart by the rest of the prompt; bounded so a huge --file send does
+      // not drag its whole payload back through the bridge.
+      out.push({ id: item.id, userText: text.slice(0, 4000) });
     } catch (error) {
       // A conversation we cannot read is simply not a match.
     }
@@ -5404,9 +5407,47 @@ export function recentConversationsExpression(limit = 4) {
   return out;
 })()`;
 }
-/** Which of those conversations is the one this send posted into, if any. */
+/**
+ * Which of those conversations is the one this send posted into, if any.
+ *
+ * Identity is a PREFIX test - the first 120 normalized characters - because a
+ * composer tool prefixes the prompt and attachments append to it, so neither
+ * end is reliable on its own. Two consults that open the same way therefore
+ * look identical to it, which is not hypothetical: an agent working from a
+ * template, or a debate loop, repeats its opening every round. Taking the
+ * first match then reads an OLDER conversation and returns its answer as this
+ * send's - measured on two prompts sharing a 125-character preamble and
+ * differing at character 142, where sending the newer one picked the older.
+ *
+ * So an ambiguous prefix is resolved by the whole prompt, and if that cannot
+ * single one out either, nothing is picked. The caller falls back to its other
+ * evidence, which costs a wait; picking wrong costs the wrong answer.
+ */
 export function pickLandedConversation(candidates, sentPrompt) {
-    return candidates.find((candidate) => transcriptMatchesSentPrompt(candidate.userText, sentPrompt))?.id;
+    const matches = candidates.filter((candidate) => transcriptMatchesSentPrompt(candidate.userText, sentPrompt));
+    if (matches.length <= 1)
+        return matches[0]?.id;
+    const whole = matches.filter((candidate) => transcriptContainsWholeSentPrompt(candidate.userText, sentPrompt));
+    return whole.length === 1 ? whole[0].id : undefined;
+}
+/**
+ * The stricter test, for telling apart conversations the prefix cannot.
+ *
+ * Still a containment test - the transcript wraps the prompt - but of the
+ * whole prompt rather than its opening. A prompt longer than the recorded
+ * sample cannot match, which leaves the caller with nothing to pick, and
+ * nothing is the safe answer here.
+ */
+export function transcriptContainsWholeSentPrompt(userText, sentPrompt) {
+    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;
+    return seen.includes(sent);
 }
 export function transcriptAnswerExpression(conversationId) {
     return `(async () => {

package/dist/cli-pro.js

@@ -1352,6 +1352,11 @@ export async function runAskProCommand(rest, io) {
         const autoLoginAllowed = !parsedAskPro.optionArgs.includes("--no-auto-login") &&
             (parsedAskPro.optionArgs.includes("--auto-login") || io.isInteractive === true);
         let consult;
+        // Declared out here so a retry that fails still reports what recovery
+        // did: the notes used to live inside the inner catch and were attached
+        // to the ANSWER, so a recovered browser whose retry then died recorded
+        // nothing about the recovery at all.
+        const recoveryNotes = [];
         try {
             try {
                 consult = await sendOnce();
@@ -1360,7 +1365,6 @@ export async function runAskProCommand(rest, io) {
                 const firstBlocker = browserSendBlockerFromError(error);
                 if (firstBlocker.code !== "browser_unreachable" || !autoLoginAllowed)
                     throw error;
-                const recoveryNotes = [];
                 const recovered = await attemptBrowserAutoRecovery(io.stderr, {
                     ...(browserPort !== undefined ? { port: browserPort } : {}),
                     notes: recoveryNotes
@@ -1387,7 +1391,7 @@ export async function runAskProCommand(rest, io) {
             // What the send had already noticed before it died. These used to go
             // out with the result, so a failure dropped them - including the note
             // that would explain it, like having just moved off the Work surface.
-            const blockedWarnings = sendWarningsFromError(error).map(redactProject);
+            const blockedWarnings = [...recoveryNotes, ...sendWarningsFromError(error)].map(redactProject);
             for (const warning of blockedWarnings)
                 io.stderr(warning);
             const persistedBlocker = {
@@ -1797,6 +1801,20 @@ function autoClearDisabledByEnv(env = process.env) {
     const raw = (env.PRODEX_NO_AUTO_CLEAR ?? "").trim().toLowerCase();
     return raw === "1" || raw === "true" || raw === "yes";
 }
+/**
+ * What recovery did to the browser, in the words the receipt keeps.
+ *
+ * Both halves are recorded because both change what the answer came from. The
+ * ending case takes someone's running browser with it; the launch case is the
+ * quieter one and used to record nothing at all - measured, killing the
+ * dedicated browser and sending with --auto-login recovered in three seconds
+ * and left warnings: [] on the receipt, the result and the task.
+ */
+export function browserRecoveredNote(ended) {
+    return ended.length > 0
+        ? `browser_recovered: the dedicated browser stopped answering its control port and prodex ended it (pid ${ended.join(", ")}) and started a fresh one before sending. Anything it was doing at the time is gone; the profile and login were kept.`
+        : "browser_recovered: the dedicated browser was not running, so prodex started it with the saved profile before sending. The login was kept; anything the old browser had open is gone.";
+}
 export async function attemptBrowserAutoRecovery(stderr, options) {
     // Launching is right when the browser is gone and wrong when it is only deaf:
     // a second Chrome on the same profile joins the wedged one rather than
@@ -1831,7 +1849,7 @@ export async function attemptBrowserAutoRecovery(stderr, options) {
         stderr(`recover: the browser stopped answering; ending it (pid ${wedged.join(", ")}) and starting a fresh one...`);
         // Ending someone's browser is not a progress line to scroll past: it goes on
         // the receipt, where an agent or a person reading `pro latest` will see it.
-        options.notes?.push(`browser_recovered: the dedicated browser stopped answering its control port and prodex ended it (pid ${wedged.join(", ")}) and started a fresh one before sending. Anything it was doing at the time is gone; the profile and login were kept.`);
+        options.notes?.push(browserRecoveredNote(wedged));
         await endWedgedBrowser(wedged);
         // Wait for the profile lock to actually clear rather than guessing at a
         // delay: the replacement launch fails outright if the old process still
@@ -1874,6 +1892,10 @@ export async function attemptBrowserAutoRecovery(stderr, options) {
                 stderr("recover: window minimized again");
         }
         stderr("recover: browser READY - retrying the send...");
+        // The wedged branch above records what it ended; this branch records that
+        // the browser was gone and this answer came from one prodex started.
+        if (wedged.length === 0)
+            options.notes?.push(browserRecoveredNote([]));
         return true;
     }
     catch (error) {

package/package.json

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