@youdie006/prodex 0.40.3 → 0.40.4

package/dist/chatgpt-browser.js

@@ -503,6 +503,17 @@ export function isUsableChatGptAnswer(answer) {
         return false;
     return true;
 }
+/**
+ * What comes back when the turn finished and wrote no text.
+ *
+ * Measured with `--tool create-image`: the image was generated and rendered,
+ * the assistant message in the transcript came back finished with an empty
+ * part (the image lives in a separate tool message), and prodex waited out the
+ * whole budget before reporting a timeout for a result that was already there.
+ * The thread URL travels with every answer, so saying so and pointing at it
+ * beats six minutes of silence.
+ */
+export const CHATGPT_NON_TEXT_ANSWER_NOTE = "[no text answer] ChatGPT finished this turn without writing any text - an image or another non-text result. Open the thread to see it.";
 /**
  * Who decides the answer is finished: the transcript, when it can be read.
  *
@@ -520,9 +531,16 @@ export function classifyTranscriptRead(state, 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";
+    // A turn that FINISHED with no text is not a turn still being written. The
+    // transcript only reports answer_empty after checking the turn ended, and
+    // calling it "pending" is what made an image request wait out its whole
+    // budget: measured, `--tool create-image` produced the image, its assistant
+    // message came back finished with an empty part, and the send spent six and
+    // a half minutes "stabilizing" before reporting a timeout for an answer that
+    // was sitting in the thread.
+    if (state.reason === "answer_empty")
+        return "no_text";
+    return state.reason === "answer_not_finished" || state.reason === "no_assistant_message" ? "pending" : "unavailable";
 }
 /**
  * Should prodex drag the tab back to the thread it pinned?
@@ -540,8 +558,11 @@ export function shouldRecoverThreadNavigation(args) {
         return false;
     if (!conversationIdFromThreadUrl(pinnedThreadUrl))
         return false;
-    if (lastTranscriptClassification === "pending" || lastTranscriptClassification === "answer")
+    if (lastTranscriptClassification === "pending" ||
+        lastTranscriptClassification === "answer" ||
+        lastTranscriptClassification === "no_text") {
         return false;
+    }
     return !chatGptUrlsReferToSameTarget(currentUrl, pinnedThreadUrl);
 }
 export function hasFreshChatGptAnswer(previousAssistantMessageCount, state) {
@@ -1360,6 +1381,49 @@ async function dispatchEscapeKey(cdp) {
  * stamp is what proves the old document is gone; the URL alone can be read off
  * the very page we are trying to leave.
  */
+/**
+ * Put the tab on a specific conversation, for a thread prodex itself resolved.
+ */
+async function openChatGptThread(cdp, url) {
+    const conversationId = conversationIdFromThreadUrl(url);
+    if (!conversationId)
+        throw new Error(`Not a ChatGPT conversation URL: ${url}`);
+    await cdp.evaluate(`location.assign(${JSON.stringify(url)})`);
+    const deadline = Date.now() + RELOAD_SETTLE_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await sleep(250);
+        try {
+            if (await cdp.evaluate(chatGptThreadReadyExpression(conversationId)))
+                return;
+        }
+        catch (error) {
+            // Between documents the context is gone and the next poll lands on the
+            // new one; a command timeout means the tab stopped answering.
+            if (cdpCommandTimedOut(error))
+                throw error;
+        }
+    }
+    throw new ChatGptBrowserBlockerError(chatGptThreadUnavailableBlocker(url));
+}
+/**
+ * The conversation a follow-up names cannot be opened.
+ *
+ * Retrying cannot undelete a thread, and the generic "resolve the visible
+ * browser issue manually" this used to fall back to describes a browser that
+ * is working fine - measured on a thread whose project had been deleted: the
+ * cause was named in the message and then thrown away by the catch-all next
+ * step underneath it.
+ */
+export function chatGptThreadUnavailableBlocker(url) {
+    return {
+        code: "thread_unavailable",
+        message: `ChatGPT did not open the conversation to continue (${url}). It may have been deleted, or its project was.`,
+        retryable: false,
+        next_step: "That conversation cannot be reached, and retrying will not bring it back. Send without --continue to start a new one, " +
+            "or name a different consult with --continue-task <task_id> (`prodex pro list` shows them).",
+        thread: url
+    };
+}
 async function openFreshChatGptHome(cdp) {
     await cdp.evaluate(markDocumentForReloadExpression());
     await cdp.evaluate(`location.assign("https://chatgpt.com/")`);
@@ -1641,6 +1705,20 @@ export function reloadedDocumentReadyExpression(extraCondition = "true") {
  * home that fails to load, and the composer candidate is the real editor
  * rather than the broad selector that also matches a hidden fallback.
  */
+/**
+ * True once the tab is on this conversation and has rendered a real composer.
+ *
+ * The id is compared rather than the whole URL because ChatGPT rewrites the
+ * project part of it (measured: the same project appears with and without its
+ * name), and the composer has to be the real editor rather than the hidden 0x0
+ * fallback that the broad selector also matches.
+ */
+export function chatGptThreadReadyExpression(conversationId) {
+    return `(() => {${composerExpressionHelpers()}
+    if (!location.href.includes(${JSON.stringify(conversationId)})) return false;
+    return Boolean(findChatGptComposerCandidate());
+  })()`;
+}
 export function freshChatGptHomeReadyExpression() {
     return reloadedDocumentReadyExpression(`/^https:\\/\\/chatgpt\\.com\\/?(?:[?#].*)?$/.test(location.href) && (() => {${composerExpressionHelpers()}
     return Boolean(findChatGptComposerCandidate());
@@ -1757,9 +1835,13 @@ export function composerProjectBinding(input) {
     const named = /^new\s+chat\s+in\s+(.+)$/i.exec(placeholder)?.[1] ?? /^(.+?)\uc5d0\uc11c\s*\uc0c8\s*\ucc44\ud305$/.exec(placeholder)?.[1];
     if (named)
         return named.trim().toLowerCase() === wanted ? "bound" : "elsewhere";
-    // The placeholder a plain new chat carries: recognised, and it names no
-    // project, so the composer belongs to none.
-    if (/^ask\s+chatgpt$/i.test(placeholder))
+    // The label a plain new chat carries: recognised, and it names no project, so
+    // the composer belongs to none. Two wordings measured on the same live root -
+    // the hidden fallback textarea says "Ask ChatGPT" while the editor prodex
+    // actually reads says "Chat with ChatGPT" - and reading only the first left
+    // the clearest case of "this composer is not the project's" reported as a
+    // label that could not be read.
+    if (/^(?:ask|chat with)\s+chatgpt$/i.test(placeholder))
         return "elsewhere";
     return "unknown";
 }
@@ -3046,7 +3128,7 @@ async function readTranscriptAnswer(page, conversationId, sentPrompt) {
     const answer = resolveTranscriptCitations(transcript.text, transcript.references).trim();
     return answer.length > 0
         ? { classification: "answer", answer: { answer, modelSlug: transcript.modelSlug } }
-        : { classification: "pending" };
+        : { classification: "no_text" };
 }
 // 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.
@@ -3086,7 +3168,10 @@ export async function sendChatGptPrompt(options) {
     if (options.newChat && normalizedTargetUrl) {
         throw new Error("newChat cannot be combined with targetUrl: a fresh chat navigates away from the pinned tab.");
     }
-    const pageResult = await findChatGptPage(port, computePageDiscoveryTimeout(timeoutMs), normalizedTargetUrl);
+    // A resolved thread is reached by navigating, so page discovery must not
+    // demand a tab already sitting on it.
+    const requireTabAtTargetUrl = options.navigateToTargetUrl ? undefined : normalizedTargetUrl;
+    const pageResult = await findChatGptPage(port, computePageDiscoveryTimeout(timeoutMs), requireTabAtTargetUrl);
     if (!pageResult.ok) {
         throwBlockerOrError(pageResult.blocker, "ChatGPT browser page is not available");
     }
@@ -3094,8 +3179,8 @@ export async function sendChatGptPrompt(options) {
         if (pageResult.blocker) {
             throw new ChatGptBrowserBlockerError(pageResult.blocker);
         }
-        if (normalizedTargetUrl) {
-            assertChatGptTargetTabAvailable(normalizedTargetUrl);
+        if (requireTabAtTargetUrl) {
+            assertChatGptTargetTabAvailable(requireTabAtTargetUrl);
         }
         assertChatGptPageAvailable();
     }
@@ -3242,14 +3327,21 @@ export async function sendChatGptPrompt(options) {
         awaitingResponseChoice: status.awaitingResponseChoice === true,
         ...(options.newChat !== undefined ? { newChat: options.newChat } : {}),
         ...(options.project !== undefined ? { project: options.project } : {}),
-        ...(options.projectNew !== undefined ? { projectNew: options.projectNew } : {})
+        ...(options.projectNew !== undefined ? { projectNew: options.projectNew } : {}),
+        // Navigating to another conversation leaves the parked one alone, the
+        // same way a fresh chat or a project home does.
+        ...(options.navigateToTargetUrl ? { newChat: true } : {})
     })) {
         throw new ChatGptBrowserBlockerError(chatGptResponseChoiceBlocker(true));
     }
     assertChatGptIdleAndReadyForPrompt(status, busyBlocker, true);
-    if (normalizedTargetUrl)
-        assertChatGptTargetUrlMatches(status.url, normalizedTargetUrl);
-    assertVisibleChatGptTab(status.visibilityState, status.url, normalizedTargetUrl);
+    // Only a PINNED target has to be under the tab already; a resolved thread is
+    // navigated to below, and asserting the match here would refuse the send for
+    // the tab merely being somewhere else - which is the whole reason a
+    // continuation resolves from records rather than from the tab.
+    if (requireTabAtTargetUrl)
+        assertChatGptTargetUrlMatches(status.url, requireTabAtTargetUrl);
+    assertVisibleChatGptTab(status.visibilityState, status.url, requireTabAtTargetUrl);
     emitProgress("tab_ready");
     // Progress details deliberately avoid project names (receipts redact them too).
     const selectionSummary = [
@@ -3315,6 +3407,9 @@ export async function sendChatGptPrompt(options) {
         // keeps Work's composer, and switching afterwards does not move it.
         // Max and Ultra are rungs of Work's slider, so asking for one means staying
         // there; anything else belongs on Chat, whose top step is Pro.
+        if (normalizedTargetUrl && options.navigateToTargetUrl) {
+            await openChatGptThread(cdp, normalizedTargetUrl);
+        }
         if (!effortNeedsWorkSurface(options.effort)) {
             // Leaving the current page is safe only for a send that was going to
             // navigate anyway; a continuation or a pinned tab has to be reloaded
@@ -3635,6 +3730,13 @@ export async function sendChatGptPrompt(options) {
                 lastTranscriptClassification = transcript.classification;
                 if (transcript.answer)
                     return transcriptResult(transcript.answer);
+                // A finished turn with no text is an answer of a different shape - an
+                // image, measured - and waiting for words it will never write spends
+                // the whole budget and then calls the result a timeout. The page must
+                // agree it has stopped generating before this counts.
+                if (transcript.classification === "no_text") {
+                    return transcriptResult({ answer: CHATGPT_NON_TEXT_ANSWER_NOTE, modelSlug: "" });
+                }
             }
             if (shouldRecoverThreadNavigation({ pinnedThreadUrl, currentUrl: finalState?.url, lastTranscriptClassification })) {
                 if (recoveredNavigations >= 2) {
@@ -4924,8 +5026,13 @@ export function activeComposerToolsExpression(labels) {
     // selection did not take.
     const el = document.querySelector('#prompt-textarea,[contenteditable="true"]');
     const form = el ? (el.closest("form") || el.parentElement) : null;
-    const text = (el ? el.innerText || "" : "") + String.fromCharCode(10) + (form ? form.innerText || "" : "");
-    return { ok: true, active: ${labelsJson}.filter((label) => text.includes(label)) };
+    const text = ((el ? el.innerText || "" : "") + String.fromCharCode(10) + (form ? form.innerText || "" : "")).toLowerCase();
+    // Case-insensitively: prodex carries the label as the menu spells it
+    // ("Create image") while the page has been measured using "Create Image"
+    // for the same tool. This is hardening, not a fix for a failure anyone has
+    // seen - the create-image activation failure measured on this account
+    // survives it, and its cause is still open.
+    return { ok: true, active: ${labelsJson}.filter((label) => text.includes(String(label).toLowerCase())) };
   })()`;
 }
 export function composerTextStateExpression(expectedText, toolLabels = []) {

package/dist/cli-pro.js

@@ -1313,6 +1313,9 @@ export async function runAskProCommand(rest, io) {
             port: browserPort,
             prompt: bundle.sendText,
             targetUrl: normalizedTargetUrl,
+            // A thread prodex resolved from its own records is reached by
+            // navigating; a --target-url the person confirmed is not moved.
+            ...(continuedFromTaskId ? { navigateToTargetUrl: true } : {}),
             timeoutMs: browserTimeoutMs,
             ...(attachments.length > 0 ? { attachments } : {}),
             ...(tools.length > 0 ? { tools } : {}),
@@ -1432,6 +1435,13 @@ export async function runAskProCommand(rest, io) {
             io.stderr(warning);
         if (consult.modelSlug)
             io.stderr(`model_used: ${consult.modelSlug}`);
+        // Which conversation this followed, and where the answer actually landed.
+        // The progress line that says it is filtered out of MCP notes, so an
+        // agent asking for a follow-up had no way to know which thread it got -
+        // or whether the answer is in the project it asked for.
+        if (continuedFromTaskId)
+            io.stderr(`continued_from: ${continuedFromTaskId}`);
+        io.stderr(`destination: ${destination.destination}${destination.verified === undefined ? "" : ` verified=${destination.verified}`}`);
         // "Can I count this as a Pro review?" - answered here rather than left
         // for whoever reads the receipt to work out from two other fields.
         const proVerified = proSelectionVerified({
@@ -1525,6 +1535,11 @@ export async function runAskProCommand(rest, io) {
                 status: result.status,
                 thread: consult.url,
                 answer: result.summary,
+                ...(continuedFromTaskId ? { continued_from: continuedFromTaskId } : {}),
+                destination: {
+                    observed: destination.destination,
+                    ...(destination.verified !== undefined ? { verified: destination.verified } : {})
+                },
                 warnings: persistenceWarnings
             }, null, 2));
         }

package/dist/config.js

@@ -252,8 +252,13 @@ export async function loadBrowserDefaults(cwd) {
         // stop applying with nothing said, so a consult that should have landed in
         // a project lands in the general chat and looks like it worked.
         if (!isMissingFileError(error)) {
+            // Say only what is true. Passing the flags explicitly does NOT get past
+            // this - the config is read before any of them are looked at - and
+            // advice that does not work is worse than none. Moving the file aside
+            // does work: a repo with no config has no defaults and sends fine.
             throw new Error(`${error instanceof Error ? error.message : String(error)} Until then prodex will not apply the browser defaults ` +
-                `pinned there (project, model), so pass them explicitly if you need to send before fixing it.`, { cause: error });
+                `pinned there (project, model), and every send from this repo stops here. Move .bridge/config.local.json aside ` +
+                `if this repo does not need the HTTP MCP surface.`, { cause: error });
         }
         repo = undefined;
     }

package/dist/continue-thread.js

@@ -28,6 +28,41 @@ export function chatGptProjectSlug(name) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
+/**
+ * Whether a recorded URL is a conversation someone can go back to.
+ *
+ * Not everything prodex records as a "thread" is one. Measured across this
+ * machine's records: six of them are `https://chatgpt.com/?temporary-chat=true`
+ * - a temporary chat is never saved, so returning to that URL opens a fresh
+ * empty one. Continuing into it would look like a follow-up and be a new
+ * conversation with none of the context, which is the failure --continue
+ * exists to remove rather than reproduce.
+ */
+export function isChatGptConversationUrl(threadUrl) {
+    return /\/c\/[^/?#]+/.test(threadUrl);
+}
+/**
+ * The project ids these recorded threads have been seen using, by project name.
+ *
+ * Some thread URLs carry the project name after its id and some carry only the
+ * id (measured: three of this machine's hundred-odd records). The named ones
+ * teach the mapping, so the bare ones can still be recognised instead of being
+ * invisible to every follow-up - which would quietly continue an OLDER
+ * conversation while the newest one sat unmatched.
+ */
+export function projectIdsByName(threadUrls) {
+    const byName = new Map();
+    for (const url of threadUrls) {
+        const match = /\/g\/g-p-([0-9a-f]+)-([^/?#]+)/i.exec(url);
+        if (!match)
+            continue;
+        const name = match[2].toLowerCase();
+        const ids = byName.get(name) ?? new Set();
+        ids.add(match[1].toLowerCase());
+        byName.set(name, ids);
+    }
+    return byName;
+}
 /**
  * Whether a recorded thread belongs to the project this send is for.
  *
@@ -35,18 +70,22 @@ export function chatGptProjectSlug(name) {
  * so a follow-up meant for the general chat cannot walk into a project - and a
  * project's follow-up cannot land in another project's conversation.
  */
-export function threadMatchesProject(threadUrl, project) {
+export function threadMatchesProject(threadUrl, project, knownProjectIds) {
     const projectSegment = /\/g\/(g-p-[^/?#]+)/.exec(threadUrl)?.[1];
     if (!project)
         return projectSegment === undefined;
     if (!projectSegment)
         return false;
     const slug = chatGptProjectSlug(project);
-    if (!slug)
-        return false;
     // The id comes first and the name follows it, so an exact suffix match keeps
     // "notes" from answering for "notes-archive".
-    return projectSegment.toLowerCase().endsWith(`-${slug}`);
+    if (slug && projectSegment.toLowerCase().endsWith(`-${slug}`))
+        return true;
+    // No name in the URL: fall back to the id this project has been seen using.
+    // Nothing is guessed - the id came from another record of the same project -
+    // and it survives a rename, which the name comparison cannot.
+    const id = /^g-p-([0-9a-f]+)/i.exec(projectSegment)?.[1]?.toLowerCase();
+    return Boolean(id && knownProjectIds?.has(id));
 }
 /**
  * The thread a follow-up should continue, or why it cannot be resolved.
@@ -57,9 +96,16 @@ export function threadMatchesProject(threadUrl, project) {
  * the conversation is the failure this exists to prevent.
  */
 export function resolveContinuationThread(input) {
-    const withThread = input.consults.filter((consult) => Boolean(consult.thread));
+    const withThread = input.consults.filter((consult) => consult.thread && isChatGptConversationUrl(consult.thread));
     if (input.taskId) {
         const named = withThread.find((consult) => consult.taskId === input.taskId);
+        const recordedButUnusable = !named && input.consults.some((consult) => consult.taskId === input.taskId);
+        if (recordedButUnusable) {
+            return {
+                error: `Consult "${input.taskId}" has no conversation to continue - it was a temporary chat, or it never reached one. ` +
+                    `A temporary chat is never saved, so there is nothing to go back to.`
+            };
+        }
         if (!named) {
             return {
                 error: `No recorded consult thread for "${input.taskId}". List what is here with \`prodex pro list\`, ` +
@@ -68,9 +114,12 @@ export function resolveContinuationThread(input) {
         }
         return { target: { taskId: named.taskId, thread: named.thread } };
     }
+    const knownProjectIds = input.project
+        ? projectIdsByName(withThread.map((consult) => consult.thread)).get(chatGptProjectSlug(input.project))
+        : undefined;
     const candidates = withThread
         .filter((consult) => consult.status === "done")
-        .filter((consult) => threadMatchesProject(consult.thread, input.project))
+        .filter((consult) => threadMatchesProject(consult.thread, input.project, knownProjectIds))
         .sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
     const latest = candidates[0];
     if (!latest) {

package/package.json

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