@youdie006/prodex 0.36.2 → 0.36.4

package/dist/chatgpt-browser.js

@@ -654,23 +654,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
@@ -1544,6 +1559,17 @@ 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.
+async function selectPickerModel(cdp, requested) {
+    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}`);
+    }
+    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 +1676,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);
             }
             // 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;
         }
@@ -3954,6 +3988,30 @@ export function transcriptMatchesSentPrompt(userText, sentPrompt) {
 // separates, U+E201 closes) and keeps the real sources in content_references.
 const CITATION_DELIMITER_PATTERN = /[\uE200-\uE206]/;
 const CITATION_MARKER_PATTERN = /\uE200[^\uE200-\uE206]*(?:[\uE202\uE204-\uE206][^\uE200-\uE206]*)*[\uE201\uE203]/g;
+/**
+ * The words a citation marker was wrapping, if any.
+ *
+ * The markers come in two shapes. `<E200>cite<E202>turn0search0<E201>` is a
+ * bare anchor - kind then reference id, nothing a reader would miss. But
+ * `<E200>url<E202>Timeanddate.com — World Clock<E202>turn0search0<E201>` puts a
+ * visible title in the middle, and that title is part of the sentence. Caught by
+ * diffing a saved answer against its thread: a web-search reply ended at a
+ * dangling "Source:" because the title had been deleted along with the marker.
+ */
+export function citationMarkerText(marker) {
+    // The first segment is the kind and the rest are a mix of reference tokens and,
+    // for some kinds, prose. Sorting them by SHAPE rather than by kind keeps a
+    // title from a kind not seen yet: `cite` can carry several ids
+    // (`cite<E202>turn0search19<E202>turn0search5`), and dropping every
+    // id-shaped segment leaves nothing there, which is right.
+    const referenceToken = /^turn\d+[a-z]+\d+$/i;
+    const segments = marker.replace(/^[\uE200-\uE206]|[\uE200-\uE206]$/g, "").split(/[\uE200-\uE206]/);
+    return segments
+        .slice(1)
+        .filter((segment) => segment.length > 0 && !referenceToken.test(segment))
+        .join(" ")
+        .trim();
+}
 /**
  * Turn those markers into ordinary markdown links, so a saved answer keeps the
  * sources instead of the private-use noise (or, as in the rendered DOM, nothing
@@ -3984,11 +4042,13 @@ export function resolveTranscriptCitations(text, references = []) {
     };
     let resolved = text;
     for (const [marker, reference] of byMarker) {
-        resolved = resolved.split(marker).join(linksFor(reference));
+        // No items to link is not permission to delete the sentence: fall back to
+        // whatever the marker was wrapping.
+        resolved = resolved.split(marker).join(linksFor(reference) || citationMarkerText(marker));
     }
-    // Anything still delimited had no reference to restore: strip it so private-use
-    // characters never reach a receipt.
-    return resolved.replace(CITATION_MARKER_PATTERN, "");
+    // Anything still delimited had no reference to restore. The delimiters must not
+    // reach a receipt, but the words between them still belong to the answer.
+    return resolved.replace(CITATION_MARKER_PATTERN, (marker) => citationMarkerText(marker));
 }
 export function deepResearchReportExpression(conversationId) {
     return `(async () => {

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.2",
+  "version": "0.36.4",
   "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) {