@deftai/directive-core 0.55.0

package/dist/pr-merge-readiness/main.js

@@ -0,0 +1,67 @@
+import { computeGateResult } from "./compute.js";
+import { defaultRunGh } from "./gh.js";
+import { emitJson, exitCodeFor, printHuman } from "./output.js";
+export function parseArgs(argv) {
+    let prNumber = null;
+    let repo = null;
+    let json = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { prNumber, repo, emitJson: json, error: "argument --repo: expected one argument" };
+            }
+            repo = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--repo=")) {
+            repo = arg.slice("--repo=".length);
+        }
+        else if (arg?.startsWith("-")) {
+            return { prNumber, repo, emitJson: json, error: `unrecognized arguments: ${arg}` };
+        }
+        else if (prNumber === null) {
+            const n = Number(arg);
+            if (!Number.isInteger(n) || n <= 0) {
+                return { prNumber, repo, emitJson: json, error: `invalid PR number: ${arg}` };
+            }
+            prNumber = n;
+        }
+        else {
+            return { prNumber, repo, emitJson: json, error: `unrecognized arguments: ${arg}` };
+        }
+    }
+    if (prNumber === null) {
+        return {
+            prNumber,
+            repo,
+            emitJson: json,
+            error: "the following arguments are required: pr_number",
+        };
+    }
+    return { prNumber, repo, emitJson: json };
+}
+export function run(argv, options = {}) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`pr_merge_readiness: ${args.error}\n`);
+        return 2;
+    }
+    const runGh = options.runGh ?? defaultRunGh;
+    const result = computeGateResult(args.prNumber, args.repo, runGh);
+    if (args.emitJson) {
+        process.stdout.write(emitJson(result));
+    }
+    else {
+        process.stdout.write(printHuman(result));
+    }
+    return exitCodeFor(result);
+}
+export function cmdPrMergeReadiness(argv, options = {}) {
+    return run(argv, options);
+}
+//# sourceMappingURL=main.js.map

package/dist/pr-merge-readiness/output.d.ts

@@ -0,0 +1,7 @@
+import type { GateResult } from "./types.js";
+/** Serialise gate result matching Python `GateResult.to_dict()` key order. */
+export declare function gateResultToDict(result: GateResult): Record<string, unknown>;
+export declare function emitJson(result: GateResult): string;
+export declare function printHuman(result: GateResult): string;
+export declare function exitCodeFor(result: GateResult): number;
+//# sourceMappingURL=output.d.ts.map

package/dist/pr-merge-readiness/output.js

@@ -0,0 +1,98 @@
+import { EXIT_EXTERNAL_ERROR, EXIT_MERGE_BLOCKED, EXIT_OK, VIA_ERROR, VIA_FALLBACK2, } from "./constants.js";
+import { isMergeReady } from "./evaluate.js";
+function verdictToDict(verdict) {
+    return {
+        found: verdict.found,
+        errored: verdict.errored,
+        last_reviewed_sha: verdict.lastReviewedSha,
+        confidence: verdict.confidence,
+        p0_count: verdict.p0Count,
+        p1_count: verdict.p1Count,
+        p2_count: verdict.p2Count,
+        informal_clean: verdict.informalClean,
+        raw_body_excerpt: verdict.rawBodyExcerpt,
+    };
+}
+/** Serialise gate result matching Python `GateResult.to_dict()` key order. */
+export function gateResultToDict(result) {
+    const payload = {
+        pr_number: result.prNumber,
+        repo: result.repo,
+        head_sha: result.headSha,
+        verdict: verdictToDict(result.verdict),
+        failures: [...result.failures],
+        merge_ready: isMergeReady(result.failures),
+        via: result.via,
+    };
+    if (Object.keys(result.partialData).length > 0) {
+        payload.partial_data = { ...result.partialData };
+    }
+    if (result.error !== null) {
+        payload.error = result.error;
+    }
+    return payload;
+}
+/** Match Python json.dumps(..., indent=2) default ensure_ascii=True. */
+function pythonJsonDumps(value) {
+    const json = JSON.stringify(value, null, 2);
+    return json.replace(/[\u007f-\uffff]/g, (ch) => {
+        const code = ch.charCodeAt(0);
+        return `\\u${code.toString(16).padStart(4, "0")}`;
+    });
+}
+export function emitJson(result) {
+    return `${pythonJsonDumps(gateResultToDict(result))}\n`;
+}
+export function printHuman(result) {
+    const lines = [];
+    lines.push(`PR #${result.prNumber} merge-readiness check  (via=${result.via})`);
+    lines.push(`  HEAD SHA:           ${result.headSha ?? "<unknown>"}`);
+    lines.push(`  Greptile reviewed:  ${result.verdict.lastReviewedSha ?? "<not parsed>"}`);
+    const confidenceStr = result.verdict.confidence !== null ? String(result.verdict.confidence) : "<not parsed>";
+    lines.push(`  Confidence:         ${confidenceStr}/5`);
+    lines.push(`  Findings:           P0=${result.verdict.p0Count}  ` +
+        `P1=${result.verdict.p1Count}  P2=${result.verdict.p2Count}`);
+    lines.push(`  Errored sentinel:   ${result.verdict.errored ? "True" : "False"}`);
+    if (result.via === VIA_FALLBACK2 && Object.keys(result.partialData).length > 0) {
+        lines.push("  Fallback2 signal:");
+        for (const key of ["pr_state", "merged", "mergeable", "mergeable_state"]) {
+            if (key in result.partialData) {
+                lines.push(`    ${key}: ${String(result.partialData[key])}`);
+            }
+        }
+        const checkRuns = result.partialData.check_runs;
+        if (checkRuns !== null && typeof checkRuns === "object" && !Array.isArray(checkRuns)) {
+            const greptile = checkRuns.greptile_review;
+            if (greptile !== null && greptile !== undefined && typeof greptile === "object") {
+                const g = greptile;
+                const status = typeof g.status === "string" ? g.status : "unknown";
+                const conclusion = typeof g.conclusion === "string" ? g.conclusion : "none";
+                lines.push(`    Greptile Review check: {'status': '${status}', 'conclusion': '${conclusion}'}`);
+            }
+        }
+    }
+    if (isMergeReady(result.failures)) {
+        lines.push("");
+        lines.push("Result: MERGE-READY");
+    }
+    else {
+        const label = result.via !== VIA_ERROR ? "MERGE-BLOCKED" : "EXTERNAL-ERROR";
+        lines.push("");
+        lines.push(`Result: ${label}`);
+        result.failures.forEach((fail, i) => {
+            lines.push(`  [${i + 1}] ${fail}`);
+        });
+        if (result.error !== null) {
+            lines.push("");
+            lines.push(`Underlying error: ${result.error}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function exitCodeFor(result) {
+    if (result.via === VIA_ERROR) {
+        return EXIT_EXTERNAL_ERROR;
+    }
+    return isMergeReady(result.failures) ? EXIT_OK : EXIT_MERGE_BLOCKED;
+}
+//# sourceMappingURL=output.js.map

package/dist/pr-merge-readiness/parse.d.ts

@@ -0,0 +1,6 @@
+import type { GreptileVerdict } from "./types.js";
+export declare function emptyVerdict(): GreptileVerdict;
+export declare function isInformalCleanMissingCanonicalFields(verdict: GreptileVerdict, body: string): boolean;
+/** Parse a Greptile rolling-summary comment body into a structured verdict. */
+export declare function parseGreptileBody(body: string): GreptileVerdict;
+//# sourceMappingURL=parse.d.ts.map

package/dist/pr-merge-readiness/parse.js

@@ -0,0 +1,83 @@
+import { findLastReviewedCommitSha } from "../text/redos-safe.js";
+import { CONFIDENCE_RE, GREPTILE_ERRORED_SENTINEL, INFORMAL_CLEAN_SIGNAL_RE, P0_BADGE, P1_BADGE, SECTION_RE, } from "./constants.js";
+export function emptyVerdict() {
+    return {
+        found: false,
+        errored: false,
+        lastReviewedSha: null,
+        confidence: null,
+        p0Count: 0,
+        p1Count: 0,
+        p2Count: 0,
+        informalClean: false,
+        rawBodyExcerpt: "",
+    };
+}
+export function isInformalCleanMissingCanonicalFields(verdict, body) {
+    if (!verdict.found || verdict.errored) {
+        return false;
+    }
+    if (verdict.lastReviewedSha !== null || verdict.confidence !== null) {
+        return false;
+    }
+    if (verdict.p0Count > 0 || verdict.p1Count > 0) {
+        return false;
+    }
+    return INFORMAL_CLEAN_SIGNAL_RE.test(body);
+}
+function countSubstring(body, needle) {
+    let count = 0;
+    let idx = 0;
+    let found = body.indexOf(needle, idx);
+    while (found !== -1) {
+        count += 1;
+        idx = found + needle.length;
+        found = body.indexOf(needle, idx);
+    }
+    return count;
+}
+/** Parse a Greptile rolling-summary comment body into a structured verdict. */
+export function parseGreptileBody(body) {
+    if (!body?.trim()) {
+        return emptyVerdict();
+    }
+    const errored = body.trim().startsWith(GREPTILE_ERRORED_SENTINEL);
+    const lastReviewedSha = findLastReviewedCommitSha(body);
+    const confMatch = CONFIDENCE_RE.exec(body);
+    const confidence = confMatch?.groups?.score !== undefined ? Number(confMatch.groups.score) : null;
+    let p0Count = countSubstring(body, P0_BADGE);
+    let p1Count = countSubstring(body, P1_BADGE);
+    let p2Count = countSubstring(body, '<img alt="P2"');
+    const hasDetailsFormat = body.includes("<details>");
+    if (!hasDetailsFormat && p0Count === 0 && p1Count === 0) {
+        for (const match of body.matchAll(SECTION_RE)) {
+            const sev = (match.groups?.sev ?? "").toUpperCase();
+            const count = Number(match.groups?.count ?? 0);
+            if (sev === "P0") {
+                p0Count = count;
+            }
+            else if (sev === "P1") {
+                p1Count = count;
+            }
+            else if (sev === "P2" && p2Count === 0) {
+                p2Count = count;
+            }
+        }
+    }
+    const verdict = {
+        found: true,
+        errored,
+        lastReviewedSha,
+        confidence,
+        p0Count,
+        p1Count,
+        p2Count,
+        informalClean: false,
+        rawBodyExcerpt: body.slice(0, 200),
+    };
+    if (isInformalCleanMissingCanonicalFields(verdict, body)) {
+        return { ...verdict, informalClean: true };
+    }
+    return verdict;
+}
+//# sourceMappingURL=parse.js.map

package/dist/pr-merge-readiness/types.d.ts

@@ -0,0 +1,29 @@
+export interface GreptileVerdict {
+    readonly found: boolean;
+    readonly errored: boolean;
+    readonly lastReviewedSha: string | null;
+    readonly confidence: number | null;
+    readonly p0Count: number;
+    readonly p1Count: number;
+    readonly p2Count: number;
+    readonly informalClean: boolean;
+    readonly rawBodyExcerpt: string;
+}
+export interface GateResult {
+    readonly prNumber: number;
+    readonly repo: string | null;
+    readonly headSha: string | null;
+    readonly verdict: GreptileVerdict;
+    readonly failures: readonly string[];
+    readonly via: string;
+    readonly partialData: Readonly<Record<string, unknown>>;
+    readonly error: string | null;
+}
+export interface RunGhResult {
+    readonly returncode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Injectable gh subprocess seam (#1366 / parity harness). */
+export type RunGhFn = (cmd: readonly string[]) => RunGhResult;
+//# sourceMappingURL=types.d.ts.map

package/dist/pr-merge-readiness/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/pr-monitor/cadence.d.ts

@@ -0,0 +1,3 @@
+/** Expand cadence tuple into per-poll interval seconds. */
+export declare function cadenceIntervals(cadence?: ReadonlyArray<readonly [number, number]>): number[];
+//# sourceMappingURL=cadence.d.ts.map

package/dist/pr-monitor/cadence.js

@@ -0,0 +1,12 @@
+import { DEFAULT_CADENCE } from "./constants.js";
+/** Expand cadence tuple into per-poll interval seconds. */
+export function cadenceIntervals(cadence = DEFAULT_CADENCE) {
+    const intervals = [];
+    for (const [interval, repeats] of cadence) {
+        for (let i = 0; i < repeats; i += 1) {
+            intervals.push(interval);
+        }
+    }
+    return intervals;
+}
+//# sourceMappingURL=cadence.js.map

package/dist/pr-monitor/constants.d.ts

@@ -0,0 +1,8 @@
+/** Exit codes mirroring scripts/monitor_pr.py. */
+export declare const EXIT_CLEAN = 0;
+export declare const EXIT_CAP_REACHED = 1;
+export declare const EXIT_CONFIG_ERROR = 2;
+export declare const EXIT_PR_TERMINAL = 3;
+/** Adaptive cadence (seconds, repeats). Last repeat is a soft ceiling. */
+export declare const DEFAULT_CADENCE: ReadonlyArray<readonly [number, number]>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/pr-monitor/constants.js

@@ -0,0 +1,12 @@
+/** Exit codes mirroring scripts/monitor_pr.py. */
+export const EXIT_CLEAN = 0;
+export const EXIT_CAP_REACHED = 1;
+export const EXIT_CONFIG_ERROR = 2;
+export const EXIT_PR_TERMINAL = 3;
+/** Adaptive cadence (seconds, repeats). Last repeat is a soft ceiling. */
+export const DEFAULT_CADENCE = [
+    [60, 3],
+    [180, 3],
+    [300, 99],
+];
+//# sourceMappingURL=constants.js.map

package/dist/pr-monitor/index.d.ts

@@ -0,0 +1,7 @@
+export { cadenceIntervals } from "./cadence.js";
+export { DEFAULT_CADENCE, EXIT_CAP_REACHED, EXIT_CLEAN, EXIT_CONFIG_ERROR, EXIT_PR_TERMINAL, } from "./constants.js";
+export { cmdPrMonitor, parseMonitorArgs, runMonitor } from "./main.js";
+export { formatPollStatus, isTerminalPrState, monitor, summaryLabelForExit } from "./monitor.js";
+export { callReadiness } from "./readiness.js";
+export type { CallReadinessFn, CallReadinessOptions, MonitorOptions, MonitorRunResult, MonotonicClock, PollResult, SleepFn, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/pr-monitor/index.js

@@ -0,0 +1,6 @@
+export { cadenceIntervals } from "./cadence.js";
+export { DEFAULT_CADENCE, EXIT_CAP_REACHED, EXIT_CLEAN, EXIT_CONFIG_ERROR, EXIT_PR_TERMINAL, } from "./constants.js";
+export { cmdPrMonitor, parseMonitorArgs, runMonitor } from "./main.js";
+export { formatPollStatus, isTerminalPrState, monitor, summaryLabelForExit } from "./monitor.js";
+export { callReadiness } from "./readiness.js";
+//# sourceMappingURL=index.js.map

package/dist/pr-monitor/main.d.ts

@@ -0,0 +1,17 @@
+import type { RunGhFn } from "../pr-merge-readiness/types.js";
+import { monitor } from "./monitor.js";
+export interface ParsedMonitorArgs {
+    readonly prNumber: number | null;
+    readonly repo: string | null;
+    readonly capMinutes: number;
+    readonly emitJson: boolean;
+    readonly error?: string;
+}
+export declare function parseMonitorArgs(argv: readonly string[]): ParsedMonitorArgs;
+export interface RunMonitorOptions {
+    readonly runGh?: RunGhFn;
+    readonly monitorFn?: typeof monitor;
+}
+export declare function runMonitor(argv: readonly string[], options?: RunMonitorOptions): number;
+export declare function cmdPrMonitor(argv: readonly string[], options?: RunMonitorOptions): number;
+//# sourceMappingURL=main.d.ts.map

package/dist/pr-monitor/main.js

@@ -0,0 +1,169 @@
+import { EXIT_CONFIG_ERROR } from "./constants.js";
+import { monitor, summaryLabelForExit } from "./monitor.js";
+/** Match Python json.dumps(..., indent=2) default ensure_ascii=True. */
+function pythonJsonDumps(value) {
+    const json = JSON.stringify(value, null, 2);
+    return json.replace(/[\u007f-\uffff]/g, (ch) => {
+        const code = ch.charCodeAt(0);
+        return `\\u${code.toString(16).padStart(4, "0")}`;
+    });
+}
+export function parseMonitorArgs(argv) {
+    let prNumber = null;
+    let repo = null;
+    let capMinutes = 60;
+    let emitJson = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--json") {
+            emitJson = true;
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    prNumber,
+                    repo,
+                    capMinutes,
+                    emitJson,
+                    error: "argument --repo: expected one argument",
+                };
+            }
+            repo = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--repo=")) {
+            repo = arg.slice("--repo=".length);
+        }
+        else if (arg === "--cap-minutes") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    prNumber,
+                    repo,
+                    capMinutes,
+                    emitJson,
+                    error: "argument --cap-minutes: expected one argument",
+                };
+            }
+            const parsed = Number(value);
+            if (!Number.isFinite(parsed)) {
+                return {
+                    prNumber,
+                    repo,
+                    capMinutes,
+                    emitJson,
+                    error: `invalid --cap-minutes value: ${value}`,
+                };
+            }
+            capMinutes = parsed;
+            i += 1;
+        }
+        else if (arg?.startsWith("--cap-minutes=")) {
+            const value = arg.slice("--cap-minutes=".length);
+            const parsed = Number(value);
+            if (!Number.isFinite(parsed)) {
+                return {
+                    prNumber,
+                    repo,
+                    capMinutes,
+                    emitJson,
+                    error: `invalid --cap-minutes value: ${value}`,
+                };
+            }
+            capMinutes = parsed;
+        }
+        else if (arg?.startsWith("-")) {
+            return {
+                prNumber,
+                repo,
+                capMinutes,
+                emitJson,
+                error: `unrecognized arguments: ${arg}`,
+            };
+        }
+        else if (prNumber === null) {
+            const n = Number(arg);
+            if (!Number.isInteger(n) || n <= 0) {
+                return {
+                    prNumber,
+                    repo,
+                    capMinutes,
+                    emitJson,
+                    error: `invalid PR number: ${arg}`,
+                };
+            }
+            prNumber = n;
+        }
+        else {
+            return {
+                prNumber,
+                repo,
+                capMinutes,
+                emitJson,
+                error: `unrecognized arguments: ${arg}`,
+            };
+        }
+    }
+    if (prNumber === null) {
+        return {
+            prNumber,
+            repo,
+            capMinutes,
+            emitJson,
+            error: "the following arguments are required: pr_number",
+        };
+    }
+    return { prNumber, repo, capMinutes, emitJson };
+}
+export function runMonitor(argv, options = {}) {
+    const args = parseMonitorArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`${args.error}\n`);
+        return EXIT_CONFIG_ERROR;
+    }
+    const repo = args.repo ?? process.env.GH_REPO ?? null;
+    if (repo === null || repo.length === 0) {
+        process.stderr.write("Error: --repo OWNER/REPO is required (or set $GH_REPO).\n");
+        return EXIT_CONFIG_ERROR;
+    }
+    const monitorFn = options.monitorFn ?? monitor;
+    const { exitCode, payload, pollCount } = monitorFn(args.prNumber, repo, {
+        capMinutes: args.capMinutes,
+        runGh: options.runGh,
+    });
+    const summaryLabel = summaryLabelForExit(exitCode);
+    const via = typeof payload.via === "string" ? payload.via : "?";
+    process.stderr.write(`[monitor_pr] PR #${args.prNumber} repo=${repo} result=${summaryLabel} ` +
+        `polls=${pollCount} via=${via}\n`);
+    if (args.emitJson) {
+        const envelope = {
+            monitor_result: summaryLabel,
+            polls: pollCount,
+            readiness: payload,
+        };
+        process.stdout.write(`${pythonJsonDumps(envelope)}\n`);
+    }
+    else {
+        const lines = [];
+        lines.push(`PR #${args.prNumber} monitor result: ${summaryLabel}`);
+        lines.push(`  polls: ${pollCount}`);
+        lines.push(`  via:   ${via}`);
+        const err = payload.error;
+        if (typeof err === "string" && err.length > 0) {
+            lines.push(`  error: ${err}`);
+        }
+        const failuresRaw = payload.failures;
+        if (Array.isArray(failuresRaw)) {
+            failuresRaw.forEach((fail, index) => {
+                lines.push(`  [${index + 1}] ${String(fail)}`);
+            });
+        }
+        process.stdout.write(`${lines.join("\n")}\n`);
+    }
+    return exitCode;
+}
+export function cmdPrMonitor(argv, options = {}) {
+    return runMonitor(argv, options);
+}
+//# sourceMappingURL=main.js.map

package/dist/pr-monitor/monitor.d.ts

@@ -0,0 +1,9 @@
+import type { MonitorOptions, MonitorRunResult, PollResult } from "./types.js";
+/** One-line stderr status mirror per poll. */
+export declare function formatPollStatus(pollIndex: number, pollResult: PollResult): string;
+/** Detect merged / closed PR via fallback2 partial_data. */
+export declare function isTerminalPrState(payload: Record<string, unknown>): boolean;
+/** Loop readiness with adaptive cadence until CLEAN / cap / terminal. */
+export declare function monitor(prNumber: number, repo: string, options?: MonitorOptions): MonitorRunResult;
+export declare const summaryLabelForExit: (exitCode: number) => string;
+//# sourceMappingURL=monitor.d.ts.map

package/dist/pr-monitor/monitor.js

@@ -0,0 +1,106 @@
+import { cadenceIntervals } from "./cadence.js";
+import { DEFAULT_CADENCE, EXIT_CAP_REACHED, EXIT_CLEAN, EXIT_CONFIG_ERROR, EXIT_PR_TERMINAL, } from "./constants.js";
+import { callReadiness } from "./readiness.js";
+const systemMonotonicClock = {
+    now() {
+        return performance.now() / 1000;
+    },
+};
+function defaultSleep(seconds) {
+    const start = Date.now();
+    const target = start + seconds * 1000;
+    while (Date.now() < target) {
+        // busy-wait fallback when no injectable sleep in production CLI path
+    }
+}
+/** One-line stderr status mirror per poll. */
+export function formatPollStatus(pollIndex, pollResult) {
+    const payload = pollResult.payload;
+    const via = typeof payload.via === "string" ? payload.via : "?";
+    const mergeReady = payload.merge_ready === true;
+    let headSha = payload.head_sha;
+    if (headSha === null || headSha === undefined) {
+        headSha = "<unknown>";
+    }
+    let headDisplay = String(headSha);
+    if (typeof headDisplay === "string") {
+        headDisplay = headDisplay.slice(0, 12);
+    }
+    const failuresRaw = payload.failures;
+    const failures = Array.isArray(failuresRaw) ? failuresRaw.map(String) : [];
+    const firstFailure = failures[0] ?? "";
+    const label = mergeReady ? "CLEAN" : "BLOCKED";
+    let line = `[monitor_pr] poll #${pollIndex} via=${via} head=${headDisplay} ` +
+        `${label} (${failures.length} failures)`;
+    if (firstFailure.length > 0) {
+        line += ` -- ${firstFailure.slice(0, 80)}`;
+    }
+    return line;
+}
+/** Detect merged / closed PR via fallback2 partial_data. */
+export function isTerminalPrState(payload) {
+    const partialRaw = payload.partial_data;
+    const partial = partialRaw !== null && typeof partialRaw === "object" && !Array.isArray(partialRaw)
+        ? partialRaw
+        : {};
+    return partial.merged === true || partial.pr_state === "closed";
+}
+/** Loop readiness with adaptive cadence until CLEAN / cap / terminal. */
+export function monitor(prNumber, repo, options = {}) {
+    const intervals = cadenceIntervals(options.cadence ?? DEFAULT_CADENCE);
+    const capSeconds = (options.capMinutes ?? 60) * 60;
+    const clockFn = options.clockFn ?? systemMonotonicClock;
+    const sleepFn = options.sleepFn ?? defaultSleep;
+    const callReadinessFn = options.callReadinessFn ?? ((n, r) => callReadiness(n, r, { runGh: options.runGh }));
+    const startedAt = clockFn.now();
+    let pollIndex = 0;
+    let lastPayload = {};
+    let lastExit = EXIT_CAP_REACHED;
+    for (const interval of intervals) {
+        pollIndex += 1;
+        const elapsed = clockFn.now() - startedAt;
+        if (elapsed > capSeconds) {
+            return { exitCode: EXIT_CAP_REACHED, payload: lastPayload, pollCount: pollIndex - 1 };
+        }
+        const pollResult = callReadinessFn(prNumber, repo);
+        lastPayload = pollResult.payload;
+        lastExit = pollResult.exitCode;
+        process.stderr.write(`${formatPollStatus(pollIndex, pollResult)}\n`);
+        if (pollResult.rawStderr.trim().length > 0) {
+            process.stderr.write(pollResult.rawStderr);
+        }
+        const via = lastPayload.via;
+        const mergeReady = lastPayload.merge_ready === true;
+        if (mergeReady && (via === "primary" || via === "fallback1")) {
+            return { exitCode: EXIT_CLEAN, payload: lastPayload, pollCount: pollIndex };
+        }
+        if (isTerminalPrState(lastPayload)) {
+            return { exitCode: EXIT_PR_TERMINAL, payload: lastPayload, pollCount: pollIndex };
+        }
+        if (pollIndex < intervals.length) {
+            const elapsedAfterPoll = clockFn.now() - startedAt;
+            const remaining = capSeconds - elapsedAfterPoll;
+            if (remaining <= 0) {
+                return { exitCode: EXIT_CAP_REACHED, payload: lastPayload, pollCount: pollIndex };
+            }
+            sleepFn(Math.min(interval, Math.max(1, Math.trunc(remaining))));
+        }
+    }
+    const finalExit = lastExit === EXIT_CONFIG_ERROR ? EXIT_CONFIG_ERROR : EXIT_CAP_REACHED;
+    return { exitCode: finalExit, payload: lastPayload, pollCount: pollIndex };
+}
+export const summaryLabelForExit = (exitCode) => {
+    switch (exitCode) {
+        case EXIT_CLEAN:
+            return "CLEAN";
+        case EXIT_CAP_REACHED:
+            return "CAP-REACHED";
+        case EXIT_PR_TERMINAL:
+            return "PR-TERMINAL";
+        case EXIT_CONFIG_ERROR:
+            return "CONFIG-ERROR";
+        default:
+            return "UNKNOWN";
+    }
+};
+//# sourceMappingURL=monitor.js.map

package/dist/pr-monitor/readiness.d.ts

@@ -0,0 +1,6 @@
+import type { CallReadinessOptions, PollResult } from "./types.js";
+/** Run one pr_merge_readiness-equivalent check and parse the verdict JSON. */
+export declare function callReadiness(prNumber: number, repo: string, options?: CallReadinessOptions): PollResult;
+/** Map readiness-layer external errors to monitor poll semantics. */
+export declare function readinessExitToPoll(exitCode: number): number;
+//# sourceMappingURL=readiness.d.ts.map