@deftai/directive-core 0.66.2 → 0.68.0

package/dist/pr-merge-readiness/ci-gate.js

@@ -0,0 +1,79 @@
+const FAILED_CONCLUSIONS = new Set(["failure", "cancelled", "timed_out"]);
+const PENDING_STATUSES = new Set(["queued", "in_progress"]);
+function isPending(status, conclusion) {
+    if (PENDING_STATUSES.has(status)) {
+        return true;
+    }
+    return status !== "completed" || conclusion === "none";
+}
+export function buildCiSummaryLine(summary) {
+    const passed = summary.checked_count - summary.failed_required.length - summary.pending_required.length;
+    return (`CI check-runs: ${passed} passed / ` +
+        `${summary.failed_required.length} failed / ${summary.pending_required.length} pending`);
+}
+export function evaluateCiGate(checkRuns, options = {}) {
+    if (options.skipCi === true) {
+        return {
+            failures: [],
+            summary: {
+                ready_state: "skipped",
+                checked_count: 0,
+                ignored_checks: [],
+                failed_required: [],
+                pending_required: [],
+                conclusions: [],
+            },
+        };
+    }
+    const ignoredSet = new Set(options.ignoreCheckNames ?? []);
+    const ignoredChecks = [];
+    const failedRequired = [];
+    const pendingRequired = [];
+    const conclusions = [];
+    for (const run of checkRuns) {
+        const ignored = ignoredSet.has(run.name);
+        if (ignored) {
+            ignoredChecks.push(run.name);
+        }
+        const required = !ignored;
+        conclusions.push({
+            name: run.name,
+            status: run.status,
+            conclusion: run.conclusion,
+            required,
+            ignored,
+        });
+        if (!required) {
+            continue;
+        }
+        if (FAILED_CONCLUSIONS.has(run.conclusion)) {
+            failedRequired.push(`${run.name} (${run.conclusion})`);
+            continue;
+        }
+        if (isPending(run.status, run.conclusion)) {
+            pendingRequired.push(`${run.name} (${run.status})`);
+        }
+    }
+    const failures = [];
+    if (failedRequired.length > 0) {
+        failures.push(`Required CI check-runs failed: ${failedRequired.join(", ")}. ` +
+            "Required checks fail closed by default (#2169).");
+    }
+    if (pendingRequired.length > 0) {
+        failures.push(`Required CI check-runs still running (not-ready-yet): ${pendingRequired.join(", ")}. ` +
+            "Wait for required checks to finish before merge.");
+    }
+    const readyState = failedRequired.length > 0 ? "blocked" : pendingRequired.length > 0 ? "not_ready_yet" : "ready";
+    return {
+        failures,
+        summary: {
+            ready_state: readyState,
+            checked_count: conclusions.filter((item) => item.required).length,
+            ignored_checks: ignoredChecks,
+            failed_required: failedRequired,
+            pending_required: pendingRequired,
+            conclusions,
+        },
+    };
+}
+//# sourceMappingURL=ci-gate.js.map

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

@@ -1,7 +1,21 @@
+import type { CiGateOptions } from "./ci-gate.js";
 import { isMergeReady } from "./evaluate.js";
+import { type MergeabilitySignal } from "./mergeability.js";
+import type { SlizardGateOptions } from "./slizard-gate.js";
 import type { GateResult, RunGhFn } from "./types.js";
 declare function buildGateResult(prNumber: number, repo: string | null, headSha: string | null, body: string, via: string, partialData?: Record<string, unknown>, error?: string | null): GateResult;
+/** Injectable GitHub-mergeability read seam (#2260) — keeps unit tests hermetic. */
+export type FetchMergeabilityFn = (prNumber: number, repo: string, runGh: RunGhFn) => MergeabilitySignal;
+export interface ComputeGateOptions extends CiGateOptions, SlizardGateOptions {
+    /** Override the GitHub-mergeability read (defaults to the REST reader). */
+    readonly fetchMergeabilityFn?: FetchMergeabilityFn;
+    /**
+     * Disable the #2260 mergeability reconciliation (defaults to enabled). When
+     * off, an absent/stale review verdict blocks even on a GitHub-CLEAN PR.
+     */
+    readonly disableMergeabilityReconcile?: boolean;
+}
 /** Run the primary->fallback1->fallback2 cascade and return a result. */
-export declare function computeGateResult(prNumber: number, repo: string | null, runGh: RunGhFn): GateResult;
+export declare function computeGateResult(prNumber: number, repo: string | null, runGh: RunGhFn, options?: ComputeGateOptions): GateResult;
 export { buildGateResult, isMergeReady };
 //# sourceMappingURL=compute.d.ts.map

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

@@ -1,7 +1,10 @@
+import { buildCiSummaryLine, evaluateCiGate } from "./ci-gate.js";
 import { FALLBACK2_NOT_CLEAN_MSG, VIA_ERROR, VIA_FALLBACK1, VIA_FALLBACK2, VIA_PRIMARY, } from "./constants.js";
 import { evaluateGates, isMergeReady } from "./evaluate.js";
 import { fetchCheckRunsRest, fetchGreptileBodyRest, fetchGreptileCommentBody, fetchPrHeadSha, fetchPrHeadShaRest, resolveRepo, } from "./gh.js";
+import { fetchMergeability, isGithubMergeableClean, mergeabilityToDict, verdictBlockIsSoftOnly, verdictShaIsStale, } from "./mergeability.js";
 import { emptyVerdict, parseGreptileBody } from "./parse.js";
+import { evaluateSlizardGate, isSlizardCheck } from "./slizard-gate.js";
 function buildGateResult(prNumber, repo, headSha, body, via, partialData = {}, error = null) {
     const verdict = parseGreptileBody(body);
     const failures = evaluateGates(prNumber, headSha, verdict);
@@ -16,7 +19,123 @@ function buildGateResult(prNumber, repo, headSha, body, via, partialData = {}, e
         error,
     };
 }
-function computePrimary(prNumber, repo, runGh) {
+/** Run the CI + SLizard gates off a single check-runs fetch (#2169 / #2189). */
+function evaluateCiAndSlizard(checkRuns, options) {
+    const slizardResult = evaluateSlizardGate(checkRuns, options);
+    // The SLizard check is scored by the structured gate, so exclude it from the
+    // generic CI required set to avoid double-counting the same run.
+    const slizardNames = checkRuns.filter((r) => isSlizardCheck(r.name)).map((r) => r.name);
+    const ciOptions = {
+        skipCi: options.skipCi,
+        ignoreCheckNames: [...(options.ignoreCheckNames ?? []), ...slizardNames],
+    };
+    const ciResult = evaluateCiGate(checkRuns, ciOptions);
+    return {
+        failures: [...ciResult.failures, ...slizardResult.failures],
+        ci: { ...ciResult.summary, summary_line: buildCiSummaryLine(ciResult.summary) },
+        slizard: { ...slizardResult.summary },
+    };
+}
+function applyCiGateForHead(repo, headSha, runGh, options) {
+    if (repo === null) {
+        return {
+            failures: [
+                "Could not resolve repo for required CI check-run gate. " +
+                    "Use --repo OWNER/REPO or run from a checked-out repository.",
+            ],
+            ci: {
+                ready_state: "blocked",
+                error: "repo unresolved for check-runs lookup",
+            },
+            slizard: {
+                ready_state: "skipped",
+                present: false,
+                summary_line: "SLizard review: skipped (repo unresolved for check-runs lookup)",
+            },
+        };
+    }
+    // When CI is skipped we do not fetch check-runs, so the SLizard gate cannot
+    // evaluate either; run both gates against an empty set to honor the overrides.
+    if (options.skipCi === true) {
+        const outcome = evaluateCiAndSlizard([], options);
+        outcome.ci.summary_line = "CI check-runs: skipped (--skip-ci)";
+        return { failures: outcome.failures, ci: outcome.ci, slizard: outcome.slizard };
+    }
+    const check = fetchCheckRunsRest(headSha, repo, runGh);
+    if (check.summary === null) {
+        return {
+            failures: [
+                "Required CI check-runs could not be fetched; fail closed by default (#2169). " +
+                    `Root cause: ${check.error}`,
+            ],
+            ci: {
+                ready_state: "blocked",
+                error: check.error,
+                checked_count: 0,
+                ignored_checks: [...(options.ignoreCheckNames ?? [])],
+                failed_required: [],
+                pending_required: [],
+                conclusions: [],
+            },
+            slizard: {
+                ready_state: "skipped",
+                present: false,
+                summary_line: `SLizard review: skipped (check-runs unavailable: ${check.error})`,
+            },
+        };
+    }
+    const outcome = evaluateCiAndSlizard(check.checkRuns, options);
+    return { failures: outcome.failures, ci: outcome.ci, slizard: outcome.slizard };
+}
+/**
+ * Score the verdict gate for a resolved head SHA, then (when the review verdict
+ * is only soft-blocked -- absent or stale for the current head) reconcile
+ * against GitHub's own mergeability (#2260). Shared by primary + fallback1.
+ */
+function finalizeVerdictGate(prNumber, repo, headSha, verdict, runGh, options) {
+    const failures = evaluateGates(prNumber, headSha, verdict);
+    const partialData = {};
+    const resolved = resolveRepo(repo, runGh);
+    if (failures.length === 0) {
+        const ci = applyCiGateForHead(resolved.repo, headSha, runGh, options);
+        failures.push(...ci.failures);
+        partialData.ci = ci.ci;
+        partialData.slizard = ci.slizard;
+        return { failures, partialData };
+    }
+    // #2260 reconciliation: the verdict gate failed. If the block is a HARD
+    // finding (genuine P0/P1, ERRORED, low confidence on the current head), keep
+    // blocking. Only reconcile a SOFT block (verdict absent / stale head SHA).
+    if (options.disableMergeabilityReconcile === true ||
+        resolved.repo === null ||
+        !verdictBlockIsSoftOnly(verdict, headSha)) {
+        return { failures, partialData };
+    }
+    const ci = applyCiGateForHead(resolved.repo, headSha, runGh, options);
+    partialData.ci = ci.ci;
+    partialData.slizard = ci.slizard;
+    const fetchMergeabilityFn = options.fetchMergeabilityFn ?? fetchMergeability;
+    const signal = fetchMergeabilityFn(prNumber, resolved.repo, runGh);
+    partialData.mergeability = mergeabilityToDict(signal);
+    if (isGithubMergeableClean(signal)) {
+        // GitHub itself reports CLEAN + MERGEABLE: required checks are green and the
+        // branch is mergeable. Proceed even though the OPTIONAL review verdict is
+        // absent/stale for the head SHA -- exactly the manual `gh pr merge --admin`
+        // case this fix reproduces automatically (#2260).
+        partialData.verdict_override = {
+            reason: verdictShaIsStale(verdict, headSha) ? "verdict-stale-head-sha" : "verdict-absent",
+            basis: "github mergeable_state=clean + mergeable=true (mergeStateStatus:CLEAN + " +
+                "mergeable:MERGEABLE); required checks green per GitHub branch protection (#2260)",
+            overridden_failures: [...failures],
+        };
+        return { failures: [], partialData };
+    }
+    // Not overridable (GitHub not CLEAN/MERGEABLE). Preserve the soft verdict
+    // failures and surface any CI failures so the heartbeat's blocked-on is clear.
+    failures.push(...ci.failures);
+    return { failures, partialData };
+}
+function computePrimary(prNumber, repo, runGh, options) {
     const partial = {};
     const headSha = fetchPrHeadSha(prNumber, repo, runGh);
     if (headSha === null) {
@@ -30,7 +149,7 @@ function computePrimary(prNumber, repo, runGh) {
         return { result: null, partial };
     }
     const verdict = parseGreptileBody(body);
-    const failures = evaluateGates(prNumber, headSha, verdict);
+    const { failures, partialData } = finalizeVerdictGate(prNumber, repo, headSha, verdict, runGh, options);
     return {
         result: {
             prNumber,
@@ -39,13 +158,13 @@ function computePrimary(prNumber, repo, runGh) {
             verdict,
             failures,
             via: VIA_PRIMARY,
-            partialData: {},
+            partialData,
             error: null,
         },
         partial,
     };
 }
-function computeFallback1(prNumber, repo, primaryPartial, runGh) {
+function computeFallback1(prNumber, repo, primaryPartial, runGh, options) {
     const partial = { ...primaryPartial };
     const resolved = resolveRepo(repo, runGh);
     if (resolved.repo === null) {
@@ -68,20 +187,21 @@ function computeFallback1(prNumber, repo, primaryPartial, runGh) {
         return { result: null, partial };
     }
     const verdict = parseGreptileBody(bodyResult.body);
-    const failures = evaluateGates(prNumber, headSha, verdict);
+    const gate = finalizeVerdictGate(prNumber, resolved.repo, headSha, verdict, runGh, options);
     const partialData = {};
     for (const [key, value] of Object.entries(partial)) {
         if (key !== "head_sha") {
             partialData[key] = value;
         }
     }
+    Object.assign(partialData, gate.partialData);
     return {
         result: {
             prNumber,
             repo: resolved.repo,
             headSha,
             verdict,
-            failures,
+            failures: gate.failures,
             via: VIA_FALLBACK1,
             partialData,
             error: null,
@@ -191,12 +311,12 @@ function errorResult(prNumber, repo, partial) {
     };
 }
 /** Run the primary->fallback1->fallback2 cascade and return a result. */
-export function computeGateResult(prNumber, repo, runGh) {
-    let { result, partial } = computePrimary(prNumber, repo, runGh);
+export function computeGateResult(prNumber, repo, runGh, options = {}) {
+    let { result, partial } = computePrimary(prNumber, repo, runGh, options);
     if (result !== null) {
         return result;
     }
-    ({ result, partial } = computeFallback1(prNumber, repo, partial, runGh));
+    ({ result, partial } = computeFallback1(prNumber, repo, partial, runGh, options));
     if (result !== null) {
         return result;
     }

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

@@ -1,4 +1,11 @@
 import type { RunGhFn, RunGhResult } from "./types.js";
+export interface CheckRunRecord {
+    readonly name: string;
+    readonly status: string;
+    readonly conclusion: string;
+    /** check-run `output.summary` text, when present (used by the SLizard verdict gate, #2189). */
+    readonly summary?: string;
+}
 /** UTF-8-safe gh capture via execFile (no shell) — mirrors _safe_subprocess.run_text (#1366). */
 export declare function defaultRunGh(cmd: readonly string[]): RunGhResult;
 export declare function fetchPrHeadSha(prNumber: number, repo: string | null, runGh: RunGhFn): string | null;
@@ -17,6 +24,7 @@ export declare function fetchPrHeadShaRest(prNumber: number, repo: string, runGh
 };
 export declare function fetchCheckRunsRest(sha: string, repo: string, runGh: RunGhFn): {
     summary: Record<string, unknown> | null;
+    checkRuns: CheckRunRecord[];
     error: string;
 };
 //# sourceMappingURL=gh.d.ts.map

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

@@ -229,16 +229,30 @@ export function fetchPrHeadShaRest(prNumber, repo, runGh) {
     }
     return { sha: null, error: "PR JSON missing head.sha" };
 }
+/** Pull the `output.summary` string off a raw check-run payload, if present (#2189). */
+function extractCheckRunSummary(run) {
+    const output = run.output;
+    if (output === null || typeof output !== "object" || Array.isArray(output)) {
+        return null;
+    }
+    const summary = output.summary;
+    return typeof summary === "string" && summary.length > 0 ? summary : null;
+}
 export function fetchCheckRunsRest(sha, repo, runGh) {
     const rc = runGh(["gh", "api", `repos/${repo}/commits/${sha}/check-runs`]);
     if (rc.returncode !== 0) {
         return {
             summary: null,
+            checkRuns: [],
             error: `gh api /commits/${"<"}sha>/check-runs failed: ${rc.stderr.trim()}`,
         };
     }
     if (!rc.stdout.trim()) {
-        return { summary: null, error: "empty body from gh api /commits/<sha>/check-runs" };
+        return {
+            summary: null,
+            checkRuns: [],
+            error: "empty body from gh api /commits/<sha>/check-runs",
+        };
     }
     let payload;
     try {
@@ -246,20 +260,22 @@ export function fetchCheckRunsRest(sha, repo, runGh) {
     }
     catch (exc) {
         const message = exc instanceof Error ? exc.message : String(exc);
-        return { summary: null, error: `could not parse check-runs JSON: ${message}` };
+        return { summary: null, checkRuns: [], error: `could not parse check-runs JSON: ${message}` };
     }
     if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
-        return { summary: null, error: "unexpected check-runs JSON shape (not a dict)" };
+        return { summary: null, checkRuns: [], error: "unexpected check-runs JSON shape (not a dict)" };
     }
     const runs = payload.check_runs;
     if (!Array.isArray(runs)) {
-        return { summary: null, error: "check-runs JSON missing check_runs list" };
+        return { summary: null, checkRuns: [], error: "check-runs JSON missing check_runs list" };
     }
+    const checkRuns = [];
     const summary = {
         total: runs.length,
         by_status: {},
         by_conclusion: {},
         greptile_review: null,
+        slizard_review: null,
     };
     const byStatus = summary.by_status;
     const byConclusion = summary.by_conclusion;
@@ -270,12 +286,21 @@ export function fetchCheckRunsRest(sha, repo, runGh) {
         const r = run;
         const status = typeof r.status === "string" ? r.status : "unknown";
         const conclusion = typeof r.conclusion === "string" ? r.conclusion : "none";
+        const name = typeof r.name === "string" && r.name.length > 0 ? r.name : "<unnamed>";
+        const runSummary = extractCheckRunSummary(r);
+        const record = runSummary === null
+            ? { name, status, conclusion }
+            : { name, status, conclusion, summary: runSummary };
+        checkRuns.push(record);
         byStatus[status] = (byStatus[status] ?? 0) + 1;
         byConclusion[conclusion] = (byConclusion[conclusion] ?? 0) + 1;
         if (r.name === "Greptile Review") {
             summary.greptile_review = { status, conclusion };
         }
+        if (name.toLowerCase().includes("slizard")) {
+            summary.slizard_review = { status, conclusion };
+        }
     }
-    return { summary, error: "" };
+    return { summary, checkRuns, error: "" };
 }
 //# sourceMappingURL=gh.js.map

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

@@ -1,9 +1,13 @@
-export { computeGateResult } from "./compute.js";
+export { buildCiSummaryLine, evaluateCiGate } from "./ci-gate.js";
+export { type ComputeGateOptions, computeGateResult, type FetchMergeabilityFn } from "./compute.js";
 export * from "./constants.js";
 export { evaluateGates, isMergeReady } from "./evaluate.js";
 export { defaultRunGh } from "./gh.js";
 export { cmdPrMergeReadiness, parseArgs, run } from "./main.js";
+export { fetchMergeability, isGithubMergeableClean, MERGE_STATE_CLEAN, type MergeabilitySignal, mergeabilityToDict, verdictBlockIsSoftOnly, verdictShaIsStale, } from "./mergeability.js";
 export { emitJson, exitCodeFor, gateResultToDict, printHuman } from "./output.js";
 export { emptyVerdict, isInformalCleanMissingCanonicalFields, parseGreptileBody } from "./parse.js";
+export type { SlizardGateOptions, SlizardGateResult, SlizardGateSummary, SlizardVerdict, } from "./slizard-gate.js";
+export { evaluateSlizardGate, isSlizardCheck, parseSlizardVerdict, SLIZARD_CHECK_NAME, } from "./slizard-gate.js";
 export type { GateResult, GreptileVerdict, RunGhFn, RunGhResult } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,8 +1,11 @@
+export { buildCiSummaryLine, evaluateCiGate } from "./ci-gate.js";
 export { computeGateResult } from "./compute.js";
 export * from "./constants.js";
 export { evaluateGates, isMergeReady } from "./evaluate.js";
 export { defaultRunGh } from "./gh.js";
 export { cmdPrMergeReadiness, parseArgs, run } from "./main.js";
+export { fetchMergeability, isGithubMergeableClean, MERGE_STATE_CLEAN, mergeabilityToDict, verdictBlockIsSoftOnly, verdictShaIsStale, } from "./mergeability.js";
 export { emitJson, exitCodeFor, gateResultToDict, printHuman } from "./output.js";
 export { emptyVerdict, isInformalCleanMissingCanonicalFields, parseGreptileBody } from "./parse.js";
+export { evaluateSlizardGate, isSlizardCheck, parseSlizardVerdict, SLIZARD_CHECK_NAME, } from "./slizard-gate.js";
 //# sourceMappingURL=index.js.map

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

@@ -3,6 +3,9 @@ export interface ParsedArgs {
     readonly prNumber: number | null;
     readonly repo: string | null;
     readonly emitJson: boolean;
+    readonly skipCi: boolean;
+    readonly skipSlizard: boolean;
+    readonly ciIgnoreChecks: readonly string[];
     readonly error?: string;
 }
 export declare function parseArgs(argv: readonly string[]): ParsedArgs;

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

@@ -5,15 +5,51 @@ export function parseArgs(argv) {
     let prNumber = null;
     let repo = null;
     let json = false;
+    let skipCi = false;
+    let skipSlizard = false;
+    const ciIgnoreChecks = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === "--json") {
             json = true;
         }
+        else if (arg === "--skip-ci") {
+            skipCi = true;
+        }
+        else if (arg === "--skip-slizard") {
+            skipSlizard = true;
+        }
+        else if (arg === "--ci-ignore-check") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    prNumber,
+                    repo,
+                    emitJson: json,
+                    skipCi,
+                    skipSlizard,
+                    ciIgnoreChecks,
+                    error: "argument --ci-ignore-check: expected one argument",
+                };
+            }
+            ciIgnoreChecks.push(value);
+            i += 1;
+        }
+        else if (arg?.startsWith("--ci-ignore-check=")) {
+            ciIgnoreChecks.push(arg.slice("--ci-ignore-check=".length));
+        }
         else if (arg === "--repo") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return { prNumber, repo, emitJson: json, error: "argument --repo: expected one argument" };
+                return {
+                    prNumber,
+                    repo,
+                    emitJson: json,
+                    skipCi,
+                    skipSlizard,
+                    ciIgnoreChecks,
+                    error: "argument --repo: expected one argument",
+                };
             }
             repo = value;
             i += 1;
@@ -22,17 +58,41 @@ export function parseArgs(argv) {
             repo = arg.slice("--repo=".length);
         }
         else if (arg?.startsWith("-")) {
-            return { prNumber, repo, emitJson: json, error: `unrecognized arguments: ${arg}` };
+            return {
+                prNumber,
+                repo,
+                emitJson: json,
+                skipCi,
+                skipSlizard,
+                ciIgnoreChecks,
+                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}` };
+                return {
+                    prNumber,
+                    repo,
+                    emitJson: json,
+                    skipCi,
+                    skipSlizard,
+                    ciIgnoreChecks,
+                    error: `invalid PR number: ${arg}`,
+                };
             }
             prNumber = n;
         }
         else {
-            return { prNumber, repo, emitJson: json, error: `unrecognized arguments: ${arg}` };
+            return {
+                prNumber,
+                repo,
+                emitJson: json,
+                skipCi,
+                skipSlizard,
+                ciIgnoreChecks,
+                error: `unrecognized arguments: ${arg}`,
+            };
         }
     }
     if (prNumber === null) {
@@ -40,10 +100,13 @@ export function parseArgs(argv) {
             prNumber,
             repo,
             emitJson: json,
+            skipCi,
+            skipSlizard,
+            ciIgnoreChecks,
             error: "the following arguments are required: pr_number",
         };
     }
-    return { prNumber, repo, emitJson: json };
+    return { prNumber, repo, emitJson: json, skipCi, skipSlizard, ciIgnoreChecks };
 }
 export function run(argv, options = {}) {
     const args = parseArgs(argv);
@@ -52,7 +115,11 @@ export function run(argv, options = {}) {
         return 2;
     }
     const runGh = options.runGh ?? defaultRunGh;
-    const result = computeGateResult(args.prNumber, args.repo, runGh);
+    const result = computeGateResult(args.prNumber, args.repo, runGh, {
+        skipCi: args.skipCi,
+        skipSlizard: args.skipSlizard,
+        ignoreCheckNames: args.ciIgnoreChecks,
+    });
     if (args.emitJson) {
         process.stdout.write(emitJson(result));
     }

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

@@ -0,0 +1,43 @@
+import type { GreptileVerdict, RunGhFn } from "./types.js";
+/**
+ * GitHub's authoritative mergeability signal, read over REST (#2260).
+ *
+ * REST `mergeable_state` maps 1:1 to GraphQL `mergeStateStatus`
+ * (e.g. `"clean"` == `CLEAN`); `mergeable` (boolean|null) maps to
+ * `mergeable` (`MERGEABLE`/`CONFLICTING`/`UNKNOWN`). We read REST to honor
+ * the "prefer REST over GraphQL" rule (#954) and to reuse the same
+ * `gh api repos/<owner>/<repo>/pulls/<N>` surface fallback2 already uses.
+ */
+export interface MergeabilitySignal {
+    readonly mergeableState: string | null;
+    readonly mergeable: boolean | null;
+    readonly error: string | null;
+}
+/** REST `mergeable_state` value that mirrors GraphQL `mergeStateStatus: CLEAN`. */
+export declare const MERGE_STATE_CLEAN = "clean";
+/**
+ * Read GitHub's own mergeability verdict for a PR over REST.
+ *
+ * Injectable via `runGh` so unit tests stay hermetic (no live network).
+ */
+export declare function fetchMergeability(prNumber: number, repo: string, runGh: RunGhFn): MergeabilitySignal;
+/** True when GitHub itself reports the PR as CLEAN + MERGEABLE (#2260). */
+export declare function isGithubMergeableClean(signal: MergeabilitySignal): boolean;
+/** Serialise the mergeability signal into the partial_data envelope shape. */
+export declare function mergeabilityToDict(signal: MergeabilitySignal): Record<string, unknown>;
+/** True when a parsed verdict SHA does not match the current PR head SHA. */
+export declare function verdictShaIsStale(verdict: GreptileVerdict, headSha: string | null): boolean;
+/**
+ * Classify whether the verdict-based merge block is ONLY "soft" (#2260).
+ *
+ * A soft block means the review verdict is absent or pinned to a prior head
+ * SHA (rebased staleness) -- i.e. the review has not spoken about the CURRENT
+ * head. It is safe to reconcile a soft block against GitHub mergeability.
+ *
+ * A HARD block -- a genuine P0/P1 finding, an ERRORED review, or a low
+ * confidence score on the current head -- is NEVER soft; those must keep
+ * blocking regardless of GitHub mergeability (guardrail: do not merge a PR
+ * with a real P0/P1 review finding).
+ */
+export declare function verdictBlockIsSoftOnly(verdict: GreptileVerdict, headSha: string | null): boolean;
+//# sourceMappingURL=mergeability.d.ts.map