@youdie006/prodex 0.36.4 → 0.37.0

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,7 +4,9 @@ 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 {
     blocker;
     constructor(blocker) {
@@ -1300,6 +1302,14 @@ const CLICK_POINT_SNIPPET = `
       el.scrollIntoView({ block: "center", inline: "nearest" });
       const r = el.getBoundingClientRect();
       if (r.width < 1 || r.height < 1) return { ok: false, reason: "target element has no visible area" };
+      // An inert row cannot be clicked at ANY point, so say that instead of
+      // blaming whatever hit-testing returns instead. Measured on the current
+      // picker: the model rows carry pointer-events:none and sit outside the
+      // menu's own box, so every coordinate on them resolves to the effort
+      // control and the refusal read as "another element covers it".
+      if (getComputedStyle(el).pointerEvents === "none") {
+        return { ok: false, reason: "target element is not clickable (pointer-events: none)" };
+      }
       el.setAttribute('data-prodex-click', '1');
       const x = Math.round(r.x + r.width / 2);
       const y = Math.round(r.y + (yCap ? Math.min(r.height / 2, yCap) : r.height / 2));
@@ -1382,15 +1392,24 @@ export function powerSliderStateExpression() {
     const slider = document.querySelector('[role="slider"]');
     const menu = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
     const lines = menu ? (menu.innerText || "").split(String.fromCharCode(10)).map((l) => l.trim()).filter(Boolean) : [];
-    const after = (label) => { const i = lines.indexOf(label); return i >= 0 ? lines[i + 1] : null; };
     if (!slider) return { ok: false, reason: "power slider not found", lines };
+    const readPowerSliderSelection = ${readPowerSliderSelection.toString()};
+    const selection = readPowerSliderSelection({
+      sliderValueText: slider.getAttribute("aria-valuetext"),
+      items: menu ? [...menu.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')].map((item) => ({
+        role: item.getAttribute("role"),
+        text: item.innerText || item.textContent || "",
+        checked: item.getAttribute("aria-checked") === "true",
+        containsSlider: item.contains(slider)
+      })) : []
+    });
     return {
       ok: true,
       position: Number(slider.getAttribute("aria-valuenow")),
       min: Number(slider.getAttribute("aria-valuemin")),
       max: Number(slider.getAttribute("aria-valuemax")),
-      model: after("Model"),
-      effort: after("Effort"),
+      model: selection.model,
+      effort: selection.effort,
       lines
     };
   })()`;
@@ -1425,7 +1444,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") };
@@ -1562,11 +1581,92 @@ const POWER_SLIDER_APPEAR_ATTEMPTS = 5;
 // Click a model row. They are ordinary `menuitemradio` entries in the same
 // menu as the effort slider, so the existing by-label lookup reaches them; what
 // was missing is anything routing a model here instead of into the slider.
-async function selectPickerModel(cdp, requested) {
+/**
+ * Whether a model selection failure is the picker not offering it at all.
+ *
+ * Those two cases - the row is absent, or it is inert - are the UI declining to
+ * provide the choice, and they must not kill a send that is otherwise fine. It
+ * is the same answer prodex already gives for a Pro sub-mode it cannot apply.
+ * Anything else (a menu that would not open, a click that would not land) is a
+ * real failure and stays one, so a genuine break is not buried under a warning.
+ */
+export function modelSelectionUnavailableWarning(requested, reason, available) {
+    if (!/menu item not found|not clickable/i.test(reason))
+        return undefined;
+    const offers = available?.length ? ` It offers: ${available.join(", ")}.` : "";
+    return (`model_not_applied: this ChatGPT picker does not offer "${requested}" as a selectable model, ` +
+        `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());
+    const missing = [pinned.model, pinned.effort].find((wanted) => wanted !== undefined && !has(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) {
-        const available = hit.available?.length ? ` The picker offers: ${hit.available.join(", ")}.` : "";
-        throw new Error(`ChatGPT's model picker has no "${requested}" model.${available}`);
+        const unavailable = modelSelectionUnavailableWarning(requested, hit.reason ?? "", hit.available);
+        if (unavailable) {
+            warnings.push(unavailable);
+            return;
+        }
+        throw new Error(hit.reason ?? `ChatGPT's model picker has no "${requested}" model.`);
     }
     await verifiedClickWithRetry(cdp, () => cdp.evaluate(menuItemRectExpression(requested)), requested);
 }
@@ -1686,10 +1786,22 @@ 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);
+                await selectPickerModel(cdp, plan.modelLabel, selectionWarnings);
             }
             // This branch cannot honour a sub-mode, and used to return without
             // saying so - the caller got a clean receipt for a 확장 it never got.
@@ -2156,7 +2268,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);
@@ -2238,7 +2354,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);
@@ -2336,6 +2478,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,7 +26,7 @@ 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 즉시|중간|높음|"매우 높음"] [--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]
@@ -167,7 +167,7 @@ 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 즉시|중간|높음|"매우 높음"] [--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]
@@ -253,8 +253,8 @@ export function printProBrowserHelp(stdout, sourceCli) {
         : "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 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/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/dist/picker-interaction.js

@@ -0,0 +1,40 @@
+/** Pure decision helpers for ChatGPT's composer picker, kept out of the page. */
+/** Read model and effort from both the current mixed-control picker and its prior labeled-row form. */
+export function readPowerSliderSelection(snapshot) {
+    const items = snapshot.items.map((item) => ({
+        ...item,
+        lines: item.text
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+    }));
+    const powerLabels = new Set([
+        "instant",
+        "즉시",
+        "빠름",
+        "fast",
+        "medium",
+        "중간",
+        "보통",
+        "high",
+        "높음",
+        "extra high",
+        "extrahigh",
+        "very high",
+        "매우 높음",
+        "매우높음",
+        "pro",
+        "프로"
+    ]);
+    const legacyModel = items.find((item) => item.lines[0] === "Model")?.lines[1] ?? null;
+    const legacyEffort = items.find((item) => item.lines[0] === "Effort")?.lines[1] ?? null;
+    const checkedModel = items.find((item) => item.role === "menuitemradio" && item.checked)?.lines[0] ?? null;
+    const sliderOwner = items.find((item) => item.role === "menuitem" && item.containsSlider)?.lines[0] ?? null;
+    const visiblePowerLabel = items.find((item) => item.role === "menuitem" && powerLabels.has((item.lines[0] ?? "").toLowerCase()))?.lines[0] ?? null;
+    const accessibleCandidate = snapshot.sliderValueText?.trim() || null;
+    const accessibleValue = accessibleCandidate && powerLabels.has(accessibleCandidate.toLowerCase()) ? accessibleCandidate : null;
+    return {
+        model: legacyModel ?? checkedModel,
+        effort: accessibleValue ?? legacyEffort ?? sliderOwner ?? visiblePowerLabel
+    };
+}

package/package.json

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