@youdie006/prodex 0.36.5 → 0.37.1

package/README.md

@@ -424,6 +424,47 @@ During local development, you can run the TypeScript source directly:
 npm run dev -- tasks list
 ```
 
+## When a send breaks
+
+prodex drives a web UI that changes underneath it, so the interesting question is what you have when that happens.
+
+**Report it from the receipt, not from memory.** A blocked consult already records the blocker, the version and the platform, so `prodex pro report-issue` builds the report out of that:
+
+```bash
+prodex pro report-issue              # prints it, files nothing
+prodex pro report-issue --confirm    # opens it as a GitHub issue, through `gh`
+```
+
+The prompt, the answer and the summary never travel - a public issue is not where a private consult should leak - and filing is deduplicated by blocker code, so something that stays broken adds to one issue instead of opening a new one every time.
+
+**Capture what the page looked like.** With diagnostics on, a failing send leaves a screenshot and a snapshot of the picker and composer next to each other:
+
+```bash
+PRODEX_BROWSER_DIAGNOSTICS=1 prodex ask "..."
+# .bridge/diagnostics/<when>/{screen.png,page-shape.json}
+```
+
+The snapshot carries roles, testids, rects, `aria-value*` and `pointer-events`. Those last two are what identified a model row that no coordinate could click and a slider step prodex could not read. Captures stay on your machine and are never attached to a report; a screenshot of ChatGPT shows the conversation.
+
+**Notice before a person does.** `scripts/ui-watchdog.mjs` sends a token and checks the reply - a real round trip rather than a guess from the page's shape - and can file what it finds:
+
+```bash
+node scripts/ui-watchdog.mjs                 # says ok or broken
+node scripts/ui-watchdog.mjs --file-issue    # and reports it
+```
+
+It needs the logged-in browser, so it belongs on a machine that has one rather than in CI. A daily cron entry is enough.
+
+## Sending without leaving a trace
+
+`--temporary` sends into a ChatGPT Temporary Chat, which leaves your chat list untouched:
+
+```bash
+prodex ask --new-chat --temporary "..."
+```
+
+It costs something, and prodex says so on every such send: an unsaved chat is not in the transcript API, so the answer is read off the page, where tables and citation links can be lost - and neither `pro browser recover` nor `--target-url` can reach it afterwards. It requires `--new-chat`, because a throwaway chat cannot be continued.
+
 ## FAQ
 
 **A send failed with `send_ui_changed` / "the ChatGPT web UI may have changed".** prodex drives the visible ChatGPT web UI, so an OpenAI redesign of the composer or send control can break sends. When a send times out without the prompt ever posting (the composer still holds the text, or no send button was found), prodex reports this as a likely UI change instead of a misleading "slow model" timeout. Fix: update prodex (`npm i -g @youdie006/prodex@latest`); if it persists, open an issue at https://github.com/youdie006/prodex/issues, and paste the prompt manually in the visible browser in the meantime.

package/dist/browser-diagnostics.js

@@ -0,0 +1,104 @@
+/**
+ * Capture what the page looked like when a send failed.
+ *
+ * Every UI break in this project has cost a live debugging session: opening the
+ * picker by hand, reading rects, asking elementFromPoint what was on top. A
+ * report from another machine cannot carry any of that, so the same archaeology
+ * gets repeated by whoever can reproduce it.
+ *
+ * These stay LOCAL and are never attached to anything. A screenshot of ChatGPT
+ * shows the conversation, so the capture is a debugging aid for the person who
+ * hit the failure, not something to hand out - the same line `pro report-issue`
+ * already draws.
+ */
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+/** Whether the caller asked for captures. Off unless explicitly turned on. */
+export function diagnosticsEnabled(env = process.env) {
+    const raw = env.PRODEX_BROWSER_DIAGNOSTICS;
+    return raw !== undefined && raw !== "" && raw !== "0" && raw.toLowerCase() !== "false";
+}
+/** Where a capture for this failure belongs. */
+export function diagnosticsDir(cwd, label) {
+    const safe = label.replace(/[^A-Za-z0-9_.-]+/g, "-").slice(0, 80) || "capture";
+    return path.join(cwd, ".bridge", "diagnostics", safe);
+}
+/**
+ * What the picker and composer looked like: the shape prodex needs in order to
+ * drive them, read the way the failing code reads it.
+ */
+export function pageShapeExpression() {
+    return `(() => {
+    const vis = (el) => !!(el.offsetWidth || el.offsetHeight || el.getClientRects().length);
+    const box = (el) => { const r = el.getBoundingClientRect(); return { x: Math.round(r.x), y: Math.round(r.y), w: Math.round(r.width), h: Math.round(r.height) }; };
+    const menu = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    const describe = (el) => ({
+      role: el.getAttribute("role"),
+      testid: el.getAttribute("data-testid"),
+      label: (el.innerText || "").replace(/\\n+/g, " / ").trim().slice(0, 60),
+      checked: el.getAttribute("aria-checked"),
+      haspopup: el.getAttribute("aria-haspopup"),
+      valuenow: el.getAttribute("aria-valuenow"),
+      valuemax: el.getAttribute("aria-valuemax"),
+      valuetext: el.getAttribute("aria-valuetext"),
+      // The reason a click can be refused at every coordinate on a row.
+      pointerEvents: getComputedStyle(el).pointerEvents,
+      ...box(el)
+    });
+    return {
+      url: location.href,
+      title: document.title,
+      viewport: { w: window.innerWidth, h: window.innerHeight },
+      pickerOpen: Boolean(menu),
+      picker: menu ? { ...box(menu), items: [...menu.querySelectorAll('[role],button')].filter(vis).map(describe) } : null,
+      composerButtons: [...document.querySelectorAll('form button,form [role="button"]')].filter(vis).map(describe)
+    };
+  })()`;
+}
+/**
+ * Write a screenshot and a shape snapshot next to each other. Failing to
+ * capture must never replace the failure being captured, so every step here is
+ * best effort and the caller gets back only what actually landed.
+ */
+export async function captureBrowserDiagnostics(target, input) {
+    const dir = diagnosticsDir(input.cwd, input.label);
+    const files = [];
+    try {
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const shape = await target.evaluate(pageShapeExpression());
+        const file = path.join(dir, "page-shape.json");
+        await writeFile(file, `${JSON.stringify(shape, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+        files.push(file);
+    }
+    catch {
+        // A page that cannot answer is itself worth knowing, but not worth failing over.
+    }
+    try {
+        // Some targets refuse captureScreenshot until the Page domain is on, and the
+        // failure is silent - the first capture written here came back with the
+        // shape and no image.
+        await target.send("Page.enable").catch(() => undefined);
+        const shot = (await target.send("Page.captureScreenshot", { format: "png" }));
+        if (typeof shot?.data === "string" && shot.data.length > 0) {
+            const file = path.join(dir, "screen.png");
+            await writeFile(file, Buffer.from(shot.data, "base64"), { mode: 0o600 });
+            files.push(file);
+        }
+    }
+    catch {
+        // Screenshots are unavailable on some targets; the shape snapshot still helps.
+    }
+    return files.length > 0 ? { dir, files } : undefined;
+}
+/** One line telling the user where the capture went, and that it stays put. */
+export function diagnosticsNote(capture) {
+    if (!capture)
+        return undefined;
+    return (`browser_diagnostics: wrote ${capture.files.length} file(s) to ${capture.dir}. ` +
+        "They stay on this machine - a screenshot of ChatGPT shows the conversation, so nothing attaches them to a report.");
+}

package/dist/chatgpt-browser.js

@@ -4,6 +4,7 @@ import { accessSync, constants, statSync } from "node:fs";
 import net from "node:net";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { captureBrowserDiagnostics, diagnosticsEnabled, diagnosticsNote } from "./browser-diagnostics.js";
 import os from "node:os";
 import { readPowerSliderSelection } from "./picker-interaction.js";
 export class ChatGptBrowserBlockerError extends Error {
@@ -14,7 +15,12 @@ export class ChatGptBrowserBlockerError extends Error {
         this.blocker = blocker;
     }
 }
-const REASONING_EFFORTS = ["즉시", "중간", "높음", "매우 높음"];
+// Five steps, not four. Measured at both ends of the live slider: position 0 of
+// 4 reads "Instant, 1 of 5" and position 4 reads "Pro, 5 of 5", so Pro is a step
+// of this control rather than a model. Leaving it out meant --effort could not
+// reach the top of the slider at all, and the only route there - --model Pro -
+// answered with advice to "say --effort Pro", which then failed.
+const REASONING_EFFORTS = ["즉시", "중간", "높음", "매우 높음", "Pro"];
 const PRO_MODES = ["기본", "확장"];
 // Aliases map friendly CLI input onto the exact Korean menu labels the picker
 // clicks by text. Keys are lowercased and space-stripped before lookup.
@@ -24,7 +30,9 @@ const REASONING_EFFORT_ALIASES = {
     medium: "중간",
     high: "높음",
     max: "매우 높음",
-    extrahigh: "매우 높음"
+    extrahigh: "매우 높음",
+    pro: "Pro",
+    "프로": "Pro"
 };
 // Menu labels per canonical value, verified live in both the Korean and the
 // English (US) ChatGPT UI. Matching tries every candidate so either UI works.
@@ -32,7 +40,8 @@ const EFFORT_MENU_LABELS = {
     "즉시": ["즉시", "Instant"],
     "중간": ["중간", "Medium"],
     "높음": ["높음", "High"],
-    "매우 높음": ["매우 높음", "Extra High"]
+    "매우 높음": ["매우 높음", "Extra High"],
+    Pro: ["Pro", "프로"]
 };
 const PRO_MODE_SUBMENU_LABELS = {
     "기본": ["Pro 기본", "Pro Standard", "Standard", "기본"],
@@ -1443,7 +1452,7 @@ export function menuItemRectExpression(label) {
     if (!m) return { ok: false, reason: "reasoning/model menu did not open" };
     const items = [...m.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')];
     const it = items.find(${menuLabelMatchPredicate(label)});
-    if (!it) return { ok: false, reason: "menu item not found", available: items.map((r) => ((r.innerText || r.textContent || "").trim().split(String.fromCharCode(10))[0] || "").trim()).slice(0, 12) };
+    if (!it) return { ok: false, reason: "menu item not found", available: items.map((r) => ((r.innerText || r.textContent || "").trim().split(String.fromCharCode(10))[0] || "").trim()).filter((label) => label.length > 0).slice(0, 12) };
     const point = clickPoint(it);
     if (!point.ok) return point;
     return { ...point, role: it.getAttribute("role"), haspopup: it.getAttribute("aria-haspopup") };
@@ -1597,6 +1606,80 @@ export function modelSelectionUnavailableWarning(requested, reason, available) {
         `so the send used whatever the composer already had.${offers} ` +
         'Pick an effort with --effort instead, or clear a saved default with `prodex setup --model ""`.');
 }
+/**
+ * A step the slider does not have.
+ *
+ * Reported from another machine: that account's picker has no "Pro" step at all
+ * - five attempts, the same list every time - so a pinned default of model=Pro
+ * became a step request the slider could not satisfy and every plain send died.
+ * The picker declining to offer something is not prodex breaking, so it reads
+ * the same way the model case does: warn, and let the send go.
+ */
+/**
+ * A pinned default the picker does not offer.
+ *
+ * This is how prodex broke for someone else: model=Pro was pinned back when Pro
+ * was a model, ChatGPT turned it into an effort step and dropped it from some
+ * accounts entirely, and every plain send there failed afterwards. The picker
+ * knows what it offers, so asking it once - when the default is set - beats
+ * finding out on every send for weeks.
+ */
+/**
+ * What a temporary chat costs.
+ *
+ * Measured: the chat list is byte-identical before and after, which is the
+ * point - but the answer arrives without the "(transcript ...)" a normal send
+ * reports, because the transcript API does not hold a chat that was never
+ * saved. So the answer is read off the page, which is where prodex loses
+ * markdown tables and citation urls. Trading fidelity for privacy is a fine
+ * trade to offer and a bad one to make silently.
+ */
+export function temporaryChatWarning(temporary) {
+    if (!temporary)
+        return undefined;
+    return ("temporary_chat: this chat is not saved, so the answer was read from the page rather than the transcript - " +
+        "tables and citation links can be lost - and neither `pro browser recover` nor `--target-url` can reach it later.");
+}
+export function pinnedSelectionWarning(pinned, offered) {
+    // An unreadable picker is not evidence that the pin is wrong.
+    if (offered.length === 0)
+        return undefined;
+    const has = (wanted) => offered.some((label) => label.trim().toLowerCase() === wanted.trim().toLowerCase());
+    // A value prodex already knows to be a slider step needs no listing to
+    // vouch for it: the slider shows one step at a time, so a listing that
+    // happens to read "Extra High" says nothing about Pro. Warning there was a
+    // false alarm about a setting the very next send used successfully, and an
+    // alarm that cries about known-good settings is one people learn to skip.
+    const knownStep = (wanted) => {
+        try {
+            parseReasoningEffort(wanted);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const missing = [pinned.model, pinned.effort].find((wanted) => wanted !== undefined && !has(wanted) && !knownStep(wanted));
+    if (missing === undefined)
+        return undefined;
+    // Say only what was seen. The picker lists its models, but the effort slider
+    // shows one step at a time - reading the others means moving it, which would
+    // change the user's setting just to look. So this reports that the pin was not
+    // among what the picker LISTED, not that the account cannot provide it.
+    return (`pinned_selection_check: "${missing}" was not among what the picker listed (${offered.join(", ")}). ` +
+        "The effort slider only shows its current step, so a step by that name may still exist. " +
+        "If sends start warning that it was not applied, pin one of the listed names or clear it with `prodex setup --clear-model`.");
+}
+export function stepSelectionUnavailableWarning(requested, offered) {
+    if (!requested)
+        return undefined;
+    // Quote what the page said. The browser that hit this runs in Korean, so the
+    // steps come back translated and an English label prodex expected would be
+    // useless to the person reading the warning.
+    const list = offered.length ? ` It offers: ${offered.join(", ")}.` : "";
+    return (`step_not_applied: this ChatGPT picker has no "${requested}" step, so the send used the slider's current setting.${list} ` +
+        'Pick one of those with --effort, or clear a saved default with `prodex setup --clear-model`.');
+}
 async function selectPickerModel(cdp, requested, warnings = []) {
     const hit = await cdp.evaluate(menuItemRectExpression(requested));
     if (!hit.ok || hit.x === undefined || hit.y === undefined) {
@@ -1725,7 +1808,19 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
             if (plan.warning)
                 selectionWarnings.push(plan.warning);
             if (plan.sliderLabel) {
-                await selectPowerStep(cdp, plan.sliderLabel);
+                try {
+                    await selectPowerStep(cdp, plan.sliderLabel);
+                }
+                catch (error) {
+                    // Only "this slider has no such step" is the picker declining. A
+                    // slider that will not open, or will not move, is a real failure.
+                    const message = error instanceof Error ? error.message : String(error);
+                    const noSuchStep = /has no "[^"]*" step/.test(message);
+                    if (!noSuchStep)
+                        throw error;
+                    const offered = /It showed: (.*)$/.exec(message)?.[1]?.split(" / ").map((part) => part.trim()) ?? [];
+                    selectionWarnings.push(stepSelectionUnavailableWarning(plan.sliderLabel, offered));
+                }
             }
             if (plan.modelLabel) {
                 await selectPickerModel(cdp, plan.modelLabel, selectionWarnings);
@@ -2195,7 +2290,11 @@ export async function sendChatGptPrompt(options) {
         // thread silently lands outside the project (measured live: --new-chat
         // --project threads appeared in the root chat list, --project-only
         // threads appeared inside the project).
-        await evaluateOnPage(page, `location.assign("https://chatgpt.com/")`);
+        // A temporary chat is reached by url rather than by clicking the control:
+        // the same navigation this already does, one query parameter different, and
+        // nothing to find on a page whose buttons keep moving.
+        const freshUrl = options.temporary ? "https://chatgpt.com/?temporary-chat=true" : "https://chatgpt.com/";
+        await evaluateOnPage(page, `location.assign(${JSON.stringify(freshUrl)})`);
         await waitForFreshChatGptPage(page, 8_000);
     }
     let status = await readSettledChatGptPageStatus(page);
@@ -2277,7 +2376,33 @@ export async function sendChatGptPrompt(options) {
     let submitButtonFound = false;
     let wantsDeepResearch = false;
     const sendWarnings = [];
+    const temporaryNote = temporaryChatWarning(options.temporary);
+    if (temporaryNote)
+        sendWarnings.push(temporaryNote);
     const cdp = await connectCdp(page.webSocketDebuggerUrl);
+    // With diagnostics on, a send that fails leaves behind what the page looked
+    // like: the shape prodex reads plus a screenshot. Every UI break in this
+    // project has otherwise cost a live debugging session, and a report from
+    // another machine can carry none of that. Local only - see browser-diagnostics.
+    const captureOnFailure = async (label) => {
+        if (!diagnosticsEnabled())
+            return;
+        const capture = await captureBrowserDiagnostics({
+            evaluate: (expression) => evaluateOnPage(page, expression),
+            // cdp.send resolves with the whole CDP message; the command's own result
+            // is one level in. Passing the envelope through meant the screenshot
+            // bytes were never found and the capture silently held only the shape.
+            send: async (method, params) => (await cdp.send(method, params ?? {})).result
+        }, { cwd: options.diagnosticsCwd ?? process.cwd(), label }).catch(() => undefined);
+        const note = diagnosticsNote(capture);
+        // Warnings only reach the caller on success, and this runs when the send is
+        // about to throw - so the note goes out through progress, which the CLI
+        // prints as it happens.
+        if (note) {
+            sendWarnings.push(note);
+            emitProgress("waiting", note);
+        }
+    };
     try {
         await cdp.send("Runtime.enable");
         await selectProject(cdp, options);
@@ -2375,6 +2500,13 @@ export async function sendChatGptPrompt(options) {
             }
         }
     }
+    catch (error) {
+        // Capture before the connection closes: this is the moment the page still
+        // looks the way it looked when it refused, and the selection failures this
+        // project keeps hitting are invisible in the error text alone.
+        await captureOnFailure(`send-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+        throw error;
+    }
     finally {
         cdp.close();
     }

package/dist/cli-args.js

@@ -249,6 +249,7 @@ export function assertNoExtraArgs(args, command, maxPositionals) {
     }
 }
 export const ASK_PRO_BOOLEAN_FLAGS = new Set([
+    "--temporary",
     "--dry-run",
     "--send",
     "--confirm-target",

package/dist/cli-help.js

@@ -26,10 +26,11 @@ Ask / consult commands:
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of model menu options
   prodex pro browser projects [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of sidebar project names (for --project)
   prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # recover a finished answer from a thread whose send timed out
-  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"] "prompt"  # explicit visible-browser send
+  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--temporary] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Pro] [--project "name" | --project-new "name"] "prompt"  # explicit visible-browser send
   prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
+  prodex pro report-issue [--cwd /absolute/path/to/repo] [--task <task-id>] [--repo owner/name] [--confirm]  # bug report from a failed consult's receipt; previews unless --confirm, never carries the prompt or the answer
 
 Bridge ledger (durable tasks/results/receipts/sessions under .bridge/):
   prodex init [--cwd /absolute/path/to/repo]
@@ -51,7 +52,7 @@ Bridge ledger (durable tasks/results/receipts/sessions under .bridge/):
 
 Agent / MCP integration:
   prodex mcp [--cwd /absolute/path/to/repo]
-  prodex setup [--cwd /absolute/path/to/repo] [--host 127.0.0.1] [--port 8787] [--token-ttl-hours <hours>] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name"] [--clear-model|--clear-pro-mode|--clear-effort|--clear-project] [--interactive]
+  prodex setup [--cwd /absolute/path/to/repo] [--host 127.0.0.1] [--port 8787] [--token-ttl-hours <hours>] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Pro] [--project "name"] [--clear-model|--clear-pro-mode|--clear-effort|--clear-project] [--interactive]
   prodex start [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js]
   prodex status [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] [--show-token] [--url-only] [--unsafe-show-non-expiring-token]
   prodex tunnel url [--cwd /absolute/path/to/repo] [--source-cli /absolute/path/to/dist/cli.js] --public-url https://... [--show-token] [--url-only]
@@ -79,7 +80,7 @@ export function printSetupHelp(stdout) {
     stdout(`prodex setup
 
 Commands:
-  prodex setup [--cwd /absolute/path/to/repo] [--host 127.0.0.1] [--port 8787] [--token-ttl-hours <hours>] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name"] [--clear-model|--clear-pro-mode|--clear-effort|--clear-project] [--interactive]
+  prodex setup [--cwd /absolute/path/to/repo] [--host 127.0.0.1] [--port 8787] [--token-ttl-hours <hours>] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Pro] [--project "name"] [--clear-model|--clear-pro-mode|--clear-effort|--clear-project] [--interactive]
 
 Save a loopback-only HTTP MCP profile in .bridge/config.local.json. Use --token-ttl-hours before tunnels or ChatGPT Project use.
 
@@ -167,10 +168,11 @@ Commands:
   prodex pro browser check [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js]
-  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--target-url url --confirm-target] [--new-chat] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"] "prompt"
+  prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--target-url url --confirm-target] [--new-chat] [--temporary] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Pro] [--project "name" | --project-new "name"] "prompt"
   prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
+  prodex pro report-issue [--cwd /absolute/path/to/repo] [--task <task-id>] [--repo owner/name] [--confirm]  # bug report from a failed consult's receipt; previews unless --confirm, never carries the prompt or the answer
 
 Use \`prodex pro ask\` for dry-run/manual previews.
 Use \`prodex pro browser ask\` only when you want an explicit visible-browser send.
@@ -251,10 +253,10 @@ export function printProBrowserHelp(stdout, sourceCli) {
     const smokeUsage = sourceCli
         ? `${cli} pro browser smoke${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]`
         : "prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]";
-    const selectionUsage = '[--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"]';
+    const selectionUsage = '[--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Pro] [--project "name" | --project-new "name"]';
     const askUsage = sourceCli
-        ? `${cli} pro browser ask${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`
-        : `prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`;
+        ? `${cli} pro browser ask${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--temporary] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`
+        : `prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--temporary] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] ${selectionUsage} "prompt"`;
     const modelsUsage = sourceCli
         ? `${cli} pro browser models${sourceCliOption} [--port 9333] [--timeout-ms 15000]`
         : "prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]";

package/dist/cli-pro.js

@@ -11,6 +11,8 @@ import { errorMessage, firstLine, formatBlockedConsultRecordedMessage, formatPro
 import { getTokenExpiryStatus, loadBrowserDefaults, loadLocalConfig } from "./config.js";
 import { withBrowserSendLock } from "./browser-send-lock.js";
 import { BridgeStore, MAX_FETCHABLE_RESULT_ARTIFACT_BYTES } from "./store.js";
+import { CLI_VERSION } from "./cli-help.js";
+import { PRODEX_ISSUE_REPO, buildIssueReport, fileGitHubIssue } from "./issue-report.js";
 export async function runChatgptCommand(rest, io) {
     const [subcommand, ...chatgptArgs] = rest;
     if (!subcommand || isHelpSubcommand(subcommand)) {
@@ -157,6 +159,7 @@ export async function runProCommand(rest, io, runCliFn) {
             "--pro-mode",
             "--effort",
             "--new-chat",
+            "--temporary",
             "--auto-login",
             "--no-auto-login"
         ].find((flag) => proArgs.includes(flag));
@@ -739,6 +742,43 @@ export async function runProCommand(rest, io, runCliFn) {
         }
         return 0;
     }
+    if (subcommand === "report-issue") {
+        if (printHelpIfRequested(proArgs, "pro report-issue", io.stdout, printProHelp, { valueFlags: ["--cwd", "--task", "--repo"] }))
+            return 0;
+        assertOnlyOptions(proArgs, "pro report-issue", ["--cwd", "--task", "--repo"], ["--confirm"]);
+        const targetCwd = resolveCwdFlag(io.cwd, proArgs);
+        const targetStore = new BridgeStore(targetCwd);
+        const wantedTask = readFlag(proArgs, "--task");
+        const record = wantedTask
+            ? await (async () => {
+                const result = await targetStore.getResultReadOnly(wantedTask);
+                const task = await targetStore.getTaskReadOnly(wantedTask);
+                return { task, result };
+            })()
+            : await latestBlockedConsult(targetStore);
+        if (!record)
+            throw new Error("No blocked consult found to report. Nothing failed, so there is nothing to file.");
+        const report = buildIssueReport({
+            task_id: record.result.task_id,
+            status: record.result.status,
+            ...(record.result.blocker ? { blocker: record.result.blocker } : {})
+        }, { version: CLI_VERSION, platform: process.platform, nodeVersion: process.version });
+        io.stdout(`title: ${report.title}`);
+        io.stdout(`labels: ${report.labels.join(", ")}`);
+        io.stdout("");
+        io.stdout(report.body);
+        io.stdout("");
+        // Filing is outward-facing and public, so it never happens as a side
+        // effect of looking. The preview above is the whole report.
+        if (!proArgs.includes("--confirm")) {
+            io.stdout("Nothing was filed. Re-run with --confirm to open this as a GitHub issue.");
+            return 0;
+        }
+        const repo = readFlag(proArgs, "--repo") ?? PRODEX_ISSUE_REPO;
+        const filed = await fileGitHubIssue(repo, report);
+        io.stdout(`filed: ${filed}`);
+        return 0;
+    }
     if (subcommand === "latest") {
         if (printHelpIfRequested(proArgs, "pro latest", io.stdout, printProHelp, { valueFlags: ["--cwd", "--source-cli"] }))
             return 0;
@@ -990,6 +1030,14 @@ export async function runAskProCommand(rest, io) {
         throw new Error("ask-pro cannot combine --target-url with --project/--project-new: --target-url pins the confirmed tab while the project step navigates the sidebar away from it. Open the project thread in the browser and pass its URL as --target-url instead.");
     }
     const newChat = parsedAskPro.optionArgs.includes("--new-chat");
+    // A temporary chat is not saved, so there is nothing to come back to: the
+    // recovery path every timeout message points at cannot fetch it later.
+    // Requiring --new-chat keeps that explicit rather than quietly turning a
+    // continuation into a throwaway.
+    const temporary = parsedAskPro.optionArgs.includes("--temporary");
+    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.");
+    }
     if (newChat && normalizedTargetUrl) {
         throw new Error("ask-pro cannot combine --new-chat with --target-url: --new-chat navigates to a fresh chat while --target-url pins the confirmed tab.");
     }
@@ -1117,6 +1165,8 @@ export async function runAskProCommand(rest, io) {
             ...(attachments.length > 0 ? { attachments } : {}),
             ...(tools.length > 0 ? { tools } : {}),
             ...(newChat ? { newChat: true } : {}),
+            ...(temporary ? { temporary: true } : {}),
+            diagnosticsCwd: targetCwd,
             ...(busyWaitMs !== undefined ? { busyWaitMs } : {}),
             project: selectionProject,
             projectNew: selectionProjectNew,
@@ -1814,6 +1864,16 @@ export async function latestTrustedConsult(store, options = { readOnly: true })
         throw firstUntrusted;
     return undefined;
 }
+/**
+ * The newest consult that FAILED, which is what a bug report is about.
+ *
+ * latestTrustedConsult deliberately walks past blocked records looking for an
+ * answer; a report wants the opposite.
+ */
+export async function latestBlockedConsult(store) {
+    const records = await listConsultRecordsNewestFirst(store);
+    return records.find((record) => record.result.status === "blocked");
+}
 export function legacyChatGptNamespaceError(subcommand) {
     const prefix = subcommand ? `Unknown legacy chatgpt subcommand: ${subcommand}.` : "The legacy `chatgpt` namespace is hidden.";
     return new Error(`${prefix} Use \`prodex pro browser help\` for visible-browser commands.`);

package/dist/cli-server.js

@@ -52,9 +52,27 @@ export async function runSetupCommand(rest, io) {
     io.stdout("The token is stored (once) in .bridge/config.local.json; print the full URL with `prodex status --show-token --url-only`.");
     if (config.browser_defaults) {
         io.stdout(`Browser send defaults: ${formatBrowserDefaults(config.browser_defaults)}`);
+        // Ask the picker whether it can actually provide what was just pinned.
+        // Pinning something it does not offer is how prodex broke for someone
+        // else: model=Pro was pinned when Pro was a model, ChatGPT made it an
+        // effort step and dropped it from some accounts, and every plain send
+        // failed there afterwards. Best effort - no browser is not a verdict.
+        const warning = await pinnedSelectionCheck(config.browser_defaults).catch(() => undefined);
+        if (warning)
+            io.stdout(warning);
     }
     return 0;
 }
+/** What the picker currently offers, compared against what was just pinned. */
+async function pinnedSelectionCheck(defaults) {
+    const { listChatGptModelOptions, pinnedSelectionWarning } = await import("./chatgpt-browser.js");
+    const listed = await listChatGptModelOptions({ timeoutMs: 8_000 });
+    const offered = listed.options.flatMap((option) => [option.label, ...(option.value ? [option.value] : [])]);
+    return pinnedSelectionWarning({
+        ...(defaults.model !== undefined ? { model: defaults.model } : {}),
+        ...(defaults.effort !== undefined ? { effort: defaults.effort } : {})
+    }, offered);
+}
 export async function runStartCommand(rest, io) {
     if (printHelpIfRequested(rest, "start", io.stdout, printStartHelp, { valueFlags: ["--cwd", "--source-cli"] }))
         return 0;

package/dist/cli.js

@@ -436,7 +436,9 @@ 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, plus response_choice_pending when ChatGPT is waiting for you to pick which of two answers you prefer.`;
+- 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.
+- When a send is blocked, \`prodex pro report-issue\` turns that receipt into a bug report (prints it; --confirm files it). It carries the blocker, version and platform, never the prompt or the answer.
+- PRODEX_BROWSER_DIAGNOSTICS=1 makes a failing send leave a screenshot and a page snapshot under .bridge/diagnostics for whoever debugs it. They stay local.`;
 }
 async function hasOnboardingReadme(cwd) {
     try {

package/dist/config.js

@@ -10,7 +10,8 @@ const BRIDGE_DIRECTORY_MODE = 0o700;
 const BrowserDefaultsSchema = z.object({
     model: z.string().min(1).optional(),
     pro_mode: z.enum(["기본", "확장"]).optional(),
-    effort: z.enum(["즉시", "중간", "높음", "매우 높음"]).optional(),
+    // Pro is the slider's fifth step, so a saved default may name it.
+    effort: z.enum(["즉시", "중간", "높음", "매우 높음", "Pro"]).optional(),
     project: z.string().min(1).optional()
 });
 const LocalConfigSchema = z.object({

package/dist/issue-report.js

@@ -0,0 +1,111 @@
+/**
+ * Turn a blocked consult into a bug report.
+ *
+ * Reports from this project have been arriving as chat messages: a session on
+ * another machine hit a broken picker three different ways, and the only record
+ * was the conversation it was typed into. A blocked receipt already holds what a
+ * report needs, so this reads that rather than asking anyone to retype it.
+ */
+/**
+ * Which part of prodex a blocker belongs to.
+ *
+ * Guessing from the code prefix keeps this honest about what it does not know:
+ * an unfamiliar code gets no area label rather than a wrong one.
+ */
+export function issueAreaLabel(code) {
+    if (/^(browser|chatgpt|send|model|response|tab|composer|login|captcha|deep_research|pro_mode)/.test(code))
+        return "area:browser";
+    if (/^(bridge|store|receipt|task|result|session|artifact)/.test(code))
+        return "area:bridge";
+    if (/^(config|setup|token|mcp|server)/.test(code))
+        return "area:config";
+    return undefined;
+}
+/**
+ * Build the report. Only the failure travels: never the prompt, the answer, or
+ * the summary, because a public issue must not become where a private consult
+ * leaks. Everything included here is either environment or blocker metadata.
+ */
+export function buildIssueReport(consult, environment) {
+    if (consult.status !== "blocked" || !consult.blocker) {
+        throw new Error(`${consult.task_id} is not a failure (status ${consult.status}), so there is nothing to report.`);
+    }
+    const code = (consult.blocker.code ?? "unknown").trim();
+    const message = (consult.blocker.message ?? "").trim();
+    const area = issueAreaLabel(code);
+    const body = [
+        "A consult was blocked. Filed from its receipt, so the prompt and the answer are not included.",
+        "",
+        "| | |",
+        "| --- | --- |",
+        `| blocker | \`${code}\` |`,
+        `| message | ${message || "(none)"} |`,
+        `| retryable | ${consult.blocker.retryable === true ? "yes" : "no"} |`,
+        `| prodex | ${environment.version} |`,
+        `| platform | ${environment.platform} |`,
+        `| node | ${environment.nodeVersion} |`,
+        "",
+        ...(consult.blocker.next_step ? ["What it told the caller to do:", "", `> ${consult.blocker.next_step}`, ""] : []),
+        "Receipt (local, not attached): " + consult.task_id
+    ].join("\n");
+    return {
+        title: `${code}: ${message || "blocked consult"}`.slice(0, 120),
+        body,
+        labels: ["bug", ...(area ? [area] : [])]
+    };
+}
+/**
+ * Whether this report is news.
+ *
+ * A watchdog that files on every run turns one broken thing into a daily pile of
+ * identical issues, and the pile is what makes people stop reading them. Same
+ * blocker code, still open: add to it instead of opening another.
+ */
+export function chooseIssueAction(openIssues, report) {
+    const code = report.title.split(":")[0]?.trim();
+    if (!code)
+        return { action: "create" };
+    const existing = openIssues.find((issue) => issue.title.split(":")[0]?.trim() === code);
+    return existing ? { action: "comment", number: existing.number } : { action: "create" };
+}
+/** The repository a report goes to when the caller does not name one. */
+export const PRODEX_ISSUE_REPO = "youdie006/prodex";
+/**
+ * File the report through the `gh` CLI, which already holds the user's GitHub
+ * auth. Shelling out beats storing a token: prodex never asks for one, and
+ * whatever `gh` is allowed to do is exactly what this is allowed to do.
+ */
+export async function fileGitHubIssue(repo, report) {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const run = promisify(execFile);
+    try {
+        // Only ask for labels the repository has. A label it lacks makes `gh` refuse
+        // the whole issue ("could not add label: 'area:browser' not found"), so a
+        // missing label would cost the report rather than cost the label.
+        const known = await run("gh", ["label", "list", "--repo", repo, "--limit", "100", "--json", "name"], { timeout: 60_000 }).then(({ stdout }) => new Set(JSON.parse(stdout || "[]").map((label) => label.name)), () => undefined);
+        const labels = known ? report.labels.filter((label) => known.has(label)) : report.labels;
+        const open = await run("gh", ["issue", "list", "--repo", repo, "--state", "open", "--limit", "100", "--json", "number,title"], {
+            timeout: 60_000
+        }).then(({ stdout }) => JSON.parse(stdout || "[]"), () => []);
+        const decision = chooseIssueAction(open, report);
+        if (decision.action === "comment") {
+            await run("gh", ["issue", "comment", String(decision.number), "--repo", repo, "--body", report.body], { timeout: 60_000 });
+            return `commented on existing #${decision.number}`;
+        }
+        const args = ["issue", "create", "--repo", repo, "--title", report.title, "--body", report.body];
+        for (const label of labels)
+            args.push("--label", label);
+        const { stdout } = await run("gh", args, { timeout: 60_000 });
+        return stdout.trim().split(/\r?\n/).filter(Boolean).pop() ?? "(no url returned)";
+    }
+    catch (error) {
+        // `gh` puts the reason on stderr and Node puts the command line in
+        // error.message, so reporting message first hid every real cause behind the
+        // command that produced it.
+        const stderr = error.stderr;
+        const detail = (typeof stderr === "string" ? stderr.split(/\r?\n/).map((line) => line.trim()).find(Boolean) : undefined) ??
+            (error instanceof Error ? error.message.split(/\r?\n/)[0] : String(error));
+        throw new Error(`Could not file the issue with \`gh\`: ${detail}. Check \`gh auth status\`, or copy the report above into a new issue by hand.`);
+    }
+}

package/package.json

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