@youdie006/prodex 0.39.5 → 0.40.1

package/dist/blocker-report.js

@@ -0,0 +1,81 @@
+/**
+ * Rank what actually blocks consults, across every bridge root on the machine.
+ *
+ * Half of every consult here ends in a blocker, and until now asking WHICH
+ * failure dominates meant writing a throwaway script: `pro list` reads a single
+ * repo, and the registry that knows where the others are had no reader. Pure
+ * on purpose - the reading lives in the command, so the ranking can be tested
+ * without a filesystem.
+ */
+/**
+ * Codes that describe how a send died rather than why. Counting these whole
+ * reports "the catch-all is biggest" and names nothing to fix - measured, one
+ * of them held 165 of 267 blockers - so their message decides the group.
+ */
+const CATCH_ALL_CODES = new Set(["browser_send_failed", "consult_failed", "unknown_error"]);
+/**
+ * The part of a message that identifies the failure, with the varying parts
+ * removed: the same picker failure is written once with "Pro" and once with a
+ * model name, and those are one cause, not two.
+ */
+export function blockerCause(message) {
+    const firstSentence = /^(.*?)(?:\.\s|\.$|$)/.exec(message.trim())?.[1] ?? message.trim();
+    return firstSentence
+        .replace(/"[^"]*"/g, '"..."')
+        .replace(/\d+/g, "N")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function groupKey(code, message) {
+    if (!CATCH_ALL_CODES.has(code))
+        return code;
+    const cause = blockerCause(message);
+    return cause ? `${code}: ${cause}` : code;
+}
+export function buildBlockerReport(input) {
+    const cutoff = input.since ? Date.parse(input.since) : undefined;
+    const inWindow = input.consults.filter((c) => {
+        if (cutoff === undefined)
+            return true;
+        if (!c.createdAt)
+            return false;
+        const at = Date.parse(c.createdAt);
+        return Number.isFinite(at) && at >= cutoff;
+    });
+    const groups = new Map();
+    let blocked = 0;
+    for (const consult of inWindow) {
+        if (!consult.blocker)
+            continue;
+        blocked += 1;
+        const key = groupKey(consult.blocker.code, consult.blocker.message);
+        const at = consult.createdAt ?? "";
+        const existing = groups.get(key);
+        if (existing) {
+            existing.count += 1;
+            if (at > existing.lastSeen)
+                existing.lastSeen = at;
+            existing.repos.set(consult.repo, (existing.repos.get(consult.repo) ?? 0) + 1);
+        }
+        else {
+            groups.set(key, {
+                count: 1,
+                lastSeen: at,
+                example: consult.blocker.message,
+                repos: new Map([[consult.repo, 1]])
+            });
+        }
+    }
+    const ranked = [...groups.entries()]
+        .sort((a, b) => b[1].count - a[1].count || a[0].localeCompare(b[0]))
+        .slice(0, input.limit ?? Number.POSITIVE_INFINITY)
+        .map(([code, g]) => ({
+        code,
+        count: g.count,
+        share: blocked > 0 ? g.count / blocked : 0,
+        lastSeen: g.lastSeen,
+        example: g.example,
+        repos: [...g.repos.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([repo]) => repo)
+    }));
+    return { totalConsults: inWindow.length, blocked, roots: input.roots, groups: ranked };
+}

package/dist/chatgpt-browser.js

@@ -1602,6 +1602,18 @@ async function reloadPageAndAwaitComposer(page) {
         cdp.close();
     }
 }
+/**
+ * The project a ChatGPT URL belongs to, as its `g-p-<id>` segment.
+ *
+ * The rebind check used to compare whole URLs, which also carry mode in a
+ * query string - and mode is exactly what differs across the reload this
+ * failure showed up in. Identity is the thing the check actually cares about:
+ * that the composer came back bound to THIS project rather than the one the
+ * tab came from.
+ */
+export function projectIdentity(url) {
+    return /\/g\/(g-p-[^/?#]+)/.exec(url)?.[1];
+}
 export function powerSliderPresentExpression() {
     return `Boolean(document.querySelector('[data-testid="composer-intelligence-picker-content"] [role="slider"]'))`;
 }
@@ -2524,12 +2536,25 @@ async function selectProject(cdp, options) {
         // prompt posted into the project the tab came from). A hard reload of the
         // project home rebinds the composer to THIS project before we send.
         const projectHome = await cdp.evaluate("location.href");
+        const home = projectIdentity(projectHome);
         // Polled with no delay, the first check could run before the reload had
         // committed, on the old document, whose composer and URL both still
         // matched. The stamp keeps that document from passing as the new one.
-        const rebound = await reloadAndAwaitComposer(cdp, RELOAD_SETTLE_TIMEOUT_MS, `location.href === ${JSON.stringify(projectHome)}`);
+        //
+        // Identity, not the whole URL: the href also carries mode in a query
+        // string, and comparing it byte-for-byte failed a reload that had landed
+        // exactly where it was asked to.
+        const rebound = await reloadAndAwaitComposer(cdp, RELOAD_SETTLE_TIMEOUT_MS, home ? `/\\/g\\/${home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![^/?#])/.test(location.href)` : "true");
         if (!rebound) {
-            throw new Error(`ChatGPT composer did not rebind after entering project "${options.project}"`);
+            // Say what it saw. This failure is rare and was previously reported as
+            // four words, which named neither the cause nor anything to try.
+            const landed = await cdp.evaluate("location.href").catch(() => "unknown");
+            const hasComposer = await cdp
+                .evaluate(`Boolean(document.querySelector('#prompt-textarea,[contenteditable="true"],textarea'))`)
+                .catch(() => false);
+            throw new Error(`ChatGPT composer did not rebind after entering project "${options.project}": after reloading, the tab was on ` +
+                `${projectIdentity(landed) ?? "no project"} (expected ${home ?? "that project"}) and the composer was ` +
+                `${hasComposer ? "present but the page never settled" : "still missing"}.`);
         }
     }
     const composerReady = await waitForExpressionTrue(cdp, `Boolean(document.querySelector('#prompt-textarea,[contenteditable="true"],textarea'))`, PROJECT_NAVIGATION_TIMEOUT_MS);

package/dist/cli-help.js

@@ -28,6 +28,7 @@ Ask / consult commands:
   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] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|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 blockers [--cwd /absolute/path/to/repo] [--since 7d] [--limit 10] [--json]  # what actually blocks consults, ranked, across every bridge root on this machine
   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
@@ -171,6 +172,7 @@ Commands:
   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] [--temporary] [--allow-model-fallback] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"|Max|Ultra|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 blockers [--cwd /absolute/path/to/repo] [--since 7d] [--limit 10] [--json]  # what actually blocks consults, ranked, across every bridge root on this machine
   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

package/dist/cli-pro.js

@@ -10,6 +10,8 @@ import { formatBrowserDefaults, redactServerUrl } from "./cli-server.js";
 import { errorMessage, firstLine, formatBlockedConsultRecordedMessage, formatProLatestCommand, formatBrowserCheckCommand, formatBrowserLoginCommand, formatBrowserSmokeCommand, formatBrowserTargetAskCommand, formatInitCommand, formatSetupCommand, isMissingFileError, computeSendPacingWaitMs, isUntrustedResultError, resolveMinSendIntervalMs, sourceAwareBrowserBlocker, sourceAwareBrowserNextStep, sourceAwareResultError, sourceAwareResultMessage, sourceAwareSetupMessage } from "./cli-shared.js";
 import { getTokenExpiryStatus, loadBrowserDefaults, loadLocalConfig } from "./config.js";
 import { withBrowserSendLock } from "./browser-send-lock.js";
+import { blockerCause, buildBlockerReport } from "./blocker-report.js";
+import { readBridgeRoots } from "./registry.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";
@@ -732,6 +734,50 @@ export async function runProCommand(rest, io, runCliFn) {
         // a two-hop dead end that made an agent abandon the diagnosis.
         throw new Error(`Use \`prodex pro browser ${legacyBrowserSubcommandReplacement(subcommand)}\` for explicit browser automation.`);
     }
+    if (subcommand === "blockers") {
+        if (printHelpIfRequested(proArgs, "pro blockers", io.stdout, printProHelp, { valueFlags: ["--cwd", "--since", "--limit"] }))
+            return 0;
+        assertOnlyOptions(proArgs, "pro blockers", ["--cwd", "--since", "--limit"], ["--json"]);
+        const scopedToOneRepo = readFlag(proArgs, "--cwd") !== undefined;
+        // Default to every bridge root: the failures are spread across the repos
+        // consults were run from, and `pro list` already covers just this one.
+        const roots = scopedToOneRepo ? [resolveCwdFlag(io.cwd, proArgs)] : await readBridgeRoots();
+        const since = readSinceFlag(proArgs);
+        const limit = readPositiveIntegerFlag(proArgs, "--limit") ?? 10;
+        const consults = [];
+        let readable = 0;
+        for (const root of roots) {
+            try {
+                const results = await new BridgeStore(root).listResultsReadOnly();
+                readable += 1;
+                for (const result of results) {
+                    if (!result.task_id.includes("gpt-pro-consult"))
+                        continue;
+                    consults.push({
+                        repo: path.basename(root),
+                        createdAt: result.created_at,
+                        ...(result.blocker ? { blocker: { code: result.blocker.code, message: result.blocker.message } } : {})
+                    });
+                }
+            }
+            catch {
+                // A root that has been deleted or is unreadable is not a failure of
+                // the report; it just has nothing to contribute.
+            }
+        }
+        const report = buildBlockerReport({
+            consults,
+            roots: readable,
+            ...(since ? { since } : {}),
+            limit
+        });
+        if (proArgs.includes("--json")) {
+            io.stdout(JSON.stringify(report, null, 2));
+            return 0;
+        }
+        io.stdout(formatBlockerReport(report, { since, scopedToOneRepo }));
+        return 0;
+    }
     if (subcommand === "list") {
         if (printHelpIfRequested(proArgs, "pro list", io.stdout, printProHelp, { valueFlags: ["--cwd", "--source-cli"] }))
             return 0;
@@ -879,7 +925,7 @@ export async function runProCommand(rest, io, runCliFn) {
         io.stdout(formatDebatePrompt({ topic: readFlag(proArgs, "--topic"), rounds, sourceCli }));
         return 0;
     }
-    throw unknownSubcommandError("pro", subcommand, ["ask", "browser", "debate-prompt", "list", "latest", "show"]);
+    throw unknownSubcommandError("pro", subcommand, ["ask", "blockers", "browser", "debate-prompt", "list", "latest", "show"]);
 }
 export async function runConsultsCommand(rest, io) {
     throw new Error("The legacy `consults` alias is retired. Use `prodex pro list`, `prodex pro latest`, or `prodex pro show <task-id|latest>`.");
@@ -1064,6 +1110,12 @@ export async function runAskProCommand(rest, io) {
     // Requiring --new-chat keeps that explicit rather than quietly turning a
     // continuation into a throwaway.
     const temporary = parsedAskPro.optionArgs.includes("--temporary");
+    const temporaryConflict = temporaryProjectConflict({
+        temporary,
+        ...(explicitProject !== undefined ? { explicitProject } : {})
+    });
+    if (temporaryConflict)
+        throw new Error(temporaryConflict);
     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.");
     }
@@ -1095,9 +1147,17 @@ export async function runAskProCommand(rest, io) {
     // fresh chat inside the project is exactly what "--new-chat + project"
     // produces, and the whole point of pinning a default project is that
     // consults stop landing in the general chat list. Only --target-url
-    // (pinned tab) and --project-new suppress it.
+    // (pinned tab), --project-new, and --temporary suppress it.
+    //
+    // --temporary suppresses rather than conflicts: a pinned project must not
+    // turn every throwaway send into an error, and attempting both is what
+    // produced "composer did not rebind after entering project" - a temporary
+    // chat is never saved, a project chat is, and entering a project leaves
+    // temporary mode.
     const selectionProject = explicitProject ??
-        (normalizedTargetUrl || selectionProjectNew !== undefined || suppressProject ? undefined : browserDefaults?.project);
+        (normalizedTargetUrl || selectionProjectNew !== undefined || suppressProject || temporary
+            ? undefined
+            : browserDefaults?.project);
     const reasoningAxisChosen = explicitProMode !== undefined || explicitEffort !== undefined;
     const selectionProMode = explicitProMode ?? (reasoningAxisChosen ? undefined : browserDefaults?.pro_mode);
     const selectionEffort = explicitEffort ?? (reasoningAxisChosen ? undefined : browserDefaults?.effort);
@@ -1750,6 +1810,19 @@ export function proSelectionVerified(selection) {
         return undefined;
     return /pro/i.test(selection.modelSlug);
 }
+/**
+ * A temporary chat is not saved; a project chat is. Entering a project leaves
+ * temporary mode, so asking for both is asking for two different things, and
+ * prodex used to attempt both and die inside the project step with "composer
+ * did not rebind". A pinned default project is suppressed instead of refused:
+ * the per-call flag is the more specific instruction.
+ */
+export function temporaryProjectConflict(input) {
+    if (!input.temporary || input.explicitProject === undefined)
+        return undefined;
+    return (`--temporary and --project cannot be combined: a temporary chat is never saved, and a chat inside a project is. ` +
+        `Drop --temporary to send into "${input.explicitProject}", or drop --project to send a throwaway chat.`);
+}
 export function browserSendBlockerFromError(error) {
     const blocker = typeof error === "object" && error !== null && "blocker" in error ? error.blocker : undefined;
     if (typeof blocker === "object" &&
@@ -1934,6 +2007,63 @@ export function formatProConsultArtifact(consult) {
     lines.push("## Answer", "", consult.answer.trim(), "");
     return lines.join("\n");
 }
+/**
+ * `--since 7d`, `--since 24h`, or a plain date. A window is how you ask whether
+ * a fix landed, so it has to be quick to type.
+ */
+export function readSinceFlag(args) {
+    const raw = readFlag(args, "--since");
+    if (raw === undefined)
+        return undefined;
+    const relative = /^(\d+)\s*([dh])$/i.exec(raw.trim());
+    if (relative) {
+        const amount = Number(relative[1]);
+        const hours = relative[2]?.toLowerCase() === "d" ? amount * 24 : amount;
+        return new Date(Date.now() - hours * 3_600_000).toISOString();
+    }
+    const parsed = Date.parse(raw);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`--since expects a date or an age like 7d or 24h, not "${raw}".`);
+    }
+    return new Date(parsed).toISOString();
+}
+/** The ranked report as a table, widest column first so the counts line up. */
+export function formatBlockerReport(report, options = {}) {
+    const scope = options.scopedToOneRepo ? "this repo" : `${report.roots} bridge root${report.roots === 1 ? "" : "s"}`;
+    const window = options.since ? ` since ${options.since.slice(0, 10)}` : "";
+    if (report.totalConsults === 0) {
+        return `No consults recorded in ${scope}${window}.`;
+    }
+    const share = report.totalConsults > 0 ? Math.round((report.blocked / report.totalConsults) * 100) : 0;
+    const head = `Consult blockers: ${report.blocked} of ${report.totalConsults} consults (${share}%) across ${scope}${window}`;
+    if (report.groups.length === 0)
+        return `${head}\n\nNothing was blocked.`;
+    // A split catch-all carries the first sentence in its own name, so the
+    // example would repeat it; only a bare code needs one.
+    const clip = (text, max) => (text.length > max ? `${text.slice(0, max - 1)}\u2026` : text);
+    const rows = report.groups.map((group) => {
+        const example = group.example.replace(/\s+/g, " ").trim();
+        // Compare through the same normalisation the cause went through: the code
+        // says `has no "..." step` where the message says `has no "Pro" step`.
+        const causePart = group.code.includes(": ") ? group.code.split(": ").slice(1).join(": ") : undefined;
+        const redundant = causePart !== undefined && blockerCause(example) === causePart;
+        return {
+            count: String(group.count),
+            share: `${Math.round(group.share * 100)}%`,
+            code: clip(group.code, 58),
+            lastSeen: group.lastSeen ? group.lastSeen.slice(0, 10) : "-",
+            example: redundant ? "" : clip(example, 58)
+        };
+    });
+    const width = (pick, header) => Math.max(header.length, ...rows.map((row) => pick(row).length));
+    const wCount = width((r) => r.count, "COUNT");
+    const wShare = width((r) => r.share, "SHARE");
+    const wCode = width((r) => r.code, "CAUSE");
+    const wLast = width((r) => r.lastSeen, "LAST SEEN");
+    const line = (count, sharePct, code, lastSeen, example) => `  ${count.padStart(wCount)}  ${sharePct.padStart(wShare)}  ${code.padEnd(wCode)}  ${lastSeen.padEnd(wLast)}  ${example}`;
+    const body = rows.map((row) => line(row.count, row.share, row.code, row.lastSeen, row.example).trimEnd());
+    return [head, "", line("COUNT", "SHARE", "CAUSE", "LAST SEEN", "EXAMPLE"), ...body].join("\n");
+}
 export function formatProListSummary(consult, sourceCli, options = {}) {
     const blocker = sourceAwareProAnswerBlocker(consult, sourceCli, options);
     return firstLine(sourceAwareProAnswerSummary(consult.result.summary, consult.result.blocker, blocker));

package/dist/registry.js

@@ -44,6 +44,38 @@ async function directoryExists(dir) {
         return false;
     }
 }
+/**
+ * Every bridge root this machine knows about. The registry has only ever been
+ * written; reading it is what lets a report span the repos where the failures
+ * actually are, instead of the one the command happens to run in.
+ *
+ * Advisory like the rest of the registry: a missing or corrupt file is an
+ * empty list, not an error, and roots that have since been deleted are
+ * dropped rather than reported.
+ */
+export async function readBridgeRoots() {
+    let parsed;
+    try {
+        parsed = JSON.parse(await fs.readFile(bridgesRegistryPath(), "utf8"));
+    }
+    catch {
+        return [];
+    }
+    const raw = parsed?.roots;
+    if (!Array.isArray(raw))
+        return [];
+    const roots = [];
+    for (const entry of raw.slice(0, MAX_REGISTRY_ROOTS)) {
+        const value = typeof entry === "string" ? entry : entry?.path;
+        if (typeof value !== "string" || value.length === 0)
+            continue;
+        if (!(await directoryExists(path.join(value, ".bridge"))))
+            continue;
+        if (!roots.includes(value))
+            roots.push(value);
+    }
+    return roots;
+}
 export function registerBridgeRoot(root) {
     const next = registryQueue.then(() => registerBridgeRootInner(root));
     // Keep the chain alive even if an inner registration rejects.

package/package.json

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