@deftai/directive-core 0.107.0 → 0.109.0

package/dist/release/cli-drift-report.js

@@ -0,0 +1,189 @@
+/**
+ * Local-vs-released CLI drift report after a cut (#3753).
+ *
+ * Report-only: never runs `npm i -g`. Never fails the release. Polls all four
+ * workspace packages with `--prefer-online` so a lag-poisoned npm cache cannot
+ * masquerade as a missing publish.
+ */
+import { spawnSync } from "node:child_process";
+import { PUBLIC_NPM_REGISTRY } from "../doctor/constants.js";
+import { checkActiveCliAgainstTarget } from "../session/active-cli.js";
+import { RELEASE_E2E_ENV } from "./skip-ci-incident.js";
+/** Same sentinel as release-e2e `REHEARSAL_VERSION` — do not poll npm for 0.0.1. */
+const REHEARSAL_VERSION = "0.0.1";
+/** Workspace packages published by npm-publish.yml (sibling propagate is not atomic). */
+export const WORKSPACE_PACKAGES = [
+    "@deftai/directive-types",
+    "@deftai/directive-core",
+    "@deftai/directive-content",
+    "@deftai/directive",
+];
+/** Observed sibling lag was ~7 minutes; Phase 7 wait sits under this ceiling. */
+export const CLI_DRIFT_POLL_TIMEOUT_MS = 10 * 60 * 1000;
+export const CLI_DRIFT_POLL_INTERVAL_MS = 30_000;
+/** Pipeline completion is a single probe — Step 13 returns before npm-publish.yml is green. */
+export const CLI_DRIFT_PIPELINE_POLL_TIMEOUT_MS = 0;
+export function remediationCommand(version) {
+    return `npm i -g @deftai/directive@${version} --prefer-online`;
+}
+export function npmViewArgs(name, version) {
+    return [
+        "view",
+        `${name}@${version}`,
+        "version",
+        "--prefer-online",
+        "--ignore-scripts",
+        `--registry=${PUBLIC_NPM_REGISTRY}`,
+    ];
+}
+export function defaultViewWorkspacePackage(name, version) {
+    try {
+        const result = spawnSync("npm", npmViewArgs(name, version), {
+            encoding: "utf8",
+            timeout: 15_000,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        const raw = typeof result.stdout === "string" ? result.stdout : "";
+        const seen = raw.trim().split(/\r?\n/)[0]?.trim() ?? "";
+        const visible = result.status === 0 && seen === version;
+        return { name, visible, version: seen.length > 0 ? seen : null };
+    }
+    catch {
+        return { name, visible: false, version: null };
+    }
+}
+export function classifyRegistryVisibility(opts) {
+    if (opts.skipped)
+        return "skipped";
+    const visibleCount = opts.probes.filter((p) => p.visible).length;
+    if (opts.probes.length > 0 && visibleCount === opts.probes.length)
+        return "all-visible";
+    if (visibleCount === 0 && opts.waitExhausted)
+        return "publish-incomplete";
+    return "still-propagating";
+}
+export function pollWorkspacePackages(version, opts) {
+    const now = opts.nowMs ?? Date.now;
+    const sleep = opts.sleepMs ?? (() => undefined);
+    const interval = opts.intervalMs ?? CLI_DRIFT_POLL_INTERVAL_MS;
+    const start = now();
+    let probes = WORKSPACE_PACKAGES.map((name) => opts.viewPackage(name, version));
+    if (probes.every((p) => p.visible)) {
+        return { probes, waitExhausted: false };
+    }
+    if (opts.timeoutMs <= 0) {
+        return { probes, waitExhausted: false };
+    }
+    while (now() - start < opts.timeoutMs) {
+        const remaining = opts.timeoutMs - (now() - start);
+        if (remaining <= 0)
+            break;
+        sleep(Math.min(interval, remaining));
+        probes = WORKSPACE_PACKAGES.map((name) => opts.viewPackage(name, version));
+        if (probes.every((p) => p.visible)) {
+            return { probes, waitExhausted: false };
+        }
+    }
+    return { probes, waitExhausted: true };
+}
+export function shouldSkipRegistryPoll(config, env = process.env) {
+    if (config.dryRun || config.skipTag)
+        return true;
+    if (config.version === REHEARSAL_VERSION)
+        return true;
+    if (env[RELEASE_E2E_ENV])
+        return true;
+    if (env.CI === "true" || env.GITHUB_ACTIONS === "true")
+        return true;
+    // Unit tests never probe the live registry; production `task release` does not set VITEST.
+    if (env.VITEST)
+        return true;
+    return false;
+}
+function formatRegistryLine(registry, packages) {
+    if (registry === "skipped") {
+        return "  registry: skipped (dry-run / skip-tag / rehearsal / CI — no publish to poll)";
+    }
+    const visible = packages.filter((p) => p.visible).map((p) => p.name);
+    const missing = packages.filter((p) => !p.visible).map((p) => p.name);
+    const counts = `visible ${visible.length}/${packages.length}`;
+    if (registry === "all-visible") {
+        return `  registry: all-visible (${counts})`;
+    }
+    if (registry === "publish-incomplete") {
+        return `  registry: publish-incomplete (${counts}; none of the four packages resolved after the wait)`;
+    }
+    const missingText = missing.length > 0 ? `; missing: ${missing.join(", ")}` : "";
+    return `  registry: still-propagating (${counts}${missingText})`;
+}
+export function buildCliDriftReport(releasedVersion, opts = { skipRegistryPoll: false }) {
+    const check = opts.checkActiveCli ?? ((target) => checkActiveCliAgainstTarget(target));
+    const cli = check(releasedVersion);
+    const localVersion = cli.active?.version ?? null;
+    const localPath = cli.active?.path ?? null;
+    const match = localVersion !== null && localVersion === releasedVersion && cli.ok;
+    const shadowed = !cli.ok && cli.candidates.length > 0;
+    let packages = [];
+    let waitExhausted = false;
+    if (!opts.skipRegistryPoll) {
+        const view = opts.viewPackage ?? defaultViewWorkspacePackage;
+        const polled = pollWorkspacePackages(releasedVersion, {
+            timeoutMs: opts.pollTimeoutMs ?? CLI_DRIFT_PIPELINE_POLL_TIMEOUT_MS,
+            intervalMs: opts.pollIntervalMs,
+            viewPackage: view,
+            nowMs: opts.nowMs,
+            sleepMs: opts.sleepMs,
+        });
+        packages = polled.probes;
+        waitExhausted = polled.waitExhausted;
+    }
+    const registry = classifyRegistryVisibility({
+        probes: packages,
+        waitExhausted,
+        skipped: opts.skipRegistryPoll,
+    });
+    const remediation = remediationCommand(releasedVersion);
+    const localLabel = localVersion === null
+        ? "none on PATH"
+        : `${localVersion}${localPath !== null ? ` (${localPath})` : ""}`;
+    const lines = [
+        "CLI drift report (#3753):",
+        `  released: ${releasedVersion}`,
+        `  local global CLI: ${localLabel}`,
+        `  match: ${match ? "yes" : "no"}`,
+        ...(shadowed
+            ? ["  note: PATH-shadowed install — bare deft --version is not sufficient (#3233)"]
+            : []),
+        formatRegistryLine(registry, packages),
+        `  remediation: ${remediation}`,
+        "  note: report-only — this pipeline does not run npm i -g",
+    ];
+    return {
+        releasedVersion,
+        localVersion,
+        localPath,
+        match,
+        shadowed,
+        registry,
+        packages,
+        remediation,
+        lines,
+    };
+}
+export function formatCliDriftReport(report) {
+    return `${report.lines.join("\n")}\n`;
+}
+/** Best-effort wrapper — a report failure must never fail the cut. */
+export function emitCliDriftReportBestEffort(releasedVersion, opts, write = (text) => {
+    process.stderr.write(text);
+}) {
+    try {
+        write(formatCliDriftReport(buildCliDriftReport(releasedVersion, opts)));
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        write(`CLI drift report (#3753): skipped (${reason.replace(/\r?\n/g, " ")})\n`);
+    }
+}
+//# sourceMappingURL=cli-drift-report.js.map

package/dist/release/consumer-hard-stops.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Check 4 -- consumer hard-stop census (#3900 / #3713 / #3969).
+ *
+ * Enumerates open issues by privileged label only.
+ * BLOCKER is the sole permitted consumer title classification (inbound flare).
+ * The adoption-blocker label is never derived from a title.
+ * Issue bodies are not read into the verdict.
+ *
+ * parseClosesSet composes citation-grammar classifyPosition; do not add a
+ * third position classifier (#3969).
+ */
+export declare const CONSUMER_HARD_STOP_TITLE_RE: RegExp;
+export declare const ADOPTION_BLOCKER_LABEL = "adoption-blocker";
+export declare const BLOCKS_RELEASE_TAG_LABEL = "blocks-release-tag";
+/** Maintainer-applied labels that can block a cut. Titles cannot. */
+export declare const PRIVILEGED_HARD_STOP_LABELS: readonly string[];
+export interface HardStopIssue {
+    readonly number: number;
+    readonly title: string;
+    readonly labels: readonly string[];
+}
+export interface HardStopCensusEntry {
+    readonly number: number;
+    readonly title: string;
+    readonly viaTitle: boolean;
+    readonly viaLabel: boolean;
+}
+export interface HardStopCensusResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: "stdout" | "stderr";
+    readonly matches: readonly HardStopCensusEntry[];
+    readonly shipsPast: readonly HardStopCensusEntry[];
+}
+/** Privileged labels only. Title is recorded as a flare, never as a match. Never inspect a body field. */
+export declare function classifyHardStop(issue: HardStopIssue): HardStopCensusEntry | null;
+export declare function enumerateConsumerHardStops(issues: readonly HardStopIssue[]): HardStopCensusEntry[];
+/**
+ * Extract Closes/Fixes/Resolves #N from changelog Unreleased text.
+ * Never from issue bodies. Hits in refused markdown positions are not claims.
+ */
+export declare function parseClosesSet(changelogText: string): Set<number>;
+export declare function evaluateConsumerHardStopCensus(options: {
+    readonly issues: readonly HardStopIssue[];
+    readonly closesSet: ReadonlySet<number>;
+}): HardStopCensusResult;
+export declare function issueFromInventoryRow(row: Record<string, unknown>): HardStopIssue | null;
+//# sourceMappingURL=consumer-hard-stops.d.ts.map

package/dist/release/consumer-hard-stops.js

@@ -0,0 +1,140 @@
+/**
+ * Check 4 -- consumer hard-stop census (#3900 / #3713 / #3969).
+ *
+ * Enumerates open issues by privileged label only.
+ * BLOCKER is the sole permitted consumer title classification (inbound flare).
+ * The adoption-blocker label is never derived from a title.
+ * Issue bodies are not read into the verdict.
+ *
+ * parseClosesSet composes citation-grammar classifyPosition; do not add a
+ * third position classifier (#3969).
+ */
+import { classifyPosition } from "../design-critique/citation-grammar.js";
+export const CONSUMER_HARD_STOP_TITLE_RE = /^BLOCKER\b/i;
+export const ADOPTION_BLOCKER_LABEL = "adoption-blocker";
+export const BLOCKS_RELEASE_TAG_LABEL = "blocks-release-tag";
+/** Maintainer-applied labels that can block a cut. Titles cannot. */
+export const PRIVILEGED_HARD_STOP_LABELS = [
+    ADOPTION_BLOCKER_LABEL,
+    BLOCKS_RELEASE_TAG_LABEL,
+];
+const REMEDIATION = "Recovery: close those issues in this cut (or list them in the Unreleased Closes set). " +
+    "Census blocking classification is privileged labels (" +
+    PRIVILEGED_HARD_STOP_LABELS.join(", ") +
+    ") only; BLOCKER in a title is an inbound flare and does not by itself block a cut (#3713 / #3969).";
+function labelsOf(issue) {
+    return issue.labels.map((label) => label.trim()).filter((label) => label.length > 0);
+}
+function hasPrivilegedLabel(labels) {
+    return labels.some((label) => PRIVILEGED_HARD_STOP_LABELS.includes(label));
+}
+/** Privileged labels only. Title is recorded as a flare, never as a match. Never inspect a body field. */
+export function classifyHardStop(issue) {
+    const viaTitle = CONSUMER_HARD_STOP_TITLE_RE.test(issue.title.trim());
+    const viaLabel = hasPrivilegedLabel(labelsOf(issue));
+    if (!viaLabel) {
+        return null;
+    }
+    return { number: issue.number, title: issue.title, viaTitle, viaLabel };
+}
+export function enumerateConsumerHardStops(issues) {
+    const out = [];
+    for (const issue of issues) {
+        const match = classifyHardStop(issue);
+        if (match !== null) {
+            out.push(match);
+        }
+    }
+    return out.sort((a, b) => a.number - b.number);
+}
+/**
+ * Extract Closes/Fixes/Resolves #N from changelog Unreleased text.
+ * Never from issue bodies. Hits in refused markdown positions are not claims.
+ */
+export function parseClosesSet(changelogText) {
+    const after = changelogText.split(/^## \[Unreleased\]\s*$/m)[1] ?? "";
+    const unreleased = after.split(/^## \[/m)[0] ?? after;
+    const found = new Set();
+    const re = /\b(?:Closes|Fixes|Resolves)\s+#(\d+)/gi;
+    let match = re.exec(unreleased);
+    while (match !== null) {
+        const reason = classifyPosition(unreleased, match.index ?? 0);
+        if (reason === null) {
+            const n = Number(match[1]);
+            if (Number.isInteger(n) && n > 0) {
+                found.add(n);
+            }
+        }
+        match = re.exec(unreleased);
+    }
+    return found;
+}
+export function evaluateConsumerHardStopCensus(options) {
+    const matches = enumerateConsumerHardStops(options.issues);
+    const shipsPast = matches.filter((entry) => !options.closesSet.has(entry.number));
+    if (matches.length === 0) {
+        return {
+            code: 0,
+            message: "Consumer hard-stops: ok -- no open privileged hard-stop labels (" +
+                PRIVILEGED_HARD_STOP_LABELS.join(", ") +
+                ").",
+            stream: "stdout",
+            matches,
+            shipsPast,
+        };
+    }
+    if (shipsPast.length === 0) {
+        return {
+            code: 0,
+            message: "Consumer hard-stops: ok -- " +
+                String(matches.length) +
+                " open hard-stop(s) are in this cut Closes set.",
+            stream: "stdout",
+            matches,
+            shipsPast,
+        };
+    }
+    const sample = shipsPast
+        .slice(0, 8)
+        .map((entry) => "#" + String(entry.number))
+        .join(", ");
+    return {
+        code: 1,
+        message: "Consumer hard-stops: fail -- " +
+            String(shipsPast.length) +
+            " open hard-stop(s) not in this cut Closes set: " +
+            sample +
+            ". " +
+            REMEDIATION,
+        stream: "stderr",
+        matches,
+        shipsPast,
+    };
+}
+export function issueFromInventoryRow(row) {
+    const number = row.number;
+    const title = row.title;
+    if (typeof number !== "number" || !Number.isInteger(number) || typeof title !== "string") {
+        return null;
+    }
+    if ("pull_request" in row) {
+        return null;
+    }
+    const labelsRaw = row.labels;
+    const labels = [];
+    if (Array.isArray(labelsRaw)) {
+        for (const item of labelsRaw) {
+            if (typeof item === "string") {
+                labels.push(item);
+            }
+            else if (item !== null && typeof item === "object" && "name" in item) {
+                const name = item.name;
+                if (typeof name === "string") {
+                    labels.push(name);
+                }
+            }
+        }
+    }
+    return { number, title, labels };
+}
+//# sourceMappingURL=consumer-hard-stops.js.map

package/dist/release/consumer-readiness-disclosure.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks 5 and 6 -- operator disclosure at the release decision point (#3900).
+ *
+ * New-refusal census and net-posture are judgments. They are printed for the
+ * operator and never fail-closed, never dressed as a computed verdict.
+ */
+export interface RefusalHint {
+    readonly line: number;
+    readonly excerpt: string;
+}
+export interface ConsumerReadinessDisclosure {
+    readonly blocking: false;
+    readonly newRefusalHints: readonly RefusalHint[];
+    readonly text: string;
+}
+export declare function collectNewRefusalHints(changelogText: string): RefusalHint[];
+export declare function formatConsumerReadinessDisclosure(changelogText: string): ConsumerReadinessDisclosure;
+//# sourceMappingURL=consumer-readiness-disclosure.d.ts.map

package/dist/release/consumer-readiness-disclosure.js

@@ -0,0 +1,51 @@
+/**
+ * Checks 5 and 6 -- operator disclosure at the release decision point (#3900).
+ *
+ * New-refusal census and net-posture are judgments. They are printed for the
+ * operator and never fail-closed, never dressed as a computed verdict.
+ */
+const FAIL_CLOSED_HINT = /fail-closed|fail closed|refuses? to|MUST NOT|must not|blocks? (?:the )?(?:tag|cut|release)|new refusal/i;
+function unreleasedSection(changelogText) {
+    const rest = changelogText.split(/^## \[Unreleased\]\s*$/m)[1];
+    if (rest === undefined) {
+        return "";
+    }
+    const next = rest.split(/^## \[/m)[0] ?? rest;
+    return next;
+}
+export function collectNewRefusalHints(changelogText) {
+    const section = unreleasedSection(changelogText);
+    const hints = [];
+    const lines = section.split("\n");
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        if (FAIL_CLOSED_HINT.test(line)) {
+            hints.push({ line: i + 1, excerpt: line.trim().slice(0, 160) });
+        }
+    }
+    return hints;
+}
+export function formatConsumerReadinessDisclosure(changelogText) {
+    const hints = collectNewRefusalHints(changelogText);
+    const lines = [
+        "Consumer-readiness disclosure (does not block the tag) -- #3900 checks 5 and 6.",
+        "",
+        "Check 5 -- new-refusal census (operator judgment):",
+    ];
+    if (hints.length === 0) {
+        lines.push("  No Unreleased lines matched fail-closed / new-refusal hints.");
+    }
+    else {
+        lines.push("  Unreleased lines that may introduce a consumer-visible refusal:");
+        for (const hint of hints.slice(0, 20)) {
+            lines.push("  - " + hint.excerpt);
+        }
+    }
+    lines.push("  Each new refusal needs remediation text and an escape hatch. This is not a computed verdict.");
+    lines.push("");
+    lines.push("Check 6 -- net-posture (operator judgment):");
+    lines.push("  Does this candidate fix more consumer-visible breakage than it introduces, and on which surfaces?");
+    lines.push("  Holding a release is only correct when that answer is negative. The operator decides.");
+    return { blocking: false, newRefusalHints: hints, text: lines.join("\n") };
+}
+//# sourceMappingURL=consumer-readiness-disclosure.js.map

package/dist/release/index.d.ts

@@ -1,7 +1,10 @@
 export * from "./auto-hatch.js";
 export * from "./build-dist.js";
+export * from "./cli-drift-report.js";
 export * from "./closed-verb-gate.js";
 export * from "./constants.js";
+export * from "./consumer-hard-stops.js";
+export * from "./consumer-readiness-disclosure.js";
 export * from "./coverage-debt-ledger.js";
 export * from "./flags.js";
 export * from "./gh.js";

package/dist/release/index.js

@@ -1,8 +1,11 @@
 /* v8 ignore file -- re-export barrel; covered via main.ts */
 export * from "./auto-hatch.js";
 export * from "./build-dist.js";
+export * from "./cli-drift-report.js";
 export * from "./closed-verb-gate.js";
 export * from "./constants.js";
+export * from "./consumer-hard-stops.js";
+export * from "./consumer-readiness-disclosure.js";
 export * from "./coverage-debt-ledger.js";
 export * from "./flags.js";
 export * from "./gh.js";

package/dist/release/issue-state-fetch.d.ts

@@ -1,4 +1,4 @@
-import { type FetchIssueStatesOptions } from "../intake/reconcile-issues.js";
+import { IssueState } from "../intake/reconcile-issues.js";
 import { type CallOptions, type CompletedProcess } from "../scm/call.js";
 export type ScmCallFn = (source: string, verb: string, args: readonly string[] | null, options?: CallOptions) => CompletedProcess;
 /** Max seconds to sleep before the single rate-limit retry (operator-locked cap). */
@@ -9,13 +9,15 @@ export interface RateLimitProbe {
     readonly coreResetUnix: number | null;
     readonly graphqlRemaining: number | null;
 }
-export interface FetchIssueStatesForReleaseOptions extends FetchIssueStatesOptions {
+export interface FetchIssueStatesForReleaseOptions {
+    readonly cwd?: string;
+    readonly scmCall?: ScmCallFn;
     readonly sleep?: SleepFn;
     readonly now?: () => number;
 }
 export type FetchIssueStatesForReleaseResult = {
     readonly ok: true;
-    readonly states: Map<number, import("../intake/reconcile-issues.js").IssueState>;
+    readonly states: Map<number, IssueState>;
 } | {
     readonly ok: false;
     readonly reason: string;

package/dist/release/issue-state-fetch.js

@@ -1,9 +1,11 @@
 /**
  * Release Step 3 issue-state fetch with capped rate-limit retry (#2577).
+ * Open-issue inventory via one paginated REST subprocess (#3752).
  */
 import { detectRateLimit } from "../cache/fetch.js";
-import { fetchIssueStates } from "../intake/reconcile-issues.js";
+import { IssueState } from "../intake/reconcile-issues.js";
 import { call } from "../scm/call.js";
+import { GhRestError, restIssueListOpenInventory } from "../scm/gh-rest.js";
 /** Max seconds to sleep before the single rate-limit retry (operator-locked cap). */
 export const MAX_RATE_LIMIT_RETRY_SLEEP_S = 120;
 const X_RATE_LIMIT_RESET_RE = /X-RateLimit-Reset:\s*(\d+)/i;
@@ -15,6 +17,71 @@ function defaultSleep(seconds) {
     const shared = new Int32Array(new SharedArrayBuffer(4));
     Atomics.wait(shared, 0, 0, ms);
 }
+function scmCallToRunGhApi(scmCall, cwd) {
+    return (args, options) => {
+        const result = scmCall("github-issue", "api", args, {
+            timeout: options?.timeout ?? 120,
+            cwd,
+        });
+        return {
+            returncode: result.returncode,
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    };
+}
+function buildStatesFromOpenInventory(issueNumbers, openInventory) {
+    const openNumbers = new Set();
+    for (const row of openInventory) {
+        const n = row.number;
+        if (typeof n === "number" && Number.isInteger(n)) {
+            openNumbers.add(n);
+        }
+    }
+    const states = new Map();
+    for (const n of [...issueNumbers].sort((a, b) => a - b)) {
+        states.set(n, openNumbers.has(n) ? new IssueState("OPEN") : new IssueState("NOT_FOUND"));
+    }
+    return states;
+}
+function fetchOpenInventoryAttempt(repo, runGhApiFn) {
+    let sawRateLimit = false;
+    let rateLimitStderr = "";
+    const trackingFn = (args, options) => {
+        const result = runGhApiFn(args, options);
+        if (result.returncode !== 0 && detectRateLimit(result.stderr)[0]) {
+            sawRateLimit = true;
+            rateLimitStderr = result.stderr;
+        }
+        return result;
+    };
+    try {
+        return {
+            inventory: restIssueListOpenInventory(repo, { runGhApiFn: trackingFn }),
+            sawRateLimit,
+            rateLimitStderr,
+            failureReason: null,
+        };
+    }
+    catch (err) {
+        const stderr = err instanceof GhRestError ? err.stderr : "";
+        if (stderr.length > 0 && detectRateLimit(stderr)[0]) {
+            sawRateLimit = true;
+            rateLimitStderr = stderr;
+        }
+        const reason = err instanceof GhRestError
+            ? `open-issue inventory fetch failed: ${err.message}`
+            : err instanceof Error
+                ? err.message
+                : String(err);
+        return {
+            inventory: null,
+            sawRateLimit,
+            rateLimitStderr,
+            failureReason: reason,
+        };
+    }
+}
 function parseRateLimitProbe(stdout) {
     try {
         const body = JSON.parse(stdout);
@@ -101,37 +168,34 @@ export function formatRateLimitFailureDetails(probe, rateLimitRelated) {
     return lines.join("\n");
 }
 export function fetchIssueStatesForRelease(repo, issueNumbers, options = {}) {
+    if (issueNumbers.size === 0) {
+        return { ok: true, states: new Map() };
+    }
+    process.stderr.write(`[release Step 3] checking ${issueNumbers.size} unique anchored issue(s) via open-issue inventory\n`);
     const sleepFn = options.sleep ?? defaultSleep;
     const nowFn = options.now ?? (() => Math.floor(Date.now() / 1000));
     const baseScmCall = options.scmCall ?? call;
     const cwd = options.cwd ?? undefined;
-    let sawRateLimit = false;
-    let lastRateLimitStderr = "";
-    const trackingScmCall = (source, verb, args, callOptions) => {
-        const result = baseScmCall(source, verb, args, callOptions);
-        if (result.returncode !== 0 && detectRateLimit(result.stderr)[0]) {
-            sawRateLimit = true;
-            lastRateLimitStderr = result.stderr;
-        }
-        return result;
+    const runGhApiFn = scmCallToRunGhApi(baseScmCall, cwd);
+    const finishSuccess = (inventory) => {
+        process.stderr.write(`[release Step 3] open-issue inventory: ${inventory.length} open issue(s)\n`);
+        return { ok: true, states: buildStatesFromOpenInventory(issueNumbers, inventory) };
     };
-    let states = fetchIssueStates(repo, issueNumbers, { ...options, scmCall: trackingScmCall });
-    if (states !== null) {
-        return { ok: true, states };
+    let attempt = fetchOpenInventoryAttempt(repo, runGhApiFn);
+    if (attempt.inventory !== null) {
+        return finishSuccess(attempt.inventory);
     }
-    if (sawRateLimit) {
+    if (attempt.sawRateLimit) {
         const probe = probeGithubRateLimit(baseScmCall, cwd);
-        const sleepS = computeRateLimitSleepSeconds(lastRateLimitStderr, probe, nowFn());
+        const sleepS = computeRateLimitSleepSeconds(attempt.rateLimitStderr, probe, nowFn());
         process.stderr.write(`[release Step 3] GitHub REST rate limit hit; sleeping ${sleepS}s before one retry\n`);
         sleepFn(sleepS);
-        sawRateLimit = false;
-        lastRateLimitStderr = "";
-        states = fetchIssueStates(repo, issueNumbers, { ...options, scmCall: trackingScmCall });
-        if (states !== null) {
-            return { ok: true, states };
+        attempt = fetchOpenInventoryAttempt(repo, runGhApiFn);
+        if (attempt.inventory !== null) {
+            return finishSuccess(attempt.inventory);
         }
     }
-    const rateLimitRelated = sawRateLimit || lastRateLimitStderr.length > 0;
+    const rateLimitRelated = attempt.sawRateLimit || attempt.rateLimitStderr.length > 0;
     if (rateLimitRelated) {
         const probe = probeGithubRateLimit(baseScmCall, cwd);
         const details = formatRateLimitFailureDetails(probe, true);
@@ -141,6 +205,7 @@ export function fetchIssueStatesForRelease(repo, issueNumbers, options = {}) {
             reason: "GitHub REST rate limit exhausted (see stderr for recovery steps)",
         };
     }
+    process.stderr.write(`${attempt.failureReason ?? "open-issue inventory fetch failed"}\n`);
     return { ok: false, reason: "failed to fetch issue states from gh" };
 }
 //# sourceMappingURL=issue-state-fetch.js.map

package/dist/release/native-steps.js

@@ -43,6 +43,7 @@ export function checkVbriefLifecycleSyncNative(projectRoot, repo) {
                 anchorIssueNumbers.add(num);
             }
         }
+        process.stderr.write(`[release Step 3] ${anchors.length} lifecycle anchor(s), ${anchorIssueNumbers.size} unique issue number(s) to evaluate\n`);
         const fetchResult = fetchIssueStatesForRelease(repo, anchorIssueNumbers, {
             cwd: projectRoot,
         });