@youdie006/prodex 0.35.1 → 0.36.1

package/README.md

@@ -440,6 +440,8 @@ npm run dev -- tasks list
 
 **Sends started failing after many consults in one chat.** Long accumulated threads eventually confuse prompt-acceptance detection (measured live around ten-plus messages). Send repeated consults into fresh chats with `--new-chat` (`new_chat: true` on the MCP tool) — the answer still lands in your account and in `.bridge/` receipts either way.
 
+**Every send says "still generating" but nothing is being written.** ChatGPT sometimes parks a thread on "You're giving feedback on a new version of ChatGPT - which response do you prefer?", and while it waits the composer keeps its stop control. prodex reports that as a `response_choice_pending` blocker naming the two "I prefer this response" buttons, because waiting will never clear it. Sends that navigate away (`--new-chat`, or any send into a project) are unaffected. A stop control can also linger for a few seconds after an ordinary answer finishes; prodex checks the conversation transcript before believing it, so a finished thread is not mistaken for a busy one.
+
 **"menu item not found" on `--effort`/`--pro-mode`/`--project`.** Selection matches the visible menu labels, verified in the Korean and English (US) ChatGPT UI. On another display language, run `prodex pro browser models` to see your labels and pass `--model "<exact label>"`, which clicks any picker radio by exact text.
 
 **Does this risk my ChatGPT account?** `prodex` is deliberately not a stealth bot: it uses a real visible browser, you log in manually, and it stops on captcha/verification instead of solving it. It does drive chatgpt.com, though, so keep usage at the human, occasional-consult volume the auto-pacing enforces — do not build tight recurring loops on top of it. Automating a paid account is your responsibility under OpenAI's terms.

package/dist/chatgpt-browser.js

@@ -596,8 +596,46 @@ export function modelSelectionWarning(requestedModel, modelSlug) {
         return undefined;
     return `model_mismatch: you asked for ${requestedModel}, but the answer came from "${modelSlug}". Check the model picker in the browser; the selection did not take.`;
 }
-export function chatGptBusyBlocker(generating) {
-    if (!generating)
+/**
+ * The panel ChatGPT raises to ask which of two answers you prefer.
+ *
+ * Recognized by its testids rather than its wording, so a UI in any language
+ * still matches. Read off the live page: the title is `paragen-feedback-title`
+ * and both choices are `paragen-prefer-response-button`.
+ */
+export const CHATGPT_RESPONSE_CHOICE_SELECTOR = '[data-testid="paragen-feedback-title"],[data-testid="paragen-prefer-response-button"]';
+/**
+ * A thread parked on that question, which no amount of waiting will clear.
+ *
+ * Measured live: both candidate answers had finished, the page had not changed
+ * in twenty seconds, and the composer's submit control was still
+ * `data-testid="stop-button"` - which prodex read as "generating". Every send
+ * afterwards waited out its whole budget and then advised waiting some more.
+ */
+export function chatGptResponseChoiceBlocker(awaitingResponseChoice) {
+    if (!awaitingResponseChoice)
+        return undefined;
+    return {
+        code: "response_choice_pending",
+        message: "ChatGPT is asking which of two answers you prefer, and this thread stays locked until one is picked.",
+        retryable: true,
+        next_step: "Pick one in the browser (the two \"I prefer this response\" buttons), " +
+            "or leave the thread alone and send into a new chat (`--new-chat`)."
+    };
+}
+/**
+ * Whether that question stands in the way of THIS send. A send that navigates
+ * away - a fresh chat, or a project home - never touches the parked thread.
+ */
+export function responseChoiceBlocksThisSend(input) {
+    if (!input.awaitingResponseChoice)
+        return false;
+    return !input.newChat && input.project === undefined && input.projectNew === undefined;
+}
+export function chatGptBusyBlocker(state) {
+    // Waiting for a choice is not generating. Conflating them turned a click
+    // away from ready into a full send budget spent on "still generating".
+    if (!state.generating || state.awaitingResponseChoice === true)
         return undefined;
     return {
         code: "response_in_progress",
@@ -608,6 +646,39 @@ export function chatGptBusyBlocker(generating) {
             "A new topic can go to a new chat instead."
     };
 }
+/**
+ * The busy verdict, re-decided against the transcript.
+ *
+ * Measured on the real page: an ordinary conversation whose answer was complete
+ * kept `data-testid="stop-button"` (aria-label "Stop answering") unchanged over
+ * thirty seconds, while the transcript for that same conversation reported
+ * finished_successfully with end_turn set. The page control is decoration once
+ * the turn is over; the transcript is the record. Only a transcript that can be
+ * read AND says the turn finished clears the blocker - an unreadable one is no
+ * evidence of anything, and typing into a live generation corrupts the thread.
+ */
+export function busyBlockerAfterTranscriptCheck(busyBlocker, transcript) {
+    if (!busyBlocker)
+        return undefined;
+    return transcript?.ok === true && transcript.isComplete === true ? undefined : busyBlocker;
+}
+/**
+ * Ask the transcript whether the conversation the tab is showing has finished.
+ * Undefined when there is nothing to ask about (a fresh chat or project home
+ * carries no conversation id) or the read fails.
+ */
+async function readTranscriptCompletion(page, url) {
+    const conversationId = conversationIdFromThreadUrl(url);
+    if (!conversationId)
+        return undefined;
+    try {
+        const state = await evaluateOnPage(page, transcriptAnswerExpression(conversationId));
+        return { ok: state.ok === true, ...(state.isComplete !== undefined ? { isComplete: state.isComplete } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
 export function isLikelyChatGptSubmitButton(label, dataTestId) {
     const normalized = label.trim().toLowerCase();
     return dataTestId === "send-button" || /\b(send|submit)\b|보내기|전송/.test(normalized);
@@ -878,8 +949,12 @@ function chatGptPageMissingBlocker() {
 // readiness assert - otherwise it is misreported as "missing a visible prompt
 // composer" (measured live: continue-by-default consults landing on a thread
 // still generating the previous prodex answer).
-export function assertChatGptIdleAndReadyForPrompt(status) {
-    const busyBlocker = chatGptBusyBlocker(status.generating);
+export function assertChatGptIdleAndReadyForPrompt(status, 
+// The caller may have already weighed the page against the transcript and
+// found the stop control stale. Re-deriving the verdict from the DOM here
+// threw away that answer and failed the send the queue had just cleared.
+decidedBusyBlocker, busyVerdictDecided = false) {
+    const busyBlocker = busyVerdictDecided ? decidedBusyBlocker : chatGptBusyBlocker(status);
     if (busyBlocker)
         throw new ChatGptBrowserBlockerError(busyBlocker);
     assertChatGptReadyForPrompt(inferChatGptPageLoggedInLikely(status), status.hasComposer, status.openDialogText);
@@ -1054,7 +1129,13 @@ export async function getChatGptBrowserStatus(options = {}) {
         ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {})
     });
     const loggedInLikely = inferChatGptPageLoggedInLikely(state);
-    const blocker = chatGptVisibilityBlocker(state.visibilityState, state.url) ?? detectChatGptPageBlocker(state) ?? chatGptBusyBlocker(state.generating);
+    // The busy verdict is checked against the transcript here too, so `check`
+    // does not report a finished conversation as one still being written.
+    const busyBlocker = chatGptBusyBlocker(state);
+    const blocker = chatGptVisibilityBlocker(state.visibilityState, state.url) ??
+        detectChatGptPageBlocker(state) ??
+        chatGptResponseChoiceBlocker(state.awaitingResponseChoice === true) ??
+        (busyBlocker ? busyBlockerAfterTranscriptCheck(busyBlocker, await readTranscriptCompletion(page.page, state.url)) : undefined);
     return {
         reachable: true,
         loggedInLikely,
@@ -2009,7 +2090,7 @@ export async function sendChatGptPrompt(options) {
     // timeout: consults continue threads by default, so landing on a thread
     // whose previous (often timed-out Pro) answer is still streaming is a when,
     // not an if - queueing behind it beats failing.
-    let busyBlocker = chatGptBusyBlocker(status.generating);
+    let busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
     const busyWaitBudgetMs = options.busyWaitMs ?? timeoutMs;
     if (busyBlocker && busyWaitBudgetMs > 0) {
         // Queue behind the in-flight response instead of failing: shared-tab
@@ -2023,17 +2104,32 @@ export async function sendChatGptPrompt(options) {
             const midBlocker = detectChatGptPageBlocker(status);
             if (midBlocker)
                 throw new ChatGptBrowserBlockerError(midBlocker);
-            busyBlocker = chatGptBusyBlocker(status.generating);
+            busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
             if (busyBlocker)
                 emitProgress("waiting", "tab busy with another response; waiting");
         }
         if (!busyBlocker) {
             // The composer takes a moment to unlock after generation ends; settle
-            // again so the readiness assert below sees the reopened composer.
+            // again so the readiness assert below sees the reopened composer, and
+            // weigh that fresh reading the same way - a generation that started in
+            // the meantime must still hold the send back.
             status = await readSettledChatGptPageStatus(page);
+            busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
         }
     }
-    assertChatGptIdleAndReadyForPrompt(status);
+    // A thread ChatGPT has parked on "which response do you prefer?" will not
+    // unpark on its own. Sends that navigate away - a fresh chat, a project home
+    // - never touch it; a send that means to continue THAT thread has to say so
+    // now, rather than type into a composer that will not post.
+    if (responseChoiceBlocksThisSend({
+        awaitingResponseChoice: status.awaitingResponseChoice === true,
+        ...(options.newChat !== undefined ? { newChat: options.newChat } : {}),
+        ...(options.project !== undefined ? { project: options.project } : {}),
+        ...(options.projectNew !== undefined ? { projectNew: options.projectNew } : {})
+    })) {
+        throw new ChatGptBrowserBlockerError(chatGptResponseChoiceBlocker(true));
+    }
+    assertChatGptIdleAndReadyForPrompt(status, busyBlocker, true);
     if (normalizedTargetUrl)
         assertChatGptTargetUrlMatches(status.url, normalizedTargetUrl);
     assertVisibleChatGptTab(status.visibilityState, status.url, normalizedTargetUrl);
@@ -2447,16 +2543,40 @@ export async function sendChatGptPrompt(options) {
     throw Object.assign(new Error(`Timed out after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms) waiting for ChatGPT to respond. ` +
         "Pro reasoning can run many minutes. Raise --timeout-ms and retry."), completed?.url ? { thread: completed.url } : {});
 }
+/**
+ * One line of `pro browser models`.
+ *
+ * The listing used to append "not selectable via --model yet" to every submenu
+ * row, which is now every row that matters - and it is not true: measured
+ * against this same picker, --model Pro, --effort 즉시 and --pro-mode 확장 all
+ * selected, because selection walks into the submenu. Saying what the row is
+ * set to is the useful half; the false warning was the harmful half.
+ */
+export function formatModelMenuOption(option) {
+    const marker = option.checked ? "*" : " ";
+    const value = option.kind === "submenu" && option.value ? `  ->  ${option.value}` : "";
+    return `${marker} ${option.label}${value}`;
+}
 export function modelMenuOptionsExpression() {
     return `(() => {
     const m = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
     if (!m) return [];
     return [...m.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')]
-      .map((it) => ({
-        label: (((it.innerText || it.textContent || "").trim().split(String.fromCharCode(10))[0]) || "").trim(),
-        kind: it.getAttribute("aria-haspopup") === "menu" ? "submenu" : "radio",
-        checked: it.getAttribute("aria-checked") === "true"
-      }))
+      .map((it) => {
+        // A submenu row renders as label over value ("Model" / "GPT-5.6 Sol"),
+        // and the value is the part a person actually wants to read.
+        const lines = (it.innerText || it.textContent || "")
+          .split(String.fromCharCode(10))
+          .map((line) => line.trim())
+          .filter((line) => line.length > 0);
+        const value = lines[1] || "";
+        return {
+          label: lines[0] || "",
+          kind: it.getAttribute("aria-haspopup") === "menu" ? "submenu" : "radio",
+          checked: it.getAttribute("aria-checked") === "true",
+          ...(value ? { value } : {})
+        };
+      })
       .filter((o) => o.label.length > 0);
   })()`;
 }
@@ -2580,7 +2700,15 @@ export function findLaunchedBrowserProcesses(psOutput, input) {
     // made a check against an unused port report a healthy Chrome as wedged.
     if (mains.length === 0)
         return [];
-    const helpers = input.profileDir.length > 0 ? lines.filter((line) => line.includes(input.profileDir) && !mains.includes(line)) : [];
+    // Which profile the helpers belong to is the browser's answer, not the
+    // caller's: `check` has only a port, and matching against the profile it
+    // assumed both missed this browser's renderers and collected a stranger's.
+    // Read it off the process that answered to the port; fall back to what the
+    // caller passed only when the command line does not say.
+    // Stop at the next flag, so a profile path containing spaces survives.
+    const profileOf = (line) => /--user-data-dir=(.*?)(?=\s+-{1,2}\w|\s*$)/.exec(line)?.[1];
+    const profileDir = profileOf(mains[0]) ?? input.profileDir;
+    const helpers = profileDir.length > 0 ? lines.filter((line) => profileOf(line) === profileDir && !mains.includes(line)) : [];
     return [...mains, ...helpers].map(pidOf).filter((pid) => pid !== undefined);
 }
 /**
@@ -3074,6 +3202,7 @@ export function statusExpression() {
     const excludedTextSelector = JSON.stringify(CHATGPT_RUNTIME_BLOCKER_TEXT_EXCLUDED_ANCESTORS);
     const blockerScanExcludedSelector = JSON.stringify(CHATGPT_BLOCKER_SCAN_EXCLUDED_ANCESTORS);
     const streamingSelector = JSON.stringify(CHATGPT_STREAMING_SELECTOR);
+    const responseChoiceSelector = JSON.stringify(CHATGPT_RESPONSE_CHOICE_SELECTOR);
     const generatingControlPattern = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.source);
     const generatingControlFlags = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.flags);
     return `(() => {
@@ -3127,6 +3256,7 @@ export function statusExpression() {
       visibleButtonLabels,
       hasComposer,
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || visibleButtonLabels.some((label) => generatingControlPattern.test(label)),
+      awaitingResponseChoice: Boolean(document.querySelector(${responseChoiceSelector})),
       modelHints: lines.filter((line) => /GPT|Pro|Thinking|ChatGPT|Extra High|Auto/i.test(line)).slice(0, 30),
       openDialogText: (([...document.querySelectorAll('[role="dialog"]')].find((d) => d.offsetWidth || d.offsetHeight || d.getClientRects().length)?.innerText) || "").trim().slice(0, 200)
     };
@@ -3961,6 +4091,7 @@ export function answerExpression() {
     const excludedTextSelector = JSON.stringify(CHATGPT_RUNTIME_BLOCKER_TEXT_EXCLUDED_ANCESTORS);
     const blockerScanExcludedSelector = JSON.stringify(CHATGPT_BLOCKER_SCAN_EXCLUDED_ANCESTORS);
     const streamingSelector = JSON.stringify(CHATGPT_STREAMING_SELECTOR);
+    const responseChoiceSelector = JSON.stringify(CHATGPT_RESPONSE_CHOICE_SELECTOR);
     const generatingControlPattern = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.source);
     const generatingControlFlags = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.flags);
     return `(() => {
@@ -4025,6 +4156,7 @@ export function answerExpression() {
       blockerScanTextSample: visibleTextOutsideMessages(blockerScanExcludedSelector).slice(0, 12000),
       visibleButtonLabels: buttons,
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || buttons.some((label) => generatingControlPattern.test(label)),
+      awaitingResponseChoice: Boolean(document.querySelector(${responseChoiceSelector})),
       assistantMessageCount: assistantMessages.length,
       userMessageCount: userMessages.length,
       // ChatGPT tags each assistant message with the model that produced it -

package/dist/cli-help.js

@@ -295,7 +295,7 @@ Commands:
   ${askUsage}
   ${recoverUsage}
 
-Visible-browser sends require a manual browser session and stop on login, captcha, Cloudflare, permission, rate-limit, or usage-limit blockers.
+Visible-browser sends require a manual browser session and stop on login, captcha, Cloudflare, permission, rate-limit, or usage-limit blockers, plus response_choice_pending when ChatGPT is waiting for you to pick which of two answers you prefer.
 Model/project selection (ask):
   --model      Composer model to pick by its exact menu label (verified: Pro). Models whose menu entry opens a submenu of variants are rejected with a clear error for now.
   --pro-mode   Pro sub-mode: 기본 (standard) or 확장 (extended), used when the model is Pro. A Pro selection raises the default --timeout-ms to 1200000.

package/dist/cli-pro.js

@@ -2,7 +2,7 @@ import { existsSync, statSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { buildDryRunBundle } from "./bundle.js";
-import { DEFAULT_CDP_PORT, resolveCdpPort, resolveConversationToDelete, resolveProjectToDelete, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, listChatGptModelOptions, deleteChatGptConversation, endWedgedBrowser, browserRecoveryPlan, findWedgedBrowser, wedgedBrowserBlocker, deleteChatGptProject, listChatGptProjectsWithIds, listRecentChatGptConversations, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, openChatGptTab, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveVirtualDisplayPreference, resolveBrowserWindowMode, resolveHeadlessPreference, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt } from "./chatgpt-browser.js";
+import { DEFAULT_CDP_PORT, resolveCdpPort, resolveConversationToDelete, resolveProjectToDelete, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, formatModelMenuOption, listChatGptModelOptions, deleteChatGptConversation, endWedgedBrowser, browserRecoveryPlan, findWedgedBrowser, wedgedBrowserBlocker, deleteChatGptProject, listChatGptProjectsWithIds, listRecentChatGptConversations, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, openChatGptTab, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveVirtualDisplayPreference, resolveBrowserWindowMode, resolveHeadlessPreference, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt } from "./chatgpt-browser.js";
 import { ASK_PRO_BOOLEAN_FLAGS, ASK_PRO_PREVIEW_VALUE_FLAGS, ASK_PRO_VALUE_FLAGS, assertHelpRequestArgs, assertNoExtraArgs, assertOnlyOptions, findHelpFlagIndexBeforePromptDelimiter, formatCliCommand, hasAskProDryRunMode, hasAskProMode, hasAskProSendMode, isHelpSubcommand, parseAskProArgs, printHelpIfRequested, readFlag, readPortFlag, readPositionalsWithOptions, readNonNegativeIntegerFlag, readPositiveIntegerFlag, readRepeatedFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError } from "./cli-args.js";
 import { printProBrowserHelp, printProHelp } from "./cli-help.js";
 import { listRawResultsForInspection, listTasksForInspection } from "./cli-ledger.js";
@@ -442,11 +442,9 @@ export async function runProCommand(rest, io, runCliFn) {
             }
             io.stdout("Model menu options in the visible ChatGPT tab (read-only; nothing was selected):");
             for (const option of listed.options) {
-                const marker = option.checked ? "*" : " ";
-                const suffix = option.kind === "submenu" ? "  (has sub-variants; not selectable via --model yet)" : "";
-                io.stdout(`${marker} ${option.label}${suffix}`);
+                io.stdout(formatModelMenuOption(option));
             }
-            io.stdout("Use radio entries with `pro browser ask --model/--effort` (e.g. --model Pro).");
+            io.stdout("An arrow shows what that row is set to now; --model / --effort reach into those submenus (e.g. --model Pro).");
             return 0;
         }
         if (browserSubcommand === "projects") {
@@ -1473,7 +1471,16 @@ export async function attemptBrowserAutoRecovery(stderr, options) {
     // a second Chrome on the same profile joins the wedged one rather than
     // replacing it, and the wedged one keeps burning CPU while nobody looks. This
     // runs unattended for agents, so it is the path that let four days pass.
-    const wedged = findWedgedBrowser({ ...(options.port !== undefined ? { port: options.port } : {}) });
+    // The same record the relaunch below reads, read once and used for both: the
+    // scan matches the main process by port but its helpers by profile, so
+    // scanning the DEFAULT profile for a custom-profile user put a second,
+    // healthy browser's renderers on the list this function kills.
+    const lastLogin = await readLastBrowserLoginLaunch().catch(() => undefined);
+    const scanFor = {
+        ...(options.port !== undefined ? { port: options.port } : {}),
+        ...(lastLogin?.profile_dir ? { profileDir: lastLogin.profile_dir } : {})
+    };
+    const wedged = findWedgedBrowser(scanFor);
     if (wedged.length > 0) {
         // Confirm the silence before ending anything: one missed poll is a busy
         // browser, several in a row is a dead one.
@@ -1496,7 +1503,7 @@ export async function attemptBrowserAutoRecovery(stderr, options) {
         // delay: the replacement launch fails outright if the old process still
         // holds it, which is how the first self-heal attempt ended.
         for (let attempt = 0; attempt < 10; attempt += 1) {
-            if (findWedgedBrowser({ ...(options.port !== undefined ? { port: options.port } : {}) }).length === 0)
+            if (findWedgedBrowser(scanFor).length === 0)
                 break;
             await sleep(1_000);
         }
@@ -1506,7 +1513,6 @@ export async function attemptBrowserAutoRecovery(stderr, options) {
         // Reuse the profile the user last logged in with; launching the default
         // profile for a custom-profile user would wait on the wrong (logged-out)
         // profile or, worse, silently send to a different account.
-        const lastLogin = await readLastBrowserLoginLaunch();
         // Relaunch in the SAME window mode the user chose: silently reopening a
         // visible window for someone running headless would be exactly the
         // surprise window they turned headless to avoid.

package/dist/cli.js

@@ -116,7 +116,10 @@ export async function runCli(args, io = defaultIo()) {
     // A person typing `prodex` used to get the agent-facing command wall and no
     // way in. On a terminal, walk them through a consult instead; piped or
     // scripted callers still get the banner and the command list they parse.
-    if (!command && io.isInteractive === true)
+    // A keyboard as well as a screen: with stdin redirected there is nothing to
+    // answer the picker's questions with, and `prodex` alone should still print
+    // the command list rather than refuse.
+    if (!command && io.isInteractive === true && process.stdin.isTTY === true)
         return runInteractiveUi(io);
     if (!command || command === "help" || command === "--help" || command === "-h") {
         if (shouldColorize())
@@ -433,7 +436,7 @@ repo: ${cwd}
 
 Safety notes:
 - This command only prints commands; it does not start servers, open browsers, or write files.
-- Visible-browser sends require a manual, visible browser session and stop on login, captcha, Cloudflare, permission, rate-limit, or usage-limit blockers.`;
+- Visible-browser sends require a manual, visible browser session and stop on login, captcha, Cloudflare, permission, rate-limit, or usage-limit blockers, plus response_choice_pending when ChatGPT is waiting for you to pick which of two answers you prefer.`;
 }
 async function hasOnboardingReadme(cwd) {
     try {

package/dist/tui-run.js

@@ -136,6 +136,17 @@ async function askLine(io, question) {
  * Returns the process exit code.
  */
 export async function runInteractiveConsult(io, deps) {
+    // Every question here is answered with a keystroke, so a stdin that cannot
+    // deliver one has to be turned away at the door. Measured with stdin
+    // redirected: the picker painted the alternate screen, hid the cursor, and
+    // waited forever for a key that could not arrive - and never returning meant
+    // the screen was never restored either, leaving a terminal that needed
+    // `reset`.
+    if (io.input.isTTY !== true) {
+        io.write("The picker reads single keystrokes, so it needs a terminal on stdin.\n");
+        io.write('Send without one: prodex pro browser ask "your prompt"\n');
+        return 1;
+    }
     const now = deps.now ?? Date.now;
     readline.emitKeypressEvents(io.input);
     io.input.setRawMode?.(true);
@@ -278,6 +289,12 @@ export async function runInteractiveConsult(io, deps) {
         // Leave the alternate screen before the send: the answer, the receipt id
         // and any blocker belong in the scrollback the user keeps.
         io.write(ALT_SCREEN_OFF + SHOW_CURSOR);
+        // Hand the terminal back too. Raw mode is what let the pickers read single
+        // keys, and it also turns off the terminal's own ctrl-c: the key arrives as
+        // a keypress nothing is waiting for. The progress bar promises "ctrl-c to
+        // stop", and under raw mode that promise was false for the whole ten
+        // minutes a deep research send runs. No key is read from here on.
+        io.input.setRawMode?.(false);
         // --target-url confirms which conversation a send means; it deliberately
         // does not navigate. Picking one from a list IS a request to go there, so
         // move the tab first and let the flag confirm it landed.

package/package.json

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