@youdie006/prodex 0.40.1 → 0.40.3

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) {
@@ -842,9 +854,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);
@@ -1056,8 +1082,29 @@ decidedBusyBlocker, busyVerdictDecided = false) {
     const busyBlocker = busyVerdictDecided ? decidedBusyBlocker : chatGptBusyBlocker(status);
     if (busyBlocker)
         throw new ChatGptBrowserBlockerError(busyBlocker);
+    // ChatGPT's own error page carries no composer and none of the logged-in
+    // furniture the login check reads, so the assert below calls a perfectly
+    // good session logged out and sends the person looking for a login screen
+    // that is not there. Measured live: a project home that failed to load left
+    // the tab on that page, and the next send - the retry the project blocker
+    // asks for - reported "missing a clear logged-in ChatGPT session".
+    if (looksLikeChatGptErrorPage({ bodyText: status.textSample, hasComposer: status.hasComposer })) {
+        throw new ChatGptBrowserBlockerError(chatGptErrorPageBlocker());
+    }
     assertChatGptReadyForPrompt(inferChatGptPageLoggedInLikely(status), status.hasComposer, status.openDialogText);
 }
+/** The tab is on ChatGPT's error page: the page failed to load, and says nothing about the session. */
+export function chatGptErrorPageBlocker() {
+    return {
+        code: "chatgpt_error_page",
+        message: "ChatGPT browser is reachable, but the tab is on ChatGPT's own error page, which has no prompt composer.",
+        retryable: true,
+        // Not "the session is fine": this page carries none of the furniture that
+        // would show it either way. Not "reload it" either - measured, a project
+        // home reloads straight back into this page, while the site root loads.
+        next_step: "The page failed to load, which says nothing about the session. Open a normal chat in the visible browser, then retry."
+    };
+}
 /**
  * Whether a page with no composer is worth one reload before giving up.
  *
@@ -1302,6 +1349,36 @@ async function dispatchEscapeKey(cdp) {
     await cdp.send("Input.dispatchKeyEvent", { type: "keyDown", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 });
     await cdp.send("Input.dispatchKeyEvent", { type: "keyUp", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 });
 }
+/**
+ * Open a fresh ChatGPT root document, and prove that is where the tab landed.
+ *
+ * The recovery for a composer bound to the wrong project: only a new document
+ * sheds a stale binding, and the site root loads where a project home does
+ * not. Checked rather than best-effort, because the caller clicks a sidebar
+ * row on whatever page this leaves behind - and clicking it on the OLD
+ * document walks straight back into the binding it is trying to shed. The
+ * stamp is what proves the old document is gone; the URL alone can be read off
+ * the very page we are trying to leave.
+ */
+async function openFreshChatGptHome(cdp) {
+    await cdp.evaluate(markDocumentForReloadExpression());
+    await cdp.evaluate(`location.assign("https://chatgpt.com/")`);
+    const deadline = Date.now() + RELOAD_SETTLE_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await sleep(250);
+        try {
+            if (await cdp.evaluate(freshChatGptHomeReadyExpression()))
+                return;
+        }
+        catch (error) {
+            // The execution context is gone between documents; the next poll lands
+            // on the new one. A command timeout is different: it closed the socket.
+            if (cdpCommandTimedOut(error))
+                throw error;
+        }
+    }
+    throw new Error("ChatGPT did not open a fresh home page with a composer");
+}
 // Poll a boolean page expression instead of sleeping a fixed duration, so slow
 // renders wait longer and fast ones do not waste time.
 async function waitForExpressionTrue(cdp, expression, timeoutMs, intervalMs = 150) {
@@ -1555,6 +1632,20 @@ export function reloadedDocumentReadyExpression(extraCondition = "true") {
     return Boolean(${extraCondition});
   })()`;
 }
+/**
+ * True only on a NEWLY loaded chatgpt.com root that has rendered a composer.
+ *
+ * Every clause answers a way the old check could pass on the page we are
+ * trying to leave: the stamp proves the document is not the one that asked
+ * for the navigation, the route proves it is the root rather than the project
+ * home that fails to load, and the composer candidate is the real editor
+ * rather than the broad selector that also matches a hidden fallback.
+ */
+export function freshChatGptHomeReadyExpression() {
+    return reloadedDocumentReadyExpression(`/^https:\\/\\/chatgpt\\.com\\/?(?:[?#].*)?$/.test(location.href) && (() => {${composerExpressionHelpers()}
+    return Boolean(findChatGptComposerCandidate());
+  })()`);
+}
 /** Polled reloads return as soon as the new document has its composer; this only bounds a page that never gets there. */
 const RELOAD_SETTLE_TIMEOUT_MS = 12_000;
 /**
@@ -1602,17 +1693,75 @@ async function reloadPageAndAwaitComposer(page) {
         cdp.close();
     }
 }
+// Every alternative is wording measured on the error page itself, anchored so
+// the whole body has to be made of them and nothing else. It may repeat one:
+// the heading and the button carry the same words.
+const CHATGPT_ERROR_PAGE_BODY = /^(?:(?:something went wrong|please try again later|please try again|try again|다시\s*시도)[.!]?(?:\s+|$))+$/i;
+/**
+ * ChatGPT's error page: a document whose whole body is a retry affordance.
+ *
+ * Measured live - a direct load of a project home came back with a body of
+ * exactly "Try again", one button, and no composer, while the same route
+ * reached by clicking the sidebar worked and the rest of ChatGPT loaded fine.
+ * Reporting that as a missing composer describes a symptom and names nothing
+ * to do about it.
+ *
+ * The body has to BE the error, not merely contain a retry word somewhere: a
+ * positive now navigates the visible tab away, so "Retry settings" and a
+ * transient "Retrying..." must not qualify. Wording decides, not length - the
+ * old 40-character ceiling turned down "Something went wrong. Please try again
+ * later." for being one sentence too long. An error page prodex does not
+ * recognise stays a missing composer: a worse message, not a wrong action.
+ */
+export function looksLikeChatGptErrorPage(input) {
+    if (input.hasComposer)
+        return false;
+    // The DOM read leaves the heading and the button separated by whitespace.
+    const text = input.bodyText.replace(/\s+/g, " ").trim();
+    if (!text)
+        return false;
+    // A backstop for the alternation below rather than a classifier of its own:
+    // the longest body it can accept is well under this, so anything longer is a
+    // page with content and is not worth matching against.
+    if (text.length > 200)
+        return false;
+    return CHATGPT_ERROR_PAGE_BODY.test(text);
+}
 /**
- * The project a ChatGPT URL belongs to, as its `g-p-<id>` segment.
+ * Which project the composer will post into, read from its own placeholder.
+ *
+ * ChatGPT labels a project composer with the project it belongs to ("New chat
+ * in <name>"), and measured live that label follows a sidebar navigation from
+ * one project to another and back. That makes it the cheap answer to the
+ * question the old hard reload tried to force: is this composer the project's,
+ * or the one the tab arrived with.
  *
- * The rebind check used to compare whole URLs, which also carry mode in a
- * query string - and mode is exactly what differs across the reload this
- * failure showed up in. Identity is the thing the check actually cares about:
- * that the composer came back bound to THIS project rather than the one the
- * tab came from.
+ * Only a recognised phrasing decides anything. A placeholder that merely
+ * CONTAINS the name is not evidence - "New chat in Notes Archive" contains
+ * "Notes" - and neither is an unrecognised one, which is why a locale this
+ * cannot read comes back "unknown" rather than "bound". What "unknown" is
+ * worth is the caller's to decide, not this function's.
  */
-export function projectIdentity(url) {
-    return /\/g\/(g-p-[^/?#]+)/.exec(url)?.[1];
+export function composerProjectBinding(input) {
+    const placeholder = (input.placeholder ?? "").trim();
+    if (!placeholder)
+        return "unknown";
+    const wanted = input.projectName.trim().toLowerCase();
+    if (!wanted)
+        return "unknown";
+    // Equality where the phrasing is known, because sidebar rows are matched by
+    // exact name: "Notes" and "Notes Archive" are two projects, and a composer
+    // belonging to one must not pass for the other. The spacing of the template
+    // is loose because that is the page's to choose; the NAME is compared as it
+    // is, since two projects may differ by exactly the spacing in it.
+    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))
+        return "elsewhere";
+    return "unknown";
 }
 export function powerSliderPresentExpression() {
     return `Boolean(document.querySelector('[data-testid="composer-intelligence-picker-content"] [role="slider"]'))`;
@@ -1770,11 +1919,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)" };
@@ -1970,6 +2126,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.
  *
@@ -1977,7 +2148,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());
@@ -2035,8 +2206,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) {
@@ -2477,13 +2663,79 @@ async function createChatGptProject(cdp, name) {
         throw error;
     }
 }
-async function selectProject(cdp, options) {
-    if (options.projectNew) {
-        await createChatGptProject(cdp, options.projectNew);
-        return;
+/** The placeholder of the composer the send will actually type into. */
+/**
+ * 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 };
+    const label =
+      node.getAttribute("data-placeholder") ||
+      node.getAttribute("placeholder") ||
+      node.getAttribute("aria-label") ||
+      "";
+    return { found: true, placeholder: label };
+  })()`;
+}
+/**
+ * Wait for the composer to belong to the project we just entered.
+ *
+ * The binding arrives with the project page rather than with the URL, so this
+ * polls rather than reading once. A composer that never appears, or one whose
+ * placeholder cannot be read, comes back "unknown" - which the caller treats
+ * as a failure, so this must not report it lightly.
+ */
+async function waitForComposerProjectBinding(cdp, project, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let verdict = "unknown";
+    for (;;) {
+        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 } : {}),
+                projectName: project
+            });
+            if (sample === "bound")
+                return sample;
+            // Keep the worse reading. A composer seen belonging somewhere else stays
+            // evidence of that even if the next sample lands mid-render with no
+            // placeholder to read - overwriting it turned a known wrong destination
+            // into an unknown one, which reads like the softer failure it is not.
+            if (sample === "elsewhere" || verdict === "unknown")
+                verdict = sample;
+        }
+        if (Date.now() >= deadline)
+            return verdict;
+        await sleep(250);
     }
-    if (!options.project)
-        return;
+}
+// Enter an EXISTING project by clicking its sidebar row. Leaves the tab on
+// that project's page; whether the composer came with it is the caller's
+// question, not this one's.
+async function navigateToExistingProject(cdp, project) {
     const hrefBefore = await cdp.evaluate("location.href");
     // Poll for the project row instead of a single check: right after a
     // --new-chat navigation the sidebar's Projects section has not hydrated yet
@@ -2493,7 +2745,7 @@ async function selectProject(cdp, options) {
     let hit = { ok: false };
     const projectDeadline = Date.now() + 6_000;
     for (;;) {
-        hit = await cdp.evaluate(projectItemRectExpression(options.project));
+        hit = await cdp.evaluate(projectItemRectExpression(project));
         if (hit.ok && hit.x !== undefined && hit.y !== undefined)
             break;
         if (Date.now() >= projectDeadline)
@@ -2502,9 +2754,9 @@ async function selectProject(cdp, options) {
     }
     if (!hit.ok || hit.x === undefined || hit.y === undefined) {
         const detail = hit.reason && hit.reason !== "project not found in sidebar" ? ` (${hit.reason})` : "";
-        throw new Error(`ChatGPT project not found in sidebar: ${options.project}${detail} List the visible names with \`prodex pro browser projects\`.`);
+        throw new Error(`ChatGPT project not found in sidebar: ${project}${detail} List the visible names with \`prodex pro browser projects\`.`);
     }
-    await verifiedClickWithRetry(cdp, () => cdp.evaluate(projectItemRectExpression(options.project)), `project ${options.project}`);
+    await verifiedClickWithRetry(cdp, () => cdp.evaluate(projectItemRectExpression(project)), `project ${project}`);
     const navigated = await waitForExpressionTrue(cdp, `location.href !== ${JSON.stringify(hrefBefore)}`, PROJECT_NAVIGATION_TIMEOUT_MS);
     if (!navigated) {
         // The href staying put is fine ONLY when the tab was already on THIS
@@ -2514,7 +2766,7 @@ async function selectProject(cdp, options) {
         // project - which would silently send the prompt into the wrong project.
         const alreadyInRequestedProject = await cdp.evaluate(`(() => {
         if (!/^https:\\/\\/chatgpt\\.com\\/g\\/g-p-/.test(location.href)) return false;
-        const name = ${JSON.stringify(options.project)}.toLowerCase();
+        const name = ${JSON.stringify(project)}.toLowerCase();
         // Case-insensitive EQUALITY (not substring): matches the case-insensitive
         // sidebar-row lookup (so "codex" is accepted while sitting on "Codex"),
         // but a stalled cross-project navigation must NOT be accepted just because
@@ -2525,42 +2777,132 @@ async function selectProject(cdp, options) {
         return [...document.querySelectorAll('h1,[role="heading"]')].some((h) => (h.innerText || "").trim().toLowerCase() === name);
       })()`);
         if (!alreadyInRequestedProject) {
-            throw new Error(`Clicking project "${options.project}" did not navigate the visible tab. If the tab is already inside this project, omit --project and retry.`);
+            throw new Error(`Clicking project "${project}" did not navigate the visible tab. If the tab is already inside this project, omit --project and retry.`);
         }
     }
-    if (navigated) {
-        // 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
-        // via PRODEX_DEBUG_SEND: baseline URL on the requested project, yet the
-        // prompt posted into the project the tab came from). A hard reload of the
-        // project home rebinds the composer to THIS project before we send.
-        const projectHome = await cdp.evaluate("location.href");
-        const home = projectIdentity(projectHome);
-        // Polled with no delay, the first check could run before the reload had
-        // committed, on the old document, whose composer and URL both still
-        // matched. The stamp keeps that document from passing as the new one.
-        //
-        // Identity, not the whole URL: the href also carries mode in a query
-        // string, and comparing it byte-for-byte failed a reload that had landed
-        // exactly where it was asked to.
-        const rebound = await reloadAndAwaitComposer(cdp, RELOAD_SETTLE_TIMEOUT_MS, home ? `/\\/g\\/${home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![^/?#])/.test(location.href)` : "true");
-        if (!rebound) {
-            // Say what it saw. This failure is rare and was previously reported as
-            // four words, which named neither the cause nor anything to try.
-            const landed = await cdp.evaluate("location.href").catch(() => "unknown");
-            const hasComposer = await cdp
-                .evaluate(`Boolean(document.querySelector('#prompt-textarea,[contenteditable="true"],textarea'))`)
-                .catch(() => false);
-            throw new Error(`ChatGPT composer did not rebind after entering project "${options.project}": after reloading, the tab was on ` +
-                `${projectIdentity(landed) ?? "no project"} (expected ${home ?? "that project"}) and the composer was ` +
-                `${hasComposer ? "present but the page never settled" : "still missing"}.`);
+}
+/**
+ * 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.
+ *
+ * A project the send just created is exactly as able to post into the wrong
+ * place as one it navigated to - the create flow leaves the tab on a project
+ * home like any other - so both answer here, and the binding gate reads this
+ * rather than the pinned name alone.
+ */
+export function composerBindingTarget(options) {
+    return options.projectNew ?? options.project;
+}
+/**
+ * Put the tab in the project this send is for, and refuse unless the composer
+ * agrees that is where it posts.
+ *
+ * Both ways in share the gate. A project prodex just created is no safer than
+ * one it navigated to: the create flow waits for A composer, and the composer
+ * that answers can still be the one the tab arrived with - the same silent
+ * wrong-project send, with the new project's name in the receipt.
+ */
+async function selectProject(cdp, options) {
+    const wanted = composerBindingTarget(options);
+    if (!wanted)
+        return undefined;
+    if (options.projectNew)
+        await createChatGptProject(cdp, options.projectNew);
+    // 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
+    // via PRODEX_DEBUG_SEND: baseline URL on the requested project, yet the
+    // prompt posted into the project the tab came from).
+    //
+    // Hard-reloading the project home used to rebind it, and that stopped
+    // working: measured on two different projects, EVERY hard load of a project
+    // home - Page.reload and location.assign alike - comes back as ChatGPT's
+    // error page with no composer, while the sidebar navigation that got us
+    // here renders in under two seconds. So read the binding instead of forcing
+    // it - the composer says which project it posts into.
+    //
+    // Read on every path in. A URL that never moved is not proof about the
+    // composer either: the route and the title can already be this project's
+    // while the composer still belongs to the thread the tab was left on, and
+    // that path used to skip this check entirely - as did creating a project,
+    // which reached the send with nothing checked at all.
+    let binding = await waitForComposerProjectBinding(cdp, wanted, PROJECT_NAVIGATION_TIMEOUT_MS);
+    let recoveryNote = "";
+    if (binding !== "bound") {
+        // The one recovery that cannot inherit a stale binding, and the only one
+        // still available: a fresh document - the site root loads fine, unlike a
+        // project home - and then the same sidebar navigation over again.
+        try {
+            await openFreshChatGptHome(cdp);
+            await verifiedClickWithRetry(cdp, () => cdp.evaluate(projectItemRectExpression(wanted)), `project ${wanted}`);
+            // The click's navigation has to land before the placeholder means
+            // anything; read on the page we came from, it answers about the wrong
+            // document.
+            const entered = await waitForExpressionTrue(cdp, `/\\/g\\/g-p-/.test(location.href)`, PROJECT_NAVIGATION_TIMEOUT_MS);
+            if (!entered)
+                throw new Error("the sidebar click did not reach a project page");
+            binding = await waitForComposerProjectBinding(cdp, wanted, PROJECT_NAVIGATION_TIMEOUT_MS);
+        }
+        catch (recoveryError) {
+            // Dropping why the recovery failed would leave the refusal below saying
+            // only that the binding is still wrong, which is the less useful half.
+            recoveryNote = ` Recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`;
         }
     }
+    if (binding !== "bound") {
+        // Refuse on "unknown" as well as "elsewhere". A placeholder prodex cannot
+        // 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.
+        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 "${options.project}"`);
+        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
@@ -2819,6 +3161,40 @@ export async function sendChatGptPrompt(options) {
             busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
         }
     }
+    // ChatGPT's error page does not come back on a reload - measured: a project
+    // home that failed reloaded straight back into it - and the tab then stays
+    // there for every later send, including the retry its own blocker asks for.
+    // Going home is the recovery that works, and an unpinned send has nothing to
+    // lose by leaving an error page.
+    if (looksLikeChatGptErrorPage({ bodyText: status.textSample, hasComposer: status.hasComposer })) {
+        // A send pinned to a thread is not one of those. Navigating to the root
+        // would trade the page that explains the failure for a target mismatch
+        // that does not, and leave the pinned tab somewhere it was not asked to
+        // go, so report the error page and keep the tab where it is.
+        if (normalizedTargetUrl)
+            throw new ChatGptBrowserBlockerError(chatGptErrorPageBlocker());
+        emitProgress("waiting", "tab on ChatGPT's error page; opening a working page");
+        try {
+            await evaluateOnPage(page, `location.assign("https://chatgpt.com/")`);
+            await waitForFreshChatGptPage(page, RELOAD_SETTLE_TIMEOUT_MS);
+            let fresh = await readSettledChatGptPageStatus(page);
+            fresh = await ensureVisibleChatGptPage(port, page, fresh);
+            const blockerAfterHome = detectChatGptPageBlocker(fresh);
+            if (blockerAfterHome)
+                throw new ChatGptBrowserBlockerError(blockerAfterHome);
+            // The busy verdict above was decided about the page we just left, and it
+            // is handed to the readiness assert as already decided. Carrying it over
+            // would let a root page that is generating an answer be typed into.
+            busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(fresh), await readTranscriptCompletion(page, fresh.url));
+            status = fresh;
+        }
+        catch (error) {
+            // A blocker is the answer; anything else leaves the original status, and
+            // the readiness assert below reports the error page it still sees.
+            if (error instanceof ChatGptBrowserBlockerError || cdpCommandTimedOut(error))
+                throw error;
+        }
+    }
     // A thread can be left rendered with no composer at all - measured after a
     // send, zero contenteditables and zero textareas on the page - and every
     // retry then lands on the same dead page and reports the same "missing a
@@ -2894,6 +3270,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 = [];
@@ -2939,11 +3316,16 @@ export async function sendChatGptPrompt(options) {
         // 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 (!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);
         }
@@ -2965,6 +3347,21 @@ export async function sendChatGptPrompt(options) {
         // into; a --project/--project-new hop lands on a page with its own counts.
         beforeSubmit = await evaluateOnPage(page, answerExpression());
         dbgSend(`baseline url=${beforeSubmit.url} user=${beforeSubmit.userMessageCount} assistant=${beforeSubmit.assistantMessageCount}`);
+        // Read the binding once more, on the composer this send is about to type
+        // into. Everything between selectProject and here - the model picker, the
+        // power slider - opens and closes over the composer, and a re-render is
+        // exactly when it can come back bound to the project the tab arrived with.
+        // This is not atomic and does not pretend to be; it closes a window that
+        // measurably existed. It has to run BEFORE the attachments and the text,
+        // because a composer holding a prompt no longer shows a placeholder.
+        const boundProject = composerBindingTarget(options);
+        if (boundProject) {
+            const stillBound = await waitForComposerProjectBinding(cdp, boundProject, PROJECT_NAVIGATION_TIMEOUT_MS);
+            dbgSend(`project binding before typing=${stillBound}`);
+            if (stillBound !== "bound") {
+                throw new ChatGptBrowserBlockerError(projectNotBoundBlocker({ project: boundProject, reason: "drifted" }));
+            }
+        }
         // Attach BEFORE typing: the upload is the slow part, and a file that
         // arrives after the prompt is submitted is a file ChatGPT never saw.
         if (options.attachments && options.attachments.length > 0) {
@@ -3159,6 +3556,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))
         };
     };
@@ -3307,6 +3705,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))
         };
     }
@@ -3321,6 +3720,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 } : {}) })] : []),
@@ -5030,6 +5430,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;