@youdie006/prodex 0.40.2 → 0.40.4

package/dist/chatgpt-browser.js

@@ -437,17 +437,29 @@ export function resolveHeadlessPreference(explicit, env = process.env) {
     const raw = (env.PRODEX_HEADLESS ?? "").trim().toLowerCase();
     return raw === "1" || raw === "true" || raw === "yes";
 }
-export function inferLoggedInLikely(text, visibleButtonLabels = []) {
+/**
+ * The two verdicts read different text on purpose.
+ *
+ * `text` answers "is this a login screen": it has to be the sample with chat
+ * MESSAGES excluded, or an old conversation quoting a signup page reports the
+ * session as logged out.
+ *
+ * `loggedInSignalText` answers "is the app here": the sidebar furniture, which
+ * survives in whichever sample happened to keep it. Measured live, that is not
+ * always the filtered one - on a project home the filter left 111 characters
+ * of a banner while document.body.innerText held the whole sidebar.
+ */
+export function inferLoggedInLikely(text, visibleButtonLabels = [], loggedInSignalText = text) {
     // Only sign-up prompts and explicit login/sign-up buttons count as logged-out signals. Bare
     // "Log in"/"로그인" substrings appear in the menus and footers of a logged-in page, so matching
     // them against the full page text falsely reported logged-in Pro users as logged out.
     const hasLoginPrompt = text.includes("Sign up for free") ||
         text.includes("무료로 가입") ||
         visibleButtonLabels.some((label) => /^(log in|sign up|로그인|회원가입)$/i.test(label.trim()));
-    const hasNewChat = text.includes("New chat") || text.includes("새 채팅");
-    const hasProjectNav = text.includes("Projects") || text.includes("프로젝트");
+    const hasNewChat = loggedInSignalText.includes("New chat") || loggedInSignalText.includes("새 채팅");
+    const hasProjectNav = loggedInSignalText.includes("Projects") || loggedInSignalText.includes("프로젝트");
     const hasProfileButton = visibleButtonLabels.some((label) => /profile|account|프로필|계정/i.test(label));
-    const hasPlanHint = /\bPro\b|Plus|Team|Enterprise|매우 높음|Extra High/i.test(text);
+    const hasPlanHint = /\bPro\b|Plus|Team|Enterprise|매우 높음|Extra High/i.test(loggedInSignalText);
     return !hasLoginPrompt && hasNewChat && (hasProfileButton || hasProjectNav || hasPlanHint);
 }
 export function isUsableChatGptAnswer(answer) {
@@ -491,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.
  *
@@ -508,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?
@@ -528,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) {
@@ -842,9 +875,23 @@ export function detectChatGptPageBlocker(state) {
     return detectChatGptBlocker(state.blockerScanTextSample ?? state.blockerTextSample ?? state.textSample, state.visibleButtonLabels);
 }
 export function inferChatGptPageLoggedInLikely(state) {
-    // Login detection uses the nav-INCLUDED sample: "New chat"/"Projects"/plan
-    // hints live in the sidebar and are the primary logged-in signal.
-    return inferLoggedInLikely(state.blockerTextSample ?? state.textSample, state.visibleButtonLabels);
+    // The logged-in signals live in the sidebar - "New chat", "Projects", the
+    // plan hint - so this needs the sample that HAS the sidebar in it. That was
+    // meant to be blockerTextSample, and measured live on a project home it is
+    // not: its text walk keeps only nodes whose own parent has a box, and what
+    // survived there was 111 characters of a promotional banner while
+    // document.body.innerText carried the whole sidebar. So a logged-in Pro
+    // account on a working page was told to go and log in.
+    //
+    // The logged-OUT question keeps the message-excluded sample, so a chat
+    // quoting a signup page cannot report the session as dead. The logged-IN
+    // question reads both, because the sidebar turns up in whichever one kept
+    // it - and being wrong in that direction is caught at once by the composer
+    // check beside it, while being wrong the other way tells someone with a
+    // working browser to go and log in.
+    const messageExcluded = state.blockerTextSample ?? state.textSample;
+    const anySample = [state.textSample, state.blockerTextSample].filter(Boolean).join(String.fromCharCode(10));
+    return inferLoggedInLikely(messageExcluded, state.visibleButtonLabels, anySample);
 }
 function hasLikelyChatGptLoginPrompt(haystack) {
     const hasSpecificSignup = /sign up for free|무료로 가입/i.test(haystack);
@@ -1334,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/")`);
@@ -1615,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());
@@ -1731,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";
 }
@@ -1893,11 +2001,18 @@ export function projectItemRectExpression(name) {
     }
     let target = opt ? (opt.closest('a,[role="link"],li') || opt.parentElement) : null;
     if (!target) {
+      // The fallback for a sidebar whose option buttons this cannot read. It
+      // used to take the first row CONTAINING the name, which is the substring
+      // match the exact comparison above exists to prevent: asking for "Codex"
+      // took "Codex Review" and sent the prompt into a project nobody named.
+      // A row's first line is its name; anything else here is a guess, and a
+      // guess about which project to post into is the failure being fixed.
       const icons = [...document.querySelectorAll('[data-testid="project-folder-icon"]')];
-      for (const ic of icons) {
-        const row = ic.closest('a,li,[role="link"]') || ic.parentElement?.parentElement;
-        if (row && (row.textContent || "").includes(wanted)) { target = row; break; }
-      }
+      const rowName = (row) => ((row.innerText || row.textContent || "").split("\\n").map((line) => line.trim()).find((line) => line.length > 0) || "");
+      const rows = icons.map((ic) => ic.closest('a,li,[role="link"]') || ic.parentElement?.parentElement).filter(Boolean);
+      const named = rows.filter((row) => rowName(row).toLowerCase() === wanted.toLowerCase());
+      if (named.length > 1) return { ok: false, reason: "project name matches multiple sidebar projects; rename one to disambiguate" };
+      if (named.length === 1) target = named[0];
     }
     if (!target) {
       return { ok: false, reason: "project not found in sidebar (" + optionButtons.length + " projects visible; names are matched exactly first, then case-insensitively - check the exact sidebar spelling)" };
@@ -2093,6 +2208,21 @@ async function selectPickerModel(cdp, requested, warnings = []) {
  * without this the step that follows reported "the picker did not expose its
  * power slider" on a picker that was simply shut.
  */
+/**
+ * How to apply the stored Chat-surface preference on a page that renders no
+ * surface toggle at all.
+ *
+ * Reloading in place is the only option for a send that has to stay where it
+ * is - a pinned thread, a continuation. On a project home it is the wrong one:
+ * a hard load of one comes back as ChatGPT's error page (measured on two
+ * projects), which leaves the send on a document with no sidebar, and the
+ * project step then reports the project missing from a sidebar that was never
+ * drawn. A send that is going to navigate anyway takes the root, which loads.
+ */
+export function chatSurfaceRecoveryPlan(input) {
+    const onProjectPage = /^https:\/\/chatgpt\.com\/g\/g-p-/.test(input.href);
+    return input.mayLeaveCurrentPage && onProjectPage ? "fresh-root" : "reload";
+}
 /**
  * Put the browser back on ChatGPT's Chat surface when it has drifted onto Work.
  *
@@ -2100,7 +2230,7 @@ async function selectPickerModel(cdp, requested, warnings = []) {
  * the page announces which one is live, so a drifted browser silently drives
  * the wrong picker. Returns a warning to carry to the caller when it moved.
  */
-async function ensureChatSurface(cdp) {
+async function ensureChatSurface(cdp, options) {
     const read = async () => {
         try {
             return await cdp.evaluate(chatSurfaceProbeExpression());
@@ -2158,8 +2288,23 @@ async function ensureChatSurface(cdp) {
     try {
         await cdp.evaluate(selectChatSurfaceExpression());
         // Reading the persisted value back right after writing it proves nothing;
-        // the reloaded document rendering its composer is what proves the switch.
-        if ((await reloadAndAwaitComposer(cdp, RELOAD_SETTLE_TIMEOUT_MS)) && (await confirm()))
+        // the new document rendering its composer is what proves the switch.
+        const plan = chatSurfaceRecoveryPlan({
+            href: await cdp.evaluate("location.href"),
+            mayLeaveCurrentPage: options.mayLeaveCurrentPage
+        });
+        let applied;
+        if (plan === "fresh-root") {
+            // Throws when the root never rendered a composer, which the catch below
+            // turns into the same "could not be switched back" warning as a reload
+            // that never settled.
+            await openFreshChatGptHome(cdp);
+            applied = true;
+        }
+        else {
+            applied = await reloadAndAwaitComposer(cdp, RELOAD_SETTLE_TIMEOUT_MS);
+        }
+        if (applied && (await confirm()))
             return note;
     }
     catch (error) {
@@ -2601,11 +2746,27 @@ async function createChatGptProject(cdp, name) {
     }
 }
 /** The placeholder of the composer the send will actually type into. */
-function composerProjectBindingExpression() {
+/**
+ * Read the label the composer carries, wherever it keeps it.
+ *
+ * Measured live on a project home: the editor prodex types into is the
+ * contenteditable div, and it carries the label ONLY as `aria-label` -
+ * `data-placeholder` is null on it. The 0x0 textarea beside it does carry
+ * `placeholder`, but the composer finder rejects that one on size, exactly as
+ * it should. Reading a single attribute meant the label was there and prodex
+ * could not see it, so every project send refused with "the placeholder could
+ * not be read" - the fail-closed branch doing its job on a page that was fine.
+ */
+export function composerProjectBindingExpression() {
     return `(() => {${composerExpressionHelpers()}
     const node = findChatGptComposerCandidate();
     if (!node) return { found: false };
-    return { found: true, placeholder: node.getAttribute("data-placeholder") || node.getAttribute("placeholder") || "" };
+    const label =
+      node.getAttribute("data-placeholder") ||
+      node.getAttribute("placeholder") ||
+      node.getAttribute("aria-label") ||
+      "";
+    return { found: true, placeholder: label };
   })()`;
 }
 /**
@@ -2620,9 +2781,20 @@ async function waitForComposerProjectBinding(cdp, project, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     let verdict = "unknown";
     for (;;) {
-        const read = await cdp
-            .evaluate(composerProjectBindingExpression())
-            .catch(() => ({ found: false }));
+        let read;
+        try {
+            read = await cdp.evaluate(composerProjectBindingExpression());
+        }
+        catch (error) {
+            // A read that lands between documents answers about neither, and the next
+            // poll lands on the new one. A command timeout is a different thing: the
+            // tab stopped answering, and swallowing it spent this whole budget and
+            // the recovery's before refusing with "the placeholder could not be
+            // read" - a binding failure reported for a browser that was gone.
+            if (cdpCommandTimedOut(error))
+                throw error;
+            read = { found: false };
+        }
         if (read.found) {
             const sample = composerProjectBinding({
                 ...(read.placeholder !== undefined ? { placeholder: read.placeholder } : {}),
@@ -2691,6 +2863,35 @@ async function navigateToExistingProject(cdp, project) {
         }
     }
 }
+/**
+ * The refusal to post into a project prodex cannot confirm, as a blocker.
+ *
+ * It used to be a plain Error whose English prose a regex in the CLI matched to
+ * recover the code - so the difference between "the composer belongs elsewhere"
+ * and "the browser stopped answering" survived only as a sentence, and a
+ * reworded message would have quietly become an unclassified send failure. The
+ * wording still carries the phrase the classifier keys on, because older
+ * senders and other paths still reach it as text.
+ *
+ * The project it OFFERED instead is deliberately absent: naming it would put
+ * another project's name in a persisted record, which redaction covers only for
+ * the ones this send asked for.
+ */
+export function projectNotBoundBlocker(input) {
+    const detail = input.reason === "elsewhere"
+        ? "after entering it, the composer still offers a chat that belongs somewhere else"
+        : input.reason === "unknown"
+            ? "after entering it, the composer's placeholder could not be read, so where the prompt would land is unknown"
+            : "it read as this project's after entering it and no longer does";
+    return {
+        code: "project_not_bound",
+        message: `ChatGPT composer did not bind to project "${input.project}": ${detail}, so nothing was sent.` +
+            (input.recoveryNote ?? ""),
+        retryable: true,
+        next_step: "Nothing was sent, so nothing landed in the wrong project. Retry - the composer normally binds on the next navigation - " +
+            "or open the project once in the visible browser and send again."
+    };
+}
 /**
  * The project name the composer has to agree with before anything is typed,
  * or undefined for a send that pins no project.
@@ -2715,11 +2916,18 @@ export function composerBindingTarget(options) {
 async function selectProject(cdp, options) {
     const wanted = composerBindingTarget(options);
     if (!wanted)
-        return;
+        return undefined;
     if (options.projectNew)
         await createChatGptProject(cdp, options.projectNew);
-    else
+    // Clicking the sidebar row when the composer already belongs to this project
+    // is work that can only fail. Measured: a send into the project the tab was
+    // already sitting in refused with "another element covers its click point" -
+    // a promotional banner over the sidebar - on a page that was ready to accept
+    // the prompt. The read below is the same evidence the gate accepts, so a
+    // composer that already answers with this project needs no navigation.
+    else if ((await waitForComposerProjectBinding(cdp, options.project, 0)) !== "bound") {
         await navigateToExistingProject(cdp, options.project);
+    }
     // A sidebar SPA navigation moves the URL to the target project while the
     // composer can stay bound to the PREVIOUS project's conversation target, so
     // the send silently creates the thread in the OLD project (reproduced live
@@ -2766,20 +2974,17 @@ async function selectProject(cdp, options) {
         // read is not evidence that the composer is this project's, and what it
         // guards against - a prompt posted into another project, recorded under
         // the requested one - costs far more than a send the caller can retry.
-        //
-        // Naming the project it offered instead would put ANOTHER project's name
-        // in a persisted receipt, which redaction only covers for the requested
-        // one, so say what happened and leave that name out.
-        const detail = binding === "elsewhere"
-            ? "the composer still offers a chat that belongs somewhere else"
-            : "the composer's placeholder could not be read, so where the prompt would land is unknown";
-        throw new Error(`ChatGPT composer did not bind to project "${wanted}": after entering it, ${detail}, ` +
-            `so nothing was sent.${recoveryNote}`);
+        throw new ChatGptBrowserBlockerError(projectNotBoundBlocker({
+            project: wanted,
+            reason: binding,
+            ...(recoveryNote ? { recoveryNote } : {})
+        }));
     }
     const composerReady = await waitForExpressionTrue(cdp, `Boolean(document.querySelector('#prompt-textarea,[contenteditable="true"],textarea'))`, PROJECT_NAVIGATION_TIMEOUT_MS);
     if (!composerReady) {
         throw new Error(`ChatGPT composer did not appear after entering project "${wanted}"`);
     }
+    return chatGptProjectIdFromUrl(await cdp.evaluate("location.href"));
 }
 // Read the finished answer from an existing ChatGPT thread WITHOUT sending a new
 // prompt. Recovers a consult whose send timed out but whose answer ChatGPT
@@ -2923,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.
@@ -2963,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");
     }
@@ -2971,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();
     }
@@ -3119,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 = [
@@ -3147,6 +3362,7 @@ export async function sendChatGptPrompt(options) {
             process.stderr.write(`DBG-SEND +${Date.now() - sendStartedAt}ms ${msg}\n`);
     };
     let beforeSubmit;
+    let boundProjectId;
     let submitButtonFound = false;
     let wantsDeepResearch = false;
     const sendWarnings = [];
@@ -3191,12 +3407,20 @@ 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)) {
-            const surfaceWarning = await ensureChatSurface(cdp);
+            // 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
+            // where it stands, because that page IS the destination.
+            const surfaceWarning = await ensureChatSurface(cdp, {
+                mayLeaveCurrentPage: Boolean(options.newChat || options.project || options.projectNew)
+            });
             if (surfaceWarning)
                 sendWarnings.push(surfaceWarning);
         }
-        await selectProject(cdp, options);
+        boundProjectId = await selectProject(cdp, options);
         try {
             await selectModelReasoning(cdp, options, sendWarnings);
         }
@@ -3230,8 +3454,7 @@ export async function sendChatGptPrompt(options) {
             const stillBound = await waitForComposerProjectBinding(cdp, boundProject, PROJECT_NAVIGATION_TIMEOUT_MS);
             dbgSend(`project binding before typing=${stillBound}`);
             if (stillBound !== "bound") {
-                throw new Error(`ChatGPT composer did not bind to project "${boundProject}": it read as this project's after entering it and ` +
-                    `no longer does, so nothing was sent.`);
+                throw new ChatGptBrowserBlockerError(projectNotBoundBlocker({ project: boundProject, reason: "drifted" }));
             }
         }
         // Attach BEFORE typing: the upload is the slow part, and a file that
@@ -3428,6 +3651,7 @@ export async function sendChatGptPrompt(options) {
             answer: transcript.answer,
             modelHints: finalState?.modelHints ?? [],
             ...(transcript.modelSlug ? { modelSlug: transcript.modelSlug } : finalState?.modelSlug ? { modelSlug: finalState.modelSlug } : {}),
+            ...(boundProjectId ? { boundProjectId } : {}),
             warnings: withDialogNote([...sendWarnings, selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...((transcript.modelSlug || finalState?.modelSlug) ? { modelSlug: (transcript.modelSlug || finalState?.modelSlug) } : {}) })]).filter((warning) => Boolean(warning))
         };
     };
@@ -3506,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) {
@@ -3576,6 +3807,7 @@ export async function sendChatGptPrompt(options) {
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
             ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
+            ...(boundProjectId ? { boundProjectId } : {}),
             warnings: withDialogNote([...sendWarnings, selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...(completed.modelSlug !== undefined ? { modelSlug: completed.modelSlug } : {}) })]).filter((warning) => Boolean(warning))
         };
     }
@@ -3590,6 +3822,7 @@ export async function sendChatGptPrompt(options) {
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
             ...(completed.modelSlug ? { modelSlug: completed.modelSlug } : {}),
+            ...(boundProjectId ? { boundProjectId } : {}),
             warnings: withDialogNote([
                 ...sendWarnings,
                 ...(selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...(completed.modelSlug !== undefined ? { modelSlug: completed.modelSlug } : {}) }) ? [selectionMismatchWarning({ ...(options.model !== undefined ? { model: options.model } : {}), ...(options.effort !== undefined ? { effort: options.effort } : {}), ...(completed.modelSlug !== undefined ? { modelSlug: completed.modelSlug } : {}) })] : []),
@@ -4793,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 = []) {
@@ -5299,6 +5537,68 @@ export function deepResearchReportExpression(conversationId) {
  * Thread urls come in a plain (`/c/<id>`) and a project (`/g/g-p-.../c/<id>`)
  * shape; both end in the conversation id the backend API is keyed by.
  */
+/**
+ * The project a ChatGPT URL belongs to, as its stable id.
+ *
+ * Measured live within one send: the SAME project renders as
+ * `/g/g-p-<hash>/project` on its home and `/g/g-p-<hash>-<name>/c/<id>` on the
+ * thread that came out of it. Comparing the slugs whole would call those two
+ * different projects, so only the hash - the part that does not depend on how
+ * the page felt like writing the name - identifies it.
+ */
+export function chatGptProjectIdFromUrl(url) {
+    if (!url)
+        return undefined;
+    const match = /\/g\/g-p-([0-9a-f]+)(?:[-/?#]|$)/i.exec(url);
+    return match ? match[1].toLowerCase() : undefined;
+}
+/**
+ * Where the prompt actually landed, against where it was aimed.
+ *
+ * The receipt recorded the project the caller ASKED for, which is intent, not
+ * evidence: a send that ended up somewhere else was recorded under the name of
+ * the place it never reached. The answered thread's URL carries the project it
+ * really belongs to, and the project step knows the id it bound to, so the two
+ * can be compared instead of assumed. "unverified" is its own answer - better
+ * than a receipt that certifies what nobody checked.
+ */
+export function destinationVerification(input) {
+    const answeredProjectId = chatGptProjectIdFromUrl(input.answeredUrl);
+    const destination = !input.answeredUrl ? "unknown" : answeredProjectId ? "project" : "root";
+    if (!input.requestedProject)
+        return { destination };
+    if (destination === "unknown")
+        return { destination, verified: false };
+    // Landing outside every project is wrong on its own evidence: it needs no id
+    // to compare against, and requiring one would have retired a warning that
+    // caught this in the field.
+    if (destination === "root") {
+        return {
+            destination,
+            verified: false,
+            warning: "project_landing_warning: a project was requested but the answered thread is a root chat, so it landed OUTSIDE the project. " +
+                "Move it via the thread menu (Move to project) or re-run; list projects with `prodex pro browser projects`."
+        };
+    }
+    // In a project, with nothing to check it against: not a warning, but not a
+    // verified landing either.
+    if (!input.boundProjectId)
+        return { destination, verified: false };
+    const verified = answeredProjectId === input.boundProjectId;
+    return {
+        destination,
+        verified,
+        ...(verified
+            ? {}
+            : {
+                // Naming the project it landed in would put another project's name in
+                // a persisted record; the thread URL is already there for anyone who
+                // needs to go look.
+                warning: "project_landing_warning: the answered thread belongs to a different project than the one this send entered. " +
+                    "Open the thread URL in the receipt to see where it went."
+            })
+    };
+}
 export function conversationIdFromThreadUrl(url) {
     const match = /\/c\/([0-9a-fA-F-]{16,})/.exec(url);
     return match ? match[1] : undefined;

package/dist/cli-args.js

@@ -260,6 +260,9 @@ export const ASK_PRO_BOOLEAN_FLAGS = new Set([
     "--no-auto-login",
     // Send outside any project for once, overriding a pinned default.
     "--no-project",
+    // Continue the conversation a previous consult left off in, resolved from
+    // this repo's own records rather than from whatever the shared tab shows.
+    "--continue",
     // Send even when the requested model/effort could not be applied, rather
     // than stopping. Off by default: an answer from a step nobody asked for is
     // usually thrown away.
@@ -268,6 +271,8 @@ export const ASK_PRO_BOOLEAN_FLAGS = new Set([
 export const ASK_PRO_SELECTION_VALUE_FLAGS = ["--project", "--project-new", "--model", "--pro-mode", "--effort"];
 export const ASK_PRO_VALUE_FLAGS = new Set([
     "--cwd",
+    // Continue one NAMED past consult, when "the last one" is not the one meant.
+    "--continue-task",
     "--file",
     // Upload the file itself (pdf/pptx/image) instead of inlining its text.
     "--attach",