@youdie006/prodex 0.36.3 → 0.36.5

package/dist/chatgpt-browser.js

@@ -5,6 +5,7 @@ import net from "node:net";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
+import { readPowerSliderSelection } from "./picker-interaction.js";
 export class ChatGptBrowserBlockerError extends Error {
     blocker;
     constructor(blocker) {
@@ -654,23 +655,38 @@ export function proModeNotAppliedWarning(proMode, sliderEffort) {
         "Drop --pro-mode here, or clear a saved default with `prodex setup --clear-pro-mode`.");
 }
 /**
- * Which of two flags the slider actually obeyed.
+ * Which control each request belongs to.
  *
- * On this picker one control carries both: "Pro" is the top EFFORT step, not a
- * model. Naming a model AND an effort therefore asks for two positions of the
- * same slider, and the send takes `effort ?? model` - so the model is dropped.
- * Measured: `--model Pro --effort 중간` answered from gpt-5-6-thinking with an
- * empty warnings list. Asking for Pro and quietly getting a cheaper model is
- * the kind of thing a receipt exists to catch.
+ * The picker holds two of them: a `role="slider"` for effort (Instant..Pro) and
+ * `menuitemradio` rows for the models. Selection used to send both through the
+ * slider (`effort ?? model`), so a model name walked the slider looking for a
+ * step it could never be - and the refusal quoted the slider's TEXT, which
+ * contains the model names, so the message read as "it is right there in the
+ * list". `--model Pro` only ever worked when the slider happened to sit on its
+ * top step; once it moved to Instant the same command failed.
+ *
+ * Pro stopped being a model and became that top step, but it is the pinned
+ * default in every repo configured before the change, so it is honoured where
+ * it now lives rather than failing every one of them - out loud.
  */
-export function modelIgnoredForEffortWarning(model, effort) {
-    if (!model || !effort)
-        return undefined;
-    if (model.trim().toLowerCase() === effort.trim().toLowerCase())
-        return undefined;
-    return (`model_ignored: this ChatGPT picker sets the model and the effort with one slider, ` +
-        `so --model ${model} and --effort ${effort} name two positions of it. The send used ${effort}. ` +
-        `Pass only one of them to say which you meant.`);
+export function pickerSelectionPlan(input) {
+    const plan = {};
+    const modelIsNowAnEffort = input.model !== undefined && /^\s*pro\s*$/i.test(input.model);
+    if (input.effort !== undefined)
+        plan.sliderLabel = input.effort;
+    else if (modelIsNowAnEffort)
+        plan.sliderLabel = input.model;
+    if (input.model !== undefined && !modelIsNowAnEffort)
+        plan.modelLabel = input.model;
+    if (modelIsNowAnEffort) {
+        plan.warning =
+            `model_is_now_an_effort: ChatGPT's picker lists Pro as an effort step, not a model, so --model ${input.model} was ` +
+                (input.effort === undefined
+                    ? "applied to the effort slider instead. Say --effort Pro to be explicit"
+                    : `ignored in favour of --effort ${input.effort}`) +
+                ", or clear a saved default with `prodex setup --model \"\"`.";
+    }
+    return plan;
 }
 export function chatGptBusyBlocker(state) {
     // Waiting for a choice is not generating. Conflating them turned a click
@@ -1285,6 +1301,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));
@@ -1367,15 +1391,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
     };
   })()`;
@@ -1544,6 +1577,38 @@ const POWER_SLIDER_APPEAR_ATTEMPTS = 5;
  * menu must already be open. Returns the quota line so the caller can warn
  * when Pro runs are nearly spent.
  */
+// 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.
+/**
+ * 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 ""`.');
+}
+async function selectPickerModel(cdp, requested, warnings = []) {
+    const hit = await cdp.evaluate(menuItemRectExpression(requested));
+    if (!hit.ok || hit.x === undefined || hit.y === undefined) {
+        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);
+}
 async function selectPowerStep(cdp, requested) {
     // The menu paints a moment after it opens, and on a page that has just been
     // built - a project created seconds ago - that moment is longer. Failing the
@@ -1650,18 +1715,26 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
         // it is not, so both UI generations work.
         const sliderState = await cdp.evaluate(powerSliderStateExpression());
         if (sliderState?.ok) {
-            const wanted = options.effort ?? options.model;
-            if (wanted) {
-                await selectPowerStep(cdp, wanted);
+            // The slider is the EFFORT control and the models are radios beside it.
+            // Sending a model name into the slider made it walk every step looking
+            // for one it could never be.
+            const plan = pickerSelectionPlan({
+                ...(options.model !== undefined ? { model: options.model } : {}),
+                ...(options.effort !== undefined ? { effort: options.effort } : {})
+            });
+            if (plan.warning)
+                selectionWarnings.push(plan.warning);
+            if (plan.sliderLabel) {
+                await selectPowerStep(cdp, plan.sliderLabel);
+            }
+            if (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.
             const proModeWarning = proModeNotAppliedWarning(options.proMode, sliderState.effort ?? undefined);
             if (proModeWarning)
                 selectionWarnings.push(proModeWarning);
-            const modelWarning = modelIgnoredForEffortWarning(options.model, options.effort);
-            if (modelWarning)
-                selectionWarnings.push(modelWarning);
             await dispatchEscapeKey(cdp);
             return;
         }

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/dist/store.js

@@ -55,6 +55,10 @@ export async function assertUsableBridgeRoot(root) {
         return;
     throw new Error(`Bridge root is not a usable repo directory: ${root}${looksLikeDevicePath ? " (that is a file-descriptor/device path, not a repo)" : ""}. prodex uses the process working directory when no --cwd is given, so a server started from a pipe or a deleted directory lands here. Pass --cwd /absolute/path/to/repo, or set PRODEX_CWD=/absolute/path/to/repo (works for the MCP server, which takes no flags).`);
 }
+// How many record files to read at once. High enough to hide per-file latency
+// on a slow mount, low enough that a big store cannot run the process out of
+// file descriptors.
+const READ_ALL_CONCURRENCY = 32;
 export class BridgeStore {
     root;
     bridgeDir;
@@ -878,15 +882,40 @@ export class BridgeStore {
     async readAll(kind, parseRecord, options = {}) {
         const dir = this.dir(kind);
         const entries = await readdir(dir, { withFileTypes: true });
-        const items = [];
-        for (const entry of entries) {
-            if (!entry.isFile() || !entry.name.endsWith(".json"))
-                continue;
-            const id = entry.name.replace(/\.json$/, "");
-            if (!isBridgeRecordId(kind, id))
-                continue;
-            items.push(this.parseRecord(kind, id, await this.readRecordJson(kind, id, options), parseRecord));
-        }
+        const ids = entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name.replace(/\.json$/, ""))
+            .filter((id) => isBridgeRecordId(kind, id));
+        // Read them together. The records are independent, but this loop used to
+        // await each one, so the cost was the file count times the filesystem's
+        // latency: measured on a Windows mount at ~24ms a file, 505 receipts took
+        // 12s, and `pro latest` paid it on every call because verifying ONE result
+        // reads every receipt. Bounded so a large store cannot exhaust the fd table.
+        const items = new Array(ids.length);
+        // The sequential loop threw on the FIRST bad record and never reached the
+        // rest, so that is the error callers were told about. Keep reporting the
+        // earliest one rather than whichever read happens to lose the race.
+        let failure;
+        let next = 0;
+        const readOne = async () => {
+            for (;;) {
+                const index = next;
+                next += 1;
+                if (index >= ids.length)
+                    return;
+                const id = ids[index];
+                try {
+                    items[index] = this.parseRecord(kind, id, await this.readRecordJson(kind, id, options), parseRecord);
+                }
+                catch (error) {
+                    if (!failure || index < failure.index)
+                        failure = { index, error };
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(READ_ALL_CONCURRENCY, ids.length) }, readOne));
+        if (failure)
+            throw failure.error;
         return items;
     }
     parseRecord(kind, id, value, parseRecord) {

package/package.json

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

package/scripts/release-check.mjs

@@ -133,7 +133,23 @@ async function readRequiredPackageJson(packageJsonPath) {
   }
 }
 
+// Budgets sized from what each check actually does, not from one number for all
+// of them. Measured on a developer machine whose repo sits on a 9p mount:
+// smoke:package takes 244s because it packs, installs and drives the package
+// end to end, and the suite takes ~50s. A single 180s cap killed smoke:package
+// mid-run and reported "release verification failed" with only npm's banner as
+// evidence, because the process died before it printed anything - while running
+// the same command directly passed every check. CI runs this same path before
+// publishing, so the cap was a thin margin in the release path too.
 async function runFullReleaseVerification(rootDir) {
+  // Declared here, not at module scope: this file runs its entry point during
+  // module evaluation, so a top-level const is still in its temporal dead zone
+  // by the time this is called.
+  const CHECK_TIMEOUT_MS = {
+    default: 300_000,
+    "npm test": 900_000,
+    "npm run smoke:package": 1_800_000
+  };
   const checks = [
     ["npm", ["test"]],
     ["npm", ["run", "typecheck"]],
@@ -142,7 +158,8 @@ async function runFullReleaseVerification(rootDir) {
     ["node", ["dist/cli.js", "doctor"]]
   ];
   for (const [command, commandArgs] of checks) {
-    await run(commandForPlatform(command), commandArgs, rootDir);
+    const key = [command, ...commandArgs].join(" ");
+    await run(commandForPlatform(command), commandArgs, rootDir, CHECK_TIMEOUT_MS[key] ?? CHECK_TIMEOUT_MS.default);
   }
 }
 
@@ -328,13 +345,13 @@ function formatPathList(paths) {
   return paths.length > 8 ? `${shown}, ... (${paths.length} files)` : shown;
 }
 
-async function run(command, commandArgs, cwd) {
+async function run(command, commandArgs, cwd, timeoutMs = 300_000) {
   const commandLine = [command, ...commandArgs].join(" ");
   console.log(`release_check: ${commandLine}`);
   try {
     await execFileAsync(command, commandArgs, {
       cwd,
-      timeout: 180_000,
+      timeout: timeoutMs,
       maxBuffer: 20 * 1024 * 1024
     });
   } catch (error) {