@deftai/directive-core 0.107.0 → 0.109.0

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/run-summary/types.d.ts

@@ -126,8 +126,8 @@ export interface AcceptanceRunSummaryPayload {
     readonly none_stated?: boolean;
     readonly clause_count?: number;
     readonly clause_outcomes?: readonly AcceptanceClauseOutcomeRow[];
-    /** bank | cache | executed — how verify:ac obtained this result (#3387). */
-    readonly served_from?: "bank" | "cache" | "executed";
+    /** bank | cache | executed | refused — how verify:ac obtained this result (#3387 / #3615). */
+    readonly served_from?: "bank" | "cache" | "executed" | "refused";
     /** Config-error cause when outcome is config-error (#3559). */
     readonly cause?: string;
     /** Reuse-gate miss cause when served_from is executed (#3558). */

package/dist/scm/build-command.d.ts

@@ -1,7 +1,7 @@
-import { resolveBinary } from "./binary.js";
+import { resolveBinaryForArgv } from "./call-shape.js";
 export interface BuildCommandOptions {
     readonly binary?: string;
-    readonly whichFn?: Parameters<typeof resolveBinary>[0];
+    readonly whichFn?: Parameters<typeof resolveBinaryForArgv>[2];
 }
 /**
  * Construct the underlying `[binary, namespace, verb, *extra]` argv.

package/dist/scm/build-command.js

@@ -1,4 +1,4 @@
-import { resolveBinary } from "./binary.js";
+import { resolveBinaryForArgv } from "./call-shape.js";
 import { ALLOWED_ISSUE_VERBS, ALLOWED_NAMESPACES } from "./constants.js";
 import { ScmStubError } from "./errors.js";
 import { pyRepr, pyTuple } from "./py-format.js";
@@ -17,7 +17,7 @@ export function buildCommand(namespace, verb, extra, options = {}) {
             `${pyTuple(ALLOWED_ISSUE_VERBS)}. The v1 stub only exposes these four; ` +
             "additional scm:issue:* commands belong on #881.");
     }
-    const resolved = options.binary ?? resolveBinary(options.whichFn ?? undefined);
+    const resolved = options.binary ?? resolveBinaryForArgv(namespace, [verb, ...extra], options.whichFn);
     return [resolved, namespace, verb, ...extra];
 }
 //# sourceMappingURL=build-command.js.map

package/dist/scm/call-shape.d.ts

@@ -0,0 +1,25 @@
+import { type WhichFn } from "./binary.js";
+/** Surfaces ghx may serve versus surfaces that must use live gh (#3737). */
+export type ScmBinaryRole = "cached-get" | "live-gh";
+/**
+ * Classify an SCM argv for ghx eligibility.
+ *
+ * ghx is a cached read-only GET proxy that accepts a single positional path.
+ * Extra positionals are rejected (`accepts 1 arg(s), received 2`). Flags
+ * (`--method`, `--paginate`, `--jq`, `--input`, `-X`, ...) are not the cache
+ * shape. Non-`api` verbs are live `gh`.
+ */
+export declare function classifyScmArgv(verb: string, args?: readonly string[]): ScmBinaryRole;
+/**
+ * Resolve a binary for a classified role.
+ *
+ * cached-get uses the PATH ladder (`resolveBinary`, ghx then gh).
+ * live-gh pins `gh` — the same preference as `resolveLiveGh`,
+ * `resolveAuthProbeBinary`, and `GH_ONLY_WHICH`. If `gh` is absent, throw
+ * rather than fall through to ghx (a mutation or flag-rich GET is not a
+ * cache-proxy shape).
+ */
+export declare function resolveBinaryForRole(role: ScmBinaryRole, whichFn?: WhichFn): string;
+/** Classify argv then resolve. Compose with `resolveBinary`; do not probe health. */
+export declare function resolveBinaryForArgv(verb: string, args?: readonly string[], whichFn?: WhichFn): string;
+//# sourceMappingURL=call-shape.d.ts.map

package/dist/scm/call-shape.js

@@ -0,0 +1,59 @@
+import { defaultWhich, resolveBinary } from "./binary.js";
+import { ScmStubError } from "./errors.js";
+/**
+ * Classify an SCM argv for ghx eligibility.
+ *
+ * ghx is a cached read-only GET proxy that accepts a single positional path.
+ * Extra positionals are rejected (`accepts 1 arg(s), received 2`). Flags
+ * (`--method`, `--paginate`, `--jq`, `--input`, `-X`, ...) are not the cache
+ * shape. Non-`api` verbs are live `gh`.
+ */
+export function classifyScmArgv(verb, args = []) {
+    if (verb !== "api") {
+        return "live-gh";
+    }
+    const positionals = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const token = args[i];
+        if (token === undefined) {
+            continue;
+        }
+        if (token === "--") {
+            positionals.push(...args.slice(i + 1));
+            break;
+        }
+        if (token.startsWith("-")) {
+            return "live-gh";
+        }
+        positionals.push(token);
+    }
+    if (positionals.length !== 1) {
+        return "live-gh";
+    }
+    return "cached-get";
+}
+/**
+ * Resolve a binary for a classified role.
+ *
+ * cached-get uses the PATH ladder (`resolveBinary`, ghx then gh).
+ * live-gh pins `gh` — the same preference as `resolveLiveGh`,
+ * `resolveAuthProbeBinary`, and `GH_ONLY_WHICH`. If `gh` is absent, throw
+ * rather than fall through to ghx (a mutation or flag-rich GET is not a
+ * cache-proxy shape).
+ */
+export function resolveBinaryForRole(role, whichFn = defaultWhich) {
+    if (role === "live-gh") {
+        if (whichFn("gh") !== null) {
+            return "gh";
+        }
+        throw new ScmStubError("gh not found on PATH; this call shape requires live gh, not the ghx cache proxy. " +
+            "install GitHub CLI (https://cli.github.com/) or pass GH_TOKEN into a matched env and re-run. " +
+            "Refs #3737 / #2275.");
+    }
+    return resolveBinary(whichFn);
+}
+/** Classify argv then resolve. Compose with `resolveBinary`; do not probe health. */
+export function resolveBinaryForArgv(verb, args = [], whichFn = defaultWhich) {
+    return resolveBinaryForRole(classifyScmArgv(verb, args), whichFn);
+}
+//# sourceMappingURL=call-shape.js.map

package/dist/scm/call.d.ts

@@ -1,4 +1,4 @@
-import { resolveBinary } from "./binary.js";
+import { type WhichFn } from "./binary.js";
 /** Mirrors Python `subprocess.CompletedProcess`. */
 export interface CompletedProcess {
     readonly args: readonly string[];
@@ -13,7 +13,7 @@ export interface CallOptions {
     readonly timeout?: number;
     readonly cwd?: string;
     readonly binary?: string;
-    readonly whichFn?: Parameters<typeof resolveBinary>[0];
+    readonly whichFn?: WhichFn;
     readonly env?: NodeJS.ProcessEnv;
     readonly input?: string;
 }
@@ -21,10 +21,13 @@ export interface CallOptions {
  * Source-aware SCM invocation -- partial down-payment on #445 / #935 Workstream 6.
  * Mirrors `scripts/scm.py::call`.
  *
- * Binary absence still throws ScmStubError via resolveBinary with the #2275
- * diagnostic. Full auth readiness is enforced at SCM CLI entry points
+ * Binary absence still throws ScmStubError via resolveBinaryForRole with the
+ * #2275 diagnostic. Full auth readiness is enforced at SCM CLI entry points
  * (`scm/main`, issue-ingest, reconcile-issues) via requireScmReady — not on
  * every call() — so unit tests that inject binary/seams stay hermetic.
+ *
+ * Call-shape selection (#3737): ghx only for single-path GET. An explicit
+ * `binary` override skips selection and spawn-failure fallback.
  */
 export declare function call(source: string, verb: string, args?: readonly string[] | null, options?: CallOptions): CompletedProcess;
 //# sourceMappingURL=call.d.ts.map

package/dist/scm/call.js

@@ -1,43 +1,82 @@
 import { spawnSync } from "node:child_process";
-import { resolveBinary } from "./binary.js";
+import { resolveCaptureFailureStderr, SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
+import { defaultWhich } from "./binary.js";
+import { classifyScmArgv, resolveBinaryForRole } from "./call-shape.js";
 import { SUPPORTED_CALL_SOURCES } from "./constants.js";
 import { pyRepr } from "./py-format.js";
+import { formatScmSpawnDiagnostic, isAvailabilitySpawnFailure } from "./spawn-status.js";
 /**
  * Source-aware SCM invocation -- partial down-payment on #445 / #935 Workstream 6.
  * Mirrors `scripts/scm.py::call`.
  *
- * Binary absence still throws ScmStubError via resolveBinary with the #2275
- * diagnostic. Full auth readiness is enforced at SCM CLI entry points
+ * Binary absence still throws ScmStubError via resolveBinaryForRole with the
+ * #2275 diagnostic. Full auth readiness is enforced at SCM CLI entry points
  * (`scm/main`, issue-ingest, reconcile-issues) via requireScmReady — not on
  * every call() — so unit tests that inject binary/seams stay hermetic.
+ *
+ * Call-shape selection (#3737): ghx only for single-path GET. An explicit
+ * `binary` override skips selection and spawn-failure fallback.
  */
 export function call(source, verb, args = null, options = {}) {
     if (!SUPPORTED_CALL_SOURCES.includes(source)) {
         throw new Error(`source=${pyRepr(source)} not yet supported; ` +
             "see #445 / #935 Workstream 6 for the abstraction.");
     }
-    const resolved = options.binary ?? resolveBinary(options.whichFn);
-    const argv = [resolved, verb, ...(args ?? [])];
+    const whichFn = options.whichFn ?? defaultWhich;
+    const role = classifyScmArgv(verb, args ?? []);
+    const explicitBinary = options.binary;
+    let resolved = explicitBinary ?? resolveBinaryForRole(role, whichFn);
+    const extra = args ?? [];
     const captureOutput = options.captureOutput ?? true;
     const timeoutMs = options.timeout !== undefined ? Math.round(options.timeout * 1000) : undefined;
-    const result = spawnSync(resolved, [verb, ...(args ?? [])], {
+    const spawnOnce = (bin) => spawnSync(bin, [verb, ...extra], {
         cwd: options.cwd,
         env: options.env ?? process.env,
         input: options.input,
         encoding: (options.text ?? true) ? "utf8" : undefined,
         timeout: timeoutMs,
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
         stdio: captureOutput ? ["pipe", "pipe", "pipe"] : "inherit",
     });
+    let result = spawnOnce(resolved);
+    if (explicitBinary === undefined &&
+        role === "cached-get" &&
+        resolved === "ghx" &&
+        isAvailabilitySpawnFailure({
+            status: result.status,
+            error: result.error,
+            stdout: typeof result.stdout === "string" ? result.stdout : "",
+            stderr: typeof result.stderr === "string" ? result.stderr : "",
+        }) &&
+        whichFn("gh") !== null) {
+        resolved = "gh";
+        result = spawnOnce(resolved);
+    }
+    const argv = [resolved, verb, ...extra];
+    const captured = typeof result.stderr === "string" ? result.stderr : "";
+    let stderr = resolveCaptureFailureStderr({
+        captured,
+        status: result.status,
+        message: result.error?.message,
+    });
+    if (isAvailabilitySpawnFailure({
+        status: result.status,
+        error: result.error,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: captured,
+    }) &&
+        stderr.trim().length === 0) {
+        stderr = formatScmSpawnDiagnostic(resolved, result.status, stderr, result.error);
+    }
     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

@@ -7,6 +7,7 @@
 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;

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

@@ -7,14 +7,16 @@
 import { spawnSync } from "node:child_process";
 import { applyDesignCritiqueCatalogChip, } from "../design-critique/exclusive-chip.js";
 import { parseGithubOwnerRepo } from "../policy/sync-default.js";
-import { ScmLabelClient, ScmLabelError } from "../vbrief-reconcile/labels.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";
+    "       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",
@@ -161,11 +163,25 @@ export function runDesignCritiqueChip(extra, seams = {}) {
         };
     }
     catch (err) {
-        if (err instanceof ScmLabelError) {
-            return { exitCode: 1, stdout: "", stderr: `error: ${err.message}\n` };
-        }
         const message = err instanceof Error ? err.message : String(err);
-        return { exitCode: 1, stdout: "", stderr: `error: ${message}\n` };
+        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

@@ -1,4 +1,5 @@
-import { resolveBinary } from "./binary.js";
+import { type SpawnSyncOptions } from "node:child_process";
+import { type WhichFn } from "./binary.js";
 export declare const DEFAULT_TIMEOUT_S = 60;
 /** Raised when the `"owner/repo"` argument is malformed. */
 export declare class InvalidRepoError extends Error {
@@ -11,35 +12,47 @@ export declare class GhRestError extends Error {
     readonly endpoint: string;
     readonly payload: Record<string, unknown> | null;
     readonly hint: string;
+    readonly binary: string;
     constructor(options: {
         stderr: string;
         exitCode: number;
         endpoint: string;
         payload: Record<string, unknown> | null;
         hint?: string;
+        binary?: string;
     });
 }
-export type RunGhApiFn = (args: readonly string[], options?: {
-    timeout?: number;
-    whichFn?: Parameters<typeof resolveBinary>[0];
-}) => {
+export type GhSpawnResult = {
+    readonly status: number | null;
+    readonly stdout?: string | Buffer | null;
+    readonly stderr?: string | Buffer | null;
+    readonly error?: {
+        readonly message?: string;
+        readonly code?: string;
+    };
+};
+export type GhSpawnFn = (command: string, args: readonly string[], options: SpawnSyncOptions) => GhSpawnResult;
+export type GhApiProcess = {
     returncode: number;
     stdout: string;
     stderr: string;
+    binary?: string;
 };
+export type RunGhApiFn = (args: readonly string[], options?: {
+    timeout?: number;
+    whichFn?: WhichFn;
+    spawnFn?: GhSpawnFn;
+}) => GhApiProcess;
 /** Single subprocess seam invoked by every helper. */
 export declare function runGhApi(args: readonly string[], options?: {
     timeout?: number;
-    whichFn?: Parameters<typeof resolveBinary>[0];
-}): {
-    returncode: number;
-    stdout: string;
-    stderr: string;
-};
+    whichFn?: WhichFn;
+    spawnFn?: GhSpawnFn;
+}): GhApiProcess;
 export declare function splitRepo(repo: string): [string, string];
 export interface GhRestSeams {
     readonly runGhApiFn?: RunGhApiFn;
-    readonly whichFn?: Parameters<typeof resolveBinary>[0];
+    readonly whichFn?: WhichFn;
 }
 /** `GET /repos/{owner}/{repo}/issues/{n}` -- read a single issue. */
 export declare function restIssueView(repo: string, n: number, seams?: GhRestSeams): Record<string, unknown>;
@@ -53,7 +66,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 +91,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