@youdie006/prodex 0.40.0 → 0.40.2

package/dist/chatgpt-browser.js

@@ -1056,8 +1056,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 +1323,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 +1606,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,6 +1667,76 @@ 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);
+}
+/**
+ * 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.
+ *
+ * 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 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"]'))`;
 }
@@ -2465,13 +2600,52 @@ 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. */
+function composerProjectBindingExpression() {
+    return `(() => {${composerExpressionHelpers()}
+    const node = findChatGptComposerCandidate();
+    if (!node) return { found: false };
+    return { found: true, placeholder: node.getAttribute("data-placeholder") || node.getAttribute("placeholder") || "" };
+  })()`;
+}
+/**
+ * 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 (;;) {
+        const read = await cdp
+            .evaluate(composerProjectBindingExpression())
+            .catch(() => ({ 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
@@ -2481,7 +2655,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)
@@ -2490,9 +2664,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
@@ -2502,7 +2676,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
@@ -2513,28 +2687,98 @@ 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");
-        // 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.
-        const rebound = await reloadAndAwaitComposer(cdp, RELOAD_SETTLE_TIMEOUT_MS, `location.href === ${JSON.stringify(projectHome)}`);
-        if (!rebound) {
-            throw new Error(`ChatGPT composer did not rebind after entering project "${options.project}"`);
+}
+/**
+ * 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;
+    if (options.projectNew)
+        await createChatGptProject(cdp, options.projectNew);
+    else
+        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.
+        //
+        // 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}`);
+    }
     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}"`);
     }
 }
 // Read the finished answer from an existing ChatGPT thread WITHOUT sending a new
@@ -2794,6 +3038,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
@@ -2940,6 +3218,22 @@ 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 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.`);
+            }
+        }
         // 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) {

package/dist/cli-pro.js

@@ -1110,6 +1110,12 @@ export async function runAskProCommand(rest, io) {
     // Requiring --new-chat keeps that explicit rather than quietly turning a
     // continuation into a throwaway.
     const temporary = parsedAskPro.optionArgs.includes("--temporary");
+    const temporaryConflict = temporaryProjectConflict({
+        temporary,
+        ...(explicitProject !== undefined ? { explicitProject } : {})
+    });
+    if (temporaryConflict)
+        throw new Error(temporaryConflict);
     if (temporary && !newChat) {
         throw new Error("--temporary starts a throwaway chat, so it needs --new-chat. A temporary chat cannot be continued or recovered later.");
     }
@@ -1141,9 +1147,17 @@ export async function runAskProCommand(rest, io) {
     // fresh chat inside the project is exactly what "--new-chat + project"
     // produces, and the whole point of pinning a default project is that
     // consults stop landing in the general chat list. Only --target-url
-    // (pinned tab) and --project-new suppress it.
+    // (pinned tab), --project-new, and --temporary suppress it.
+    //
+    // --temporary suppresses rather than conflicts: a pinned project must not
+    // turn every throwaway send into an error, and attempting both is what
+    // produced "composer did not rebind after entering project" - a temporary
+    // chat is never saved, a project chat is, and entering a project leaves
+    // temporary mode.
     const selectionProject = explicitProject ??
-        (normalizedTargetUrl || selectionProjectNew !== undefined || suppressProject ? undefined : browserDefaults?.project);
+        (normalizedTargetUrl || selectionProjectNew !== undefined || suppressProject || temporary
+            ? undefined
+            : browserDefaults?.project);
     const reasoningAxisChosen = explicitProMode !== undefined || explicitEffort !== undefined;
     const selectionProMode = explicitProMode ?? (reasoningAxisChosen ? undefined : browserDefaults?.pro_mode);
     const selectionEffort = explicitEffort ?? (reasoningAxisChosen ? undefined : browserDefaults?.effort);
@@ -1796,6 +1810,19 @@ export function proSelectionVerified(selection) {
         return undefined;
     return /pro/i.test(selection.modelSlug);
 }
+/**
+ * A temporary chat is not saved; a project chat is. Entering a project leaves
+ * temporary mode, so asking for both is asking for two different things, and
+ * prodex used to attempt both and die inside the project step with "composer
+ * did not rebind". A pinned default project is suppressed instead of refused:
+ * the per-call flag is the more specific instruction.
+ */
+export function temporaryProjectConflict(input) {
+    if (!input.temporary || input.explicitProject === undefined)
+        return undefined;
+    return (`--temporary and --project cannot be combined: a temporary chat is never saved, and a chat inside a project is. ` +
+        `Drop --temporary to send into "${input.explicitProject}", or drop --project to send a throwaway chat.`);
+}
 export function browserSendBlockerFromError(error) {
     const blocker = typeof error === "object" && error !== null && "blocker" in error ? error.blocker : undefined;
     if (typeof blocker === "object" &&
@@ -1861,6 +1888,18 @@ export function browserSendBlockerFromError(error) {
             next_step: "Another prodex send holds the browser. Wait for it to finish and retry, or pass a longer --timeout-ms, which is also the queue budget."
         };
     }
+    // The composer would have posted somewhere other than the project that was
+    // asked for, so nothing was sent. A prompt that lands in another project is
+    // worse than a blocker: the receipt records the project the caller asked for,
+    // and the answer is somewhere nobody is looking.
+    if (/composer did not bind to project/.test(message)) {
+        return {
+            code: "project_not_bound",
+            message,
+            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 picker could not provide the step that was asked for. Retrying asks
     // the same picker the same question, so this is not retryable; the caller
     // either picks a step it offers or opts into whatever the slider is on.

package/package.json

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