@deftai/directive-core 0.106.0 → 0.108.0

package/dist/review-monitor/lease-comment.d.ts

@@ -1,3 +1,4 @@
+import { PASS_MARKER_KIND } from "./constants.js";
 import type { PlatformPrimitive } from "./tier-detection.js";
 export declare function parseIso8601Utc(value: string): Date | null;
 export interface ReviewOwnerLease {
@@ -33,4 +34,39 @@ export declare function findActiveLeaseComment(comments: readonly ReviewOwnerCom
     now?: Date;
     headSha?: string | null;
 }): ReviewOwnerComment | null;
+/**
+ * Advisory pass-open mark on an issue thread (#3607).
+ *
+ * Observe-and-mark only: it records that a pass is open, who owns it, the declared
+ * ceiling comment, and when the mark expires. It never holds, blocks, or gates
+ * another actor's write -- an arriving agent reads it and decides for itself.
+ */
+export interface PassOpenMarker {
+    readonly kind: typeof PASS_MARKER_KIND;
+    readonly pass_kind: string;
+    readonly owner: string;
+    readonly agent_id: string | null;
+    readonly ceiling: string | null;
+    readonly started_at: string;
+    readonly expires_at: string;
+    readonly ended_at: string | null;
+}
+export interface PassOpenComment {
+    readonly id: number;
+    readonly body: string;
+    readonly createdAt: string;
+    /** GitHub login that authored the comment; "" when the source did not report one. */
+    readonly authorLogin: string;
+    readonly marker: PassOpenMarker | null;
+}
+export declare function parsePassOpenMarker(body: string): PassOpenMarker | null;
+export declare function renderPassOpenComment(marker: PassOpenMarker): string;
+/** Expired or synthesis-cleared marks are ignored on read; a mark self-clears (#3607). */
+export declare function isPassMarkerActive(marker: PassOpenMarker, now?: Date): boolean;
+export declare function mapPassCommentEntry(entry: unknown): PassOpenComment | null;
+/** Oldest comment id wins when two marks race, matching the lease (#2814 / #3607). */
+export declare function selectWinningPassComment(comments: readonly PassOpenComment[]): PassOpenComment | null;
+export declare function findActivePassComment(comments: readonly PassOpenComment[], options?: {
+    now?: Date;
+}): PassOpenComment | null;
 //# sourceMappingURL=lease-comment.d.ts.map

package/dist/review-monitor/lease-comment.js

@@ -1,4 +1,4 @@
-import { DEFAULT_STALE_MINUTES, REVIEW_OWNER_MARKER_END, REVIEW_OWNER_MARKER_START, } from "./constants.js";
+import { DEFAULT_STALE_MINUTES, PASS_MARKER_KIND, REVIEW_OWNER_MARKER_END, REVIEW_OWNER_MARKER_START, } from "./constants.js";
 export function parseIso8601Utc(value) {
     if (typeof value !== "string" || value.length === 0) {
         return null;
@@ -17,7 +17,7 @@ export function parseIso8601Utc(value) {
     }
     return parsed;
 }
-const FIELD_RE = /^(owner|monitor_agent_id|head_sha|started_at|expires_at|platform_primitive|ended_at):\s*(.*)$/;
+const FIELD_RE = /^(kind|owner|monitor_agent_id|agent_id|pass_kind|ceiling|head_sha|started_at|expires_at|platform_primitive|ended_at):\s*(.*)$/;
 /** True when the comment body contains the review-owner marker block. */
 export function hasReviewOwnerMarker(body) {
     return body.includes(REVIEW_OWNER_MARKER_START);
@@ -42,8 +42,17 @@ function parseFieldBlock(body) {
     }
     return fields;
 }
+/** Marker `kind:` value, or "" when the block declares none (ownership-lease shape). */
+function markerKind(body) {
+    return parseFieldBlock(body).kind ?? "";
+}
 export function parseReviewOwnerLease(body) {
     const fields = parseFieldBlock(body);
+    // An advisory pass mark shares the marker but must never satisfy the
+    // review-monitor ownership gate (#3607).
+    if ((fields.kind ?? "") === PASS_MARKER_KIND) {
+        return null;
+    }
     const owner = fields.owner ?? "";
     const monitorAgentId = fields.monitor_agent_id ?? "";
     const startedAt = fields.started_at ?? "";
@@ -128,6 +137,11 @@ export function mapCommentEntry(entry) {
     if (!hasReviewOwnerMarker(rec.body)) {
         return null;
     }
+    // Pass marks are a disjoint population on the same marker; excluding them here
+    // keeps `registerReviewMonitor` from overwriting one as its lease anchor (#3607).
+    if (markerKind(rec.body) === PASS_MARKER_KIND) {
+        return null;
+    }
     return {
         id: rec.id,
         body: rec.body,
@@ -149,4 +163,91 @@ export function findActiveLeaseComment(comments, options = {}) {
     }
     return selectWinningReviewOwnerComment(active);
 }
+export function parsePassOpenMarker(body) {
+    if (!hasReviewOwnerMarker(body)) {
+        return null;
+    }
+    const fields = parseFieldBlock(body);
+    if ((fields.kind ?? "") !== PASS_MARKER_KIND) {
+        return null;
+    }
+    const owner = fields.owner ?? "";
+    const passKind = fields.pass_kind ?? "";
+    const startedAt = fields.started_at ?? "";
+    const expiresAt = fields.expires_at ?? "";
+    if (owner.length === 0 ||
+        passKind.length === 0 ||
+        startedAt.length === 0 ||
+        expiresAt.length === 0) {
+        return null;
+    }
+    const agentId = fields.agent_id ?? "";
+    const ceiling = fields.ceiling ?? "";
+    const endedAt = fields.ended_at ?? "";
+    return {
+        kind: PASS_MARKER_KIND,
+        pass_kind: passKind,
+        owner,
+        agent_id: agentId.length > 0 ? agentId : null,
+        ceiling: ceiling.length > 0 ? ceiling : null,
+        started_at: startedAt,
+        expires_at: expiresAt,
+        ended_at: endedAt.length > 0 ? endedAt : null,
+    };
+}
+export function renderPassOpenComment(marker) {
+    const optional = (name, value) => value !== null && value.length > 0 ? `${name}: ${value}\n` : "";
+    return (`${REVIEW_OWNER_MARKER_START}\n` +
+        `kind: ${PASS_MARKER_KIND}\n` +
+        `pass_kind: ${marker.pass_kind}\n` +
+        `owner: ${marker.owner}\n` +
+        optional("agent_id", marker.agent_id) +
+        optional("ceiling", marker.ceiling) +
+        `started_at: ${marker.started_at}\n` +
+        `expires_at: ${marker.expires_at}\n` +
+        optional("ended_at", marker.ended_at) +
+        `${REVIEW_OWNER_MARKER_END}`);
+}
+/** Expired or synthesis-cleared marks are ignored on read; a mark self-clears (#3607). */
+export function isPassMarkerActive(marker, now = new Date()) {
+    if (marker.ended_at !== null) {
+        return false;
+    }
+    const expires = parseIso8601Utc(marker.expires_at);
+    if (expires === null) {
+        return false;
+    }
+    return now.getTime() <= expires.getTime();
+}
+export function mapPassCommentEntry(entry) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        return null;
+    }
+    const rec = entry;
+    if (typeof rec.id !== "number" || typeof rec.body !== "string") {
+        return null;
+    }
+    const marker = parsePassOpenMarker(rec.body);
+    if (marker === null) {
+        return null;
+    }
+    return {
+        id: rec.id,
+        body: rec.body,
+        createdAt: typeof rec.created_at === "string" ? rec.created_at : "",
+        authorLogin: typeof rec.author_login === "string" ? rec.author_login : "",
+        marker,
+    };
+}
+/** Oldest comment id wins when two marks race, matching the lease (#2814 / #3607). */
+export function selectWinningPassComment(comments) {
+    if (comments.length === 0) {
+        return null;
+    }
+    return [...comments].sort((a, b) => a.id - b.id)[0] ?? null;
+}
+export function findActivePassComment(comments, options = {}) {
+    const active = comments.filter((comment) => comment.marker !== null && isPassMarkerActive(comment.marker, options.now));
+    return selectWinningPassComment(active);
+}
 //# sourceMappingURL=lease-comment.js.map

package/dist/scm/call.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { resolveCaptureFailureStderr, SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 import { resolveBinary } from "./binary.js";
 import { SUPPORTED_CALL_SOURCES } from "./constants.js";
 import { pyRepr } from "./py-format.js";
@@ -26,18 +27,26 @@ export function call(source, verb, args = null, options = {}) {
         input: options.input,
         encoding: (options.text ?? true) ? "utf8" : undefined,
         timeout: timeoutMs,
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
         stdio: captureOutput ? ["pipe", "pipe", "pipe"] : "inherit",
     });
+    // A spawn-level failure (ENOBUFS past maxBuffer, timeout kill) yields a null
+    // status and empty stderr; surface error.message so callers never report a
+    // bare exit 1 with no reason (#1867 / #3903).
+    const stderr = resolveCaptureFailureStderr({
+        captured: typeof result.stderr === "string" ? result.stderr : "",
+        status: result.status,
+        message: result.error?.message,
+    });
     if (options.check && result.status !== 0) {
-        const message = typeof result.stderr === "string" ? result.stderr : "";
-        const error = new Error(message || `Process exited with code ${result.status}`);
+        const error = new Error(stderr || `Process exited with code ${result.status}`);
         throw error;
     }
     return {
         args: argv,
         returncode: result.status ?? 1,
         stdout: typeof result.stdout === "string" ? result.stdout : "",
-        stderr: typeof result.stderr === "string" ? result.stderr : "",
+        stderr,
     };
 }
 //# sourceMappingURL=call.js.map

package/dist/scm/design-critique-chip.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Chip-only remaining-set write for design-critique catalog labels (#3642).
+ *
+ * Parent attach of triage-ready / recut mechanism-shaped MUST use this verb,
+ * not `gh api POST .../labels` and not additive `scm:issue:edit --add-label`.
+ */
+import { type DesignCritiqueCatalogChip } from "../design-critique/exclusive-chip.js";
+import type { LabelClient } from "../vbrief-reconcile/types.js";
+export declare const DESIGN_CRITIQUE_CHIP_VERB: "design-critique-chip";
+export declare const CHIP_APPLY_MISS_TOKEN = "chip apply missed (non-blocking convenience)";
+export declare const DESIGN_CRITIQUE_CHIP_USAGE: string;
+export interface DesignCritiqueChipArgs {
+    readonly issue: number;
+    readonly chip: DesignCritiqueCatalogChip;
+    readonly repo: string | null;
+    readonly json: boolean;
+}
+export interface DesignCritiqueChipSeams {
+    readonly client?: LabelClient;
+    /** Default OWNER/NAME when --repo is omitted (git origin). */
+    readonly resolveDefaultRepo?: () => string | null;
+}
+export interface DesignCritiqueChipResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Fail-closed chip name. Closed catalog only. */
+export declare function resolveDesignCritiqueChipArg(raw: string): DesignCritiqueCatalogChip;
+export declare function parseDesignCritiqueChipArgs(extra: readonly string[]): DesignCritiqueChipArgs;
+/** Resolve OWNER/NAME from `git remote get-url origin`. */
+export declare function resolveRepoFromGitOrigin(): string | null;
+/**
+ * GET current labels, remaining-set replace via applyDesignCritiqueCatalogChip.
+ * One LabelClient.apply write. Other facets stay.
+ */
+export declare function runDesignCritiqueChip(extra: readonly string[], seams?: DesignCritiqueChipSeams): DesignCritiqueChipResult;
+//# sourceMappingURL=design-critique-chip.d.ts.map

package/dist/scm/design-critique-chip.js

@@ -0,0 +1,187 @@
+/**
+ * Chip-only remaining-set write for design-critique catalog labels (#3642).
+ *
+ * Parent attach of triage-ready / recut mechanism-shaped MUST use this verb,
+ * not `gh api POST .../labels` and not additive `scm:issue:edit --add-label`.
+ */
+import { spawnSync } from "node:child_process";
+import { applyDesignCritiqueCatalogChip, } from "../design-critique/exclusive-chip.js";
+import { parseGithubOwnerRepo } from "../policy/sync-default.js";
+import { ScmLabelClient } from "../vbrief-reconcile/labels.js";
+import { extractFlag, extractValueFlag } from "./argv.js";
+import { InvalidRepoError, splitRepo } from "./gh-rest.js";
+import { pyRepr } from "./py-format.js";
+export const DESIGN_CRITIQUE_CHIP_VERB = "design-critique-chip";
+export const CHIP_APPLY_MISS_TOKEN = "chip apply missed (non-blocking convenience)";
+export const DESIGN_CRITIQUE_CHIP_USAGE = "usage: scm issue design-critique-chip --issue N --chip triage-ready|mechanism-shaped [--repo OWNER/NAME] [--json]\n" +
+    "       Parent attach of design-critique:triage-ready / recut mechanism-shaped.\n" +
+    "       Closed catalog remaining-set replace. One write. Other facets stay.\n" +
+    "       Apply miss is non-blocking convenience; ingest is not blocked.\n";
+const CHIP_ALIASES = {
+    "triage-ready": "design-critique:triage-ready",
+    "mechanism-shaped": "design-critique:mechanism-shaped",
+    "design-critique:triage-ready": "design-critique:triage-ready",
+    "design-critique:mechanism-shaped": "design-critique:mechanism-shaped",
+};
+/** Fail-closed chip name. Closed catalog only. */
+export function resolveDesignCritiqueChipArg(raw) {
+    const chip = CHIP_ALIASES[raw];
+    if (chip === undefined) {
+        throw new Error(`unknown design-critique chip ${pyRepr(raw)}; expected triage-ready|mechanism-shaped ` +
+            "(or design-critique:triage-ready|design-critique:mechanism-shaped)");
+    }
+    return chip;
+}
+function parseIssueNumber(raw, source) {
+    const issueN = Number.parseInt(raw, 10);
+    if (Number.isNaN(issueN) || issueN <= 0 || String(issueN) !== raw) {
+        throw new Error(`${source} must be a positive integer; got ${pyRepr(raw)}`);
+    }
+    return issueN;
+}
+export function parseDesignCritiqueChipArgs(extra) {
+    let remainder = [...extra];
+    const [help] = extractFlag(remainder, "--help");
+    const [helpShort] = extractFlag(remainder, "-h");
+    if (help || helpShort) {
+        throw new ChipUsageError(DESIGN_CRITIQUE_CHIP_USAGE.trimEnd());
+    }
+    const [json, afterJson] = extractFlag(remainder, "--json");
+    remainder = afterJson;
+    const [repoRaw, afterRepo] = extractValueFlag(remainder, "--repo");
+    remainder = afterRepo;
+    const [chipRaw, afterChip] = extractValueFlag(remainder, "--chip");
+    remainder = afterChip;
+    const [issueFlag, afterIssue] = extractValueFlag(remainder, "--issue");
+    remainder = afterIssue;
+    const leftoverFlags = remainder.filter((t) => t.startsWith("-"));
+    if (leftoverFlags.length > 0) {
+        throw new Error(`unrecognized flags: ${pyRepr(leftoverFlags)}. Supported: --issue, --chip, --repo, --json.`);
+    }
+    const positionals = remainder.filter((t) => !t.startsWith("-"));
+    if (chipRaw === null || chipRaw.length === 0) {
+        throw new Error("missing --chip triage-ready|mechanism-shaped");
+    }
+    const chip = resolveDesignCritiqueChipArg(chipRaw);
+    let issueRaw = issueFlag;
+    if (positionals.length > 1) {
+        throw new Error(`expected at most one positional issue number; got ${pyRepr(positionals)}`);
+    }
+    if (positionals.length === 1) {
+        const positional = positionals[0] ?? "";
+        if (issueRaw !== null && issueRaw !== positional) {
+            throw new Error(`--issue ${pyRepr(issueRaw)} conflicts with positional ${pyRepr(positional)}`);
+        }
+        issueRaw = positional;
+    }
+    if (issueRaw === null || issueRaw.length === 0) {
+        throw new Error("missing --issue N");
+    }
+    const issue = parseIssueNumber(issueRaw, "--issue");
+    if (repoRaw !== null && repoRaw.length > 0) {
+        splitRepo(repoRaw);
+    }
+    return { issue, chip, repo: repoRaw !== null && repoRaw.length > 0 ? repoRaw : null, json };
+}
+/** Resolve OWNER/NAME from `git remote get-url origin`. */
+export function resolveRepoFromGitOrigin() {
+    const result = spawnSync("git", ["remote", "get-url", "origin"], {
+        encoding: "utf8",
+        env: process.env,
+    });
+    if (result.status !== 0)
+        return null;
+    const stdout = typeof result.stdout === "string" ? result.stdout : "";
+    return parseGithubOwnerRepo(stdout);
+}
+class ChipUsageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ChipUsageError";
+    }
+}
+/**
+ * GET current labels, remaining-set replace via applyDesignCritiqueCatalogChip.
+ * One LabelClient.apply write. Other facets stay.
+ */
+export function runDesignCritiqueChip(extra, seams = {}) {
+    let args;
+    try {
+        args = parseDesignCritiqueChipArgs(extra);
+    }
+    catch (err) {
+        if (err instanceof ChipUsageError) {
+            return { exitCode: 0, stdout: `${err.message}\n`, stderr: "" };
+        }
+        if (err instanceof InvalidRepoError) {
+            return { exitCode: 2, stdout: "", stderr: `error: invalid --repo value: ${err.message}\n` };
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return { exitCode: 2, stdout: "", stderr: `error: ${message}\n` };
+    }
+    const repo = args.repo ?? (seams.resolveDefaultRepo ?? resolveRepoFromGitOrigin)();
+    if (repo === null || repo.length === 0) {
+        return {
+            exitCode: 2,
+            stdout: "",
+            stderr: "error: missing --repo OWNER/NAME (could not resolve from git origin)\n",
+        };
+    }
+    try {
+        splitRepo(repo);
+    }
+    catch (err) {
+        if (err instanceof InvalidRepoError) {
+            return { exitCode: 2, stdout: "", stderr: `error: invalid --repo value: ${err.message}\n` };
+        }
+        throw err;
+    }
+    const client = seams.client ?? new ScmLabelClient();
+    try {
+        const applied = applyDesignCritiqueCatalogChip(client, repo, args.issue, args.chip);
+        const payload = {
+            repo,
+            issue: args.issue,
+            chip: args.chip,
+            add: [...applied.add],
+            remove: [...applied.remove],
+            remaining: [...applied.remaining],
+        };
+        if (args.json) {
+            return { exitCode: 0, stdout: `${JSON.stringify(payload)}\n`, stderr: "" };
+        }
+        const wrote = applied.add.length > 0 || applied.remove.length > 0;
+        const detail = applied.remove.length > 0
+            ? `removed ${applied.remove.join(", ")}`
+            : wrote
+                ? "added"
+                : "already exclusive";
+        return {
+            exitCode: 0,
+            stdout: `${wrote ? "applied" : "unchanged"} ${args.chip} on ${repo}#${args.issue} (${detail})\n`,
+            stderr: "",
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const payload = {
+            repo,
+            issue: args.issue,
+            chip: args.chip,
+            applied: false,
+            miss: true,
+            blocking: false,
+            error: message,
+        };
+        if (args.json) {
+            return { exitCode: 0, stdout: `${JSON.stringify(payload)}\n`, stderr: "" };
+        }
+        return {
+            exitCode: 0,
+            stdout: "",
+            stderr: `${CHIP_APPLY_MISS_TOKEN}: ${message}\n` +
+                "ingest is not blocked; remaining-set hygiene is optional for a write-capable identity\n",
+        };
+    }
+}
+//# sourceMappingURL=design-critique-chip.js.map

package/dist/scm/gh-rest.d.ts

@@ -53,7 +53,7 @@ export interface RestIssueListOptions {
 export declare function restIssueList(repo: string, options?: RestIssueListOptions, seams?: GhRestSeams): Record<string, unknown>[];
 export declare const REST_MAX_PER_PAGE = 100;
 export declare const REST_PAGINATION_MAX_PAGES = 100;
-export declare const PUBLIC_HELPERS: readonly ["restCreateIssue", "restPostComment", "restUpdateComment", "restDeleteComment", "restGetUser", "restUpdateIssue", "restCreateLabel", "restCloseIssue", "restOpenPr", "restMergePr", "restIssueView", "restPrView", "restIssueList", "restIssueListPaginated"];
+export declare const PUBLIC_HELPERS: readonly ["restCreateIssue", "restPostComment", "restUpdateComment", "restDeleteComment", "restGetUser", "restUpdateIssue", "restCreateLabel", "restCloseIssue", "restOpenPr", "restMergePr", "restIssueView", "restPrView", "restIssueList", "restIssueListPaginated", "restIssueListOpenInventory"];
 export declare function restCreateIssue(repo: string, title: string, body: string, labels?: readonly string[], seams?: GhRestSeams): Record<string, unknown>;
 export declare function restPostComment(repo: string, n: number, body: string, seams?: GhRestSeams): Record<string, unknown>;
 /** `PATCH /repos/{owner}/{repo}/issues/comments/{id}` -- edit a PR/issue comment in place. */
@@ -78,5 +78,13 @@ export interface RestIssueListPaginatedOptions extends RestIssueListOptions {
     readonly limit?: number | null;
     readonly excludePulls?: boolean;
 }
+/** Flatten `gh api --paginate --slurp` issue-list output (pages or single page). */
+export declare function flattenOpenInventoryPayload(parsed: unknown[], endpoint: string): Record<string, unknown>[];
+/**
+ * Complete open-issue inventory in one `gh api --paginate --slurp` subprocess (#3752).
+ * Fail-closed on command failure, non-array JSON, buffer exhaustion, or cap hit.
+ * Pull-request rows are excluded.
+ */
+export declare function restIssueListOpenInventory(repo: string, seams?: GhRestSeams): Record<string, unknown>[];
 export declare function restIssueListPaginated(repo: string, options?: RestIssueListPaginatedOptions, seams?: GhRestSeams): Record<string, unknown>[];
 //# sourceMappingURL=gh-rest.d.ts.map

package/dist/scm/gh-rest.js

@@ -183,6 +183,7 @@ export const PUBLIC_HELPERS = [
     "restPrView",
     "restIssueList",
     "restIssueListPaginated",
+    "restIssueListOpenInventory",
 ];
 function writeJsonPayload(payload) {
     const dir = mkdtempSync(join(tmpdir(), "gh_rest_payload_"));
@@ -331,6 +332,108 @@ export function restPrView(repo, n, seams = {}) {
         whichFn: seams.whichFn,
     });
 }
+const OPEN_INVENTORY_MAX_ISSUES = REST_PAGINATION_MAX_PAGES * REST_MAX_PER_PAGE;
+function issueRowOrThrow(item, endpoint) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+        throw new GhRestError({
+            stderr: "open-issue inventory row is not an object",
+            exitCode: 0,
+            endpoint,
+            payload: null,
+            hint: "REST issue list rows must be objects",
+        });
+    }
+    return item;
+}
+/** Flatten `gh api --paginate --slurp` issue-list output (pages or single page). */
+export function flattenOpenInventoryPayload(parsed, endpoint) {
+    if (parsed.length === 0) {
+        return [];
+    }
+    const out = [];
+    const allPages = parsed.every((item) => Array.isArray(item));
+    if (allPages) {
+        for (const page of parsed) {
+            if (!Array.isArray(page)) {
+                continue;
+            }
+            for (const item of page) {
+                const row = issueRowOrThrow(item, endpoint);
+                if ("pull_request" in row) {
+                    continue;
+                }
+                out.push(row);
+            }
+        }
+        return out;
+    }
+    for (const item of parsed) {
+        const row = issueRowOrThrow(item, endpoint);
+        if ("pull_request" in row) {
+            continue;
+        }
+        out.push(row);
+    }
+    return out;
+}
+/**
+ * Complete open-issue inventory in one `gh api --paginate --slurp` subprocess (#3752).
+ * Fail-closed on command failure, non-array JSON, buffer exhaustion, or cap hit.
+ * Pull-request rows are excluded.
+ */
+export function restIssueListOpenInventory(repo, seams = {}) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues?state=open&per_page=${REST_MAX_PER_PAGE}`;
+    const runner = seams.runGhApiFn ?? runGhApi;
+    const result = runner(["--paginate", "--slurp", endpoint], { timeout: 120 });
+    if (result.returncode !== 0) {
+        throw new GhRestError({
+            stderr: result.stderr.trim(),
+            exitCode: result.returncode,
+            endpoint,
+            payload: null,
+            hint: "verify gh auth and core REST quota; open-issue inventory must be complete",
+        });
+    }
+    const stdout = result.stdout.trim();
+    if (stdout.length === 0) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        throw new GhRestError({
+            stderr: `non-JSON open-issue inventory: ${message}`,
+            exitCode: 0,
+            endpoint,
+            payload: null,
+            hint: "gh api --paginate --slurp must return a JSON array",
+        });
+    }
+    if (!Array.isArray(parsed)) {
+        throw new GhRestError({
+            stderr: `unexpected top-level type ${typeof parsed}`,
+            exitCode: 0,
+            endpoint,
+            payload: null,
+            hint: "open-issue inventory must be a JSON array",
+        });
+    }
+    const out = flattenOpenInventoryPayload(parsed, endpoint);
+    if (out.length >= OPEN_INVENTORY_MAX_ISSUES) {
+        throw new GhRestError({
+            stderr: `open-issue inventory reached cap ${OPEN_INVENTORY_MAX_ISSUES}; pagination may be incomplete`,
+            exitCode: 0,
+            endpoint,
+            payload: null,
+            hint: "repo may exceed supported open-issue count; fail closed rather than truncate",
+        });
+    }
+    return out;
+}
 export function restIssueListPaginated(repo, options = {}, seams = {}) {
     const cappedPerPage = Math.min(Math.max(1, options.perPage ?? REST_MAX_PER_PAGE), REST_MAX_PER_PAGE);
     const [owner, name] = splitRepo(repo);

package/dist/scm/index.d.ts

@@ -3,6 +3,7 @@ export * from "./binary.js";
 export * from "./build-command.js";
 export * from "./call.js";
 export * from "./constants.js";
+export * from "./design-critique-chip.js";
 export * from "./errors.js";
 export * from "./gh-rest.js";
 export * from "./main.js";

package/dist/scm/index.js

@@ -3,6 +3,7 @@ export * from "./binary.js";
 export * from "./build-command.js";
 export * from "./call.js";
 export * from "./constants.js";
+export * from "./design-critique-chip.js";
 export * from "./errors.js";
 export * from "./gh-rest.js";
 export * from "./main.js";

package/dist/scm/main.d.ts

@@ -1,3 +1,4 @@
+import type { LabelClient } from "../vbrief-reconcile/types.js";
 import type { GhRestSeams } from "./gh-rest.js";
 export interface MainOptions {
     readonly whichFn?: Parameters<typeof import("./binary.js").resolveBinary>[0];
@@ -8,6 +9,8 @@ export interface MainOptions {
      * Production CLI always probes.
      */
     readonly skipReadiness?: boolean;
+    /** LabelClient seam for `issue design-critique-chip` (#3642). */
+    readonly labelClient?: LabelClient;
 }
 /**
  * CLI entry point. Returns the underlying binary's exit code (or 2 on arg error).

package/dist/scm/main.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import { extractFlag } from "./argv.js";
 import { buildCommand } from "./build-command.js";
 import { REST_OPT_IN_VERBS } from "./constants.js";
+import { DESIGN_CRITIQUE_CHIP_VERB, runDesignCritiqueChip } from "./design-critique-chip.js";
 import { ScmStubError } from "./errors.js";
 import { requireScmReady } from "./readiness.js";
 import { runRestList, runRestView } from "./rest-dispatch.js";
@@ -30,13 +31,26 @@ function guardScmReady(options) {
 export function main(argv, options = {}) {
     if (argv.length < 2) {
         process.stderr.write("usage: scm.py <namespace> <verb> [pass-through args...]\n" +
-            "       (v1 stub: namespace=issue, verb=list|view|close|edit)\n" +
+            "       (v1 stub: namespace=issue, verb=list|view|close|edit|design-critique-chip)\n" +
             "       --rest opt-in is supported on issue view/list (#976)\n");
         return 2;
     }
     const namespace = argv[0] ?? "";
     const verb = argv[1] ?? "";
     let extra = argv.slice(2);
+    if (namespace === "issue" && verb === DESIGN_CRITIQUE_CHIP_VERB) {
+        const blocked = guardScmReady(options);
+        if (blocked !== null)
+            return blocked;
+        const result = runDesignCritiqueChip(extra, { client: options.labelClient });
+        if (result.stdout.length > 0) {
+            process.stdout.write(result.stdout);
+        }
+        if (result.stderr.length > 0) {
+            process.stderr.write(result.stderr);
+        }
+        return result.exitCode;
+    }
     const [restMode, afterRest] = extractFlag(extra, "--rest");
     extra = afterRest;
     if (restMode) {

package/dist/scm/readiness-cli.d.ts

@@ -10,6 +10,8 @@ export interface ScmReadinessCliArgs {
     readonly deep?: boolean;
     readonly depth?: ScmProbeDepth;
     readonly help?: boolean;
+    readonly repo?: string;
+    readonly expectedLogin?: string;
 }
 export declare function parseScmReadinessArgs(argv: readonly string[]): {
     args: ScmReadinessCliArgs;