@deftai/directive-core 0.96.0 → 0.98.0

package/dist/policy/index.js

@@ -1,5 +1,7 @@
 import { FIELD_HOST_SKILL_DISCOVERY, FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS, inspectHostSkillDiscovery, } from "../init-deposit/skill-discovery-hosts.js";
 import { FIELD_OPENCLAW_PRODUCT_COMMANDS, FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS, inspectOpenClawProductCommands, } from "../slash/openclaw-deposit.js";
+import { FIELD_CHECK_RESUME, FIELD_CHECK_RESUME_CLI_ALIAS, inspectCheckResume, } from "./check-resume.js";
+import { FIELD_COVERAGE_DEBT, FIELD_COVERAGE_DEBT_CLI_ALIAS, inspectCoverageDebt, } from "./coverage-debt.js";
 import { FIELD_DELIVERY_BRANCH, FIELD_DELIVERY_BRANCH_CLI_ALIAS, inspectDeliveryBranch, } from "./delivery-branch.js";
 import { FIELD_HOST_HOOKS, FIELD_HOST_HOOKS_CLI_ALIAS, inspectHostHooks } from "./host-hooks.js";
 import { FIELD_HOST_SLASH_COMMANDS, FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS, inspectHostSlashCommands, } from "./host-slash-commands.js";
@@ -16,6 +18,9 @@ import { DEFAULT_WIP_CAP } from "./wip.js";
 export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
 export * from "./capacity.js";
+export * from "./check-resume.js";
+export * from "./coverage-check-resume-presets.js";
+export * from "./coverage-debt.js";
 export * from "./decisions.js";
 export * from "./deft-directive-disable.js";
 export * from "./delivery-branch.js";
@@ -295,6 +300,24 @@ function inspectValueFeedbackField(data, projectRoot) {
         source: field.source,
     };
 }
+function inspectCoverageDebtField(data, projectRoot) {
+    const field = inspectCoverageDebt(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectCheckResumeField(data, projectRoot) {
+    const field = inspectCheckResume(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 function inspectStalenessTicklerField(data) {
     const field = inspectStalenessTickler(data);
     return {
@@ -408,6 +431,8 @@ const REGISTERED_POLICIES = [
     inspectRuntimeAuthorityField,
     inspectProductSignalField,
     inspectValueFeedbackField,
+    inspectCoverageDebtField,
+    inspectCheckResumeField,
     inspectRequireHumanMergeField,
     inspectHotfixCriteriaField,
 ];
@@ -422,27 +447,31 @@ export function inspectOnePolicy(name, projectRoot) {
         ? FIELD_VALUE_FEEDBACK
         : name === FIELD_PRODUCT_SIGNAL_CLI_ALIAS
             ? FIELD_PRODUCT_SIGNAL
-            : name === FIELD_STALENESS_TICKLER_CLI_ALIAS
-                ? FIELD_STALENESS_TICKLER
-                : name === FIELD_RUNTIME_AUTHORITY_CLI_ALIAS
-                    ? FIELD_RUNTIME_AUTHORITY
-                    : name === FIELD_HOST_HOOKS_CLI_ALIAS
-                        ? FIELD_HOST_HOOKS
-                        : name === FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS
-                            ? FIELD_HOST_SLASH_COMMANDS
-                            : name === FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS
-                                ? FIELD_OPENCLAW_PRODUCT_COMMANDS
-                                : name === FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS
-                                    ? FIELD_HOST_SKILL_DISCOVERY
-                                    : name === FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS
-                                        ? FIELD_REQUIRE_HUMAN_MERGE
-                                        : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
-                                            ? FIELD_HOTFIX_CRITERIA
-                                            : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
-                                                ? FIELD_DELIVERY_BRANCH
-                                                : name === FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS
-                                                    ? FIELD_MIN_GREPTILE_CONFIDENCE
-                                                    : name;
+            : name === FIELD_COVERAGE_DEBT_CLI_ALIAS
+                ? FIELD_COVERAGE_DEBT
+                : name === FIELD_CHECK_RESUME_CLI_ALIAS
+                    ? FIELD_CHECK_RESUME
+                    : name === FIELD_STALENESS_TICKLER_CLI_ALIAS
+                        ? FIELD_STALENESS_TICKLER
+                        : name === FIELD_RUNTIME_AUTHORITY_CLI_ALIAS
+                            ? FIELD_RUNTIME_AUTHORITY
+                            : name === FIELD_HOST_HOOKS_CLI_ALIAS
+                                ? FIELD_HOST_HOOKS
+                                : name === FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS
+                                    ? FIELD_HOST_SLASH_COMMANDS
+                                    : name === FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS
+                                        ? FIELD_OPENCLAW_PRODUCT_COMMANDS
+                                        : name === FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS
+                                            ? FIELD_HOST_SKILL_DISCOVERY
+                                            : name === FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS
+                                                ? FIELD_REQUIRE_HUMAN_MERGE
+                                                : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
+                                                    ? FIELD_HOTFIX_CRITERIA
+                                                    : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
+                                                        ? FIELD_DELIVERY_BRANCH
+                                                        : name === FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS
+                                                            ? FIELD_MIN_GREPTILE_CONFIDENCE
+                                                            : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/pr-merge-readiness/ci-gate.d.ts

@@ -1,5 +1,21 @@
 import type { CheckRunRecord } from "./gh.js";
-export type CiReadyState = "ready" | "blocked" | "not_ready_yet" | "runner_capacity_stall" | "skipped";
+/**
+ * Bot-reviewer check-runs are not CI workflow jobs. Presence of only these
+ * (or empty check-runs) is the `ci_never_scheduled` weather signal (#3167).
+ */
+export declare function isBotReviewCheck(name: string): boolean;
+/**
+ * Suite family for cancelled↔green sibling matching (#3167 / Greptile P1).
+ * Unrelated greens (CodeQL, Socket, …) must not clear a cancelled TypeScript/Go lane.
+ * Returns null when the check is not a TS/Go CI suite job.
+ */
+export declare function suiteFamilyOf(name: string): "typescript" | "go" | null;
+/**
+ * Branch-protection SoT aggregators only (#3168 map). Primary/failover lanes are
+ * not authoritative: a green primary must not clear a cancelled aggregator.
+ */
+export declare function isAuthoritativeSuiteAggregator(name: string): boolean;
+export type CiReadyState = "ready" | "blocked" | "ci_failures" | "not_ready_yet" | "runner_capacity_stall" | "ci_never_scheduled" | "ci_cancelled_no_failover" | "skipped";
 export interface CiGateOptions {
     readonly skipCi?: boolean;
     readonly ignoreCheckNames?: readonly string[];
@@ -23,6 +39,8 @@ export interface CiGateSummary {
     readonly pending_required: readonly string[];
     /** Required checks classified as capacity-stalled (#2672). */
     readonly capacity_stalled_required: readonly string[];
+    /** Required checks cancelled without a green failover sibling (#3167). */
+    readonly cancelled_required: readonly string[];
     readonly conclusions: readonly CiCheckConclusion[];
 }
 export interface CiGateResult {
@@ -30,5 +48,15 @@ export interface CiGateResult {
     readonly summary: CiGateSummary;
 }
 export declare function buildCiSummaryLine(summary: CiGateSummary): string;
+/**
+ * Classify required CI weather for a HEAD check-run list (#2169 / #2672 / #3167).
+ *
+ * Distinct ready_state codes:
+ * - `ci_never_scheduled` — no CI workflow check-runs (bots alone / empty)
+ * - `runner_capacity_stall` — queued past budget, no runner claimed
+ * - `ci_failures` — completed failure / timed_out with product evidence
+ * - `ci_cancelled_no_failover` — only cancelled failures; no green failover
+ * - `not_ready_yet` / `ready` / `blocked` / `skipped` — legacy + residual
+ */
 export declare function evaluateCiGate(checkRuns: readonly CheckRunRecord[], options?: CiGateOptions): CiGateResult;
 //# sourceMappingURL=ci-gate.d.ts.map

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

@@ -1,45 +1,137 @@
 import { classifyCapacityStalledRequired, DEFAULT_CAPACITY_STALL_MS, } from "./runner-capacity-stall.js";
-const FAILED_CONCLUSIONS = new Set(["failure", "cancelled", "timed_out"]);
+/** Real product/test failures (distinct from cancelled primaries, #3167). */
+const FAILURE_CONCLUSIONS = new Set(["failure", "timed_out"]);
+/** Capacity/outage cancels where failover may have been skipped (#3167). */
+const CANCELLED_CONCLUSIONS = new Set(["cancelled"]);
 const PENDING_STATUSES = new Set(["queued", "in_progress"]);
+/** Non-blocking completed conclusions for general ready/pending accounting. */
+const SUCCESS_CONCLUSIONS = new Set(["success", "neutral", "skipped"]);
+/**
+ * Only true success clears a cancelled suite lane. `skipped` / `neutral` are
+ * not executed green failover evidence (#3167 Greptile P1).
+ */
+const AUTHORITATIVE_CLEAR_CONCLUSIONS = new Set(["success"]);
+/**
+ * Bot-reviewer check-runs are not CI workflow jobs. Presence of only these
+ * (or empty check-runs) is the `ci_never_scheduled` weather signal (#3167).
+ */
+export function isBotReviewCheck(name) {
+    const n = name.toLowerCase();
+    return n.includes("greptile") || n.includes("slizard") || n.includes("coderabbit");
+}
+/**
+ * Suite family for cancelled↔green sibling matching (#3167 / Greptile P1).
+ * Unrelated greens (CodeQL, Socket, …) must not clear a cancelled TypeScript/Go lane.
+ * Returns null when the check is not a TS/Go CI suite job.
+ */
+export function suiteFamilyOf(name) {
+    const n = name.toLowerCase();
+    if (n.includes("typescript") || n.includes("type script")) {
+        return "typescript";
+    }
+    // "Go (…)" primary/failover/aggregator; avoid bare "go" false positives (e.g. CodeQL go analyze).
+    if (/\bgo\s*\(/.test(n) || n.startsWith("go ") || n === "go") {
+        return "go";
+    }
+    return null;
+}
+/**
+ * Branch-protection SoT aggregators only (#3168 map). Primary/failover lanes are
+ * not authoritative: a green primary must not clear a cancelled aggregator.
+ */
+export function isAuthoritativeSuiteAggregator(name) {
+    const n = name.toLowerCase().trim();
+    if (n.includes("primary") || n.includes("failover") || n.includes("blacksmith")) {
+        return false;
+    }
+    if (n === "typescript (build + lint + test)") {
+        return true;
+    }
+    if (n === "go (test + build)") {
+        return true;
+    }
+    // Tolerate minor naming drift while excluding lane suffixes.
+    if (suiteFamilyOf(name) === "typescript" &&
+        n.includes("build") &&
+        n.includes("lint") &&
+        n.includes("test")) {
+        return true;
+    }
+    if (suiteFamilyOf(name) === "go" && n.includes("test") && n.includes("build")) {
+        return true;
+    }
+    return false;
+}
 function isPending(status, conclusion) {
     if (PENDING_STATUSES.has(status)) {
         return true;
     }
     return status !== "completed" || conclusion === "none";
 }
+function emptySummary(readyState, ignored = []) {
+    return {
+        ready_state: readyState,
+        checked_count: 0,
+        ignored_checks: ignored,
+        failed_required: [],
+        pending_required: [],
+        capacity_stalled_required: [],
+        cancelled_required: [],
+        conclusions: [],
+    };
+}
 export function buildCiSummaryLine(summary) {
     const passed = summary.checked_count - summary.failed_required.length - summary.pending_required.length;
     const stallSuffix = summary.capacity_stalled_required.length > 0
         ? ` / ${summary.capacity_stalled_required.length} capacity-stalled`
         : "";
+    const cancelSuffix = summary.cancelled_required.length > 0
+        ? ` / ${summary.cancelled_required.length} cancelled`
+        : "";
+    const weather = summary.ready_state === "ci_never_scheduled"
+        ? " (ci_never_scheduled)"
+        : summary.ready_state === "ci_cancelled_no_failover"
+            ? " (ci_cancelled_no_failover)"
+            : summary.ready_state === "ci_failures"
+                ? " (ci_failures)"
+                : "";
     return (`CI check-runs: ${passed} passed / ` +
         `${summary.failed_required.length} failed / ${summary.pending_required.length} pending` +
-        stallSuffix);
+        stallSuffix +
+        cancelSuffix +
+        weather);
 }
+/**
+ * Classify required CI weather for a HEAD check-run list (#2169 / #2672 / #3167).
+ *
+ * Distinct ready_state codes:
+ * - `ci_never_scheduled` — no CI workflow check-runs (bots alone / empty)
+ * - `runner_capacity_stall` — queued past budget, no runner claimed
+ * - `ci_failures` — completed failure / timed_out with product evidence
+ * - `ci_cancelled_no_failover` — only cancelled failures; no green failover
+ * - `not_ready_yet` / `ready` / `blocked` / `skipped` — legacy + residual
+ */
 export function evaluateCiGate(checkRuns, options = {}) {
     if (options.skipCi === true) {
         return {
             failures: [],
-            summary: {
-                ready_state: "skipped",
-                checked_count: 0,
-                ignored_checks: [],
-                failed_required: [],
-                pending_required: [],
-                capacity_stalled_required: [],
-                conclusions: [],
-            },
+            summary: emptySummary("skipped"),
         };
     }
     const ignoredSet = new Set(options.ignoreCheckNames ?? []);
     const ignoredChecks = [];
-    const failedRequired = [];
+    const failedProduct = [];
+    const cancelledRequired = [];
     const pendingRequired = [];
     const pendingProbes = [];
     const conclusions = [];
+    let workflowCheckCount = 0;
+    let operatorIgnoredOnly = false;
     for (const run of checkRuns) {
-        const ignored = ignoredSet.has(run.name);
-        if (ignored) {
+        const botReview = isBotReviewCheck(run.name);
+        const operatorIgnored = ignoredSet.has(run.name);
+        const ignored = operatorIgnored || botReview;
+        if (operatorIgnored) {
             ignoredChecks.push(run.name);
         }
         const required = !ignored;
@@ -53,8 +145,16 @@ export function evaluateCiGate(checkRuns, options = {}) {
         if (!required) {
             continue;
         }
-        if (FAILED_CONCLUSIONS.has(run.conclusion)) {
-            failedRequired.push(`${run.name} (${run.conclusion})`);
+        workflowCheckCount += 1;
+        if (run.status === "completed" && SUCCESS_CONCLUSIONS.has(run.conclusion)) {
+            continue;
+        }
+        if (FAILURE_CONCLUSIONS.has(run.conclusion)) {
+            failedProduct.push(`${run.name} (${run.conclusion})`);
+            continue;
+        }
+        if (CANCELLED_CONCLUSIONS.has(run.conclusion)) {
+            cancelledRequired.push(`${run.name} (${run.conclusion})`);
             continue;
         }
         if (isPending(run.status, run.conclusion)) {
@@ -62,23 +162,48 @@ export function evaluateCiGate(checkRuns, options = {}) {
             pendingProbes.push(run);
         }
     }
+    // Operator --ci-ignore-check on every non-bot run is intentional, not weather.
+    operatorIgnoredOnly =
+        workflowCheckCount === 0 &&
+            checkRuns.some((r) => ignoredSet.has(r.name) && !isBotReviewCheck(r.name));
+    // #3167: no workflow CI check-runs at all (empty list or bots-only) → never scheduled.
+    // Distinct from "all remaining checks operator-ignored" (legacy ready).
+    if (workflowCheckCount === 0 && !operatorIgnoredOnly) {
+        return {
+            failures: [
+                "Required CI workflow check-runs never scheduled (ci_never_scheduled): " +
+                    "no non-bot check-run for the current HEAD. " +
+                    "Do not multi-hour empty-commit thrash; emit BLOCKED after thrash caps (#3167).",
+            ],
+            summary: {
+                ready_state: "ci_never_scheduled",
+                checked_count: 0,
+                ignored_checks: ignoredChecks,
+                failed_required: [],
+                pending_required: [],
+                capacity_stalled_required: [],
+                cancelled_required: [],
+                conclusions,
+            },
+        };
+    }
     const stallOpts = {
         budgetMs: options.capacityStallBudgetMs ?? DEFAULT_CAPACITY_STALL_MS,
         nowMs: options.nowMs,
     };
     const capacityStalledRequired = classifyCapacityStalledRequired(pendingProbes, stallOpts);
     const failures = [];
-    if (failedRequired.length > 0) {
-        failures.push(`Required CI check-runs failed: ${failedRequired.join(", ")}. ` +
-            "Required checks fail closed by default (#2169).");
-    }
     let readyState;
-    if (failedRequired.length > 0) {
-        readyState = "blocked";
+    // Blocking failures listed for merge-ready / clean-gate (not diagnostic-only cancels).
+    let failedRequired = [];
+    if (failedProduct.length > 0) {
+        readyState = "ci_failures";
+        failedRequired = [...failedProduct, ...cancelledRequired];
+        failures.push(`Required CI check-runs failed (ci_failures): ${failedProduct.join(", ")}. ` +
+            "Required checks fail closed by default (#2169 / #3167).");
     }
     else if (pendingRequired.length > 0) {
-        // Capacity stall when every pending required check is a queue stall past
-        // budget — distinct from ordinary not_ready_yet (under budget / in_progress).
+        // Pending wins over cancelled siblings (failover may still be arming).
         const allPendingStalled = capacityStalledRequired.length > 0 && capacityStalledRequired.length === pendingProbes.length;
         if (allPendingStalled) {
             readyState = "runner_capacity_stall";
@@ -93,6 +218,47 @@ export function evaluateCiGate(checkRuns, options = {}) {
                 "Wait for required checks to finish before merge.");
         }
     }
+    else if (cancelledRequired.length > 0) {
+        // Cancelled suite jobs clear only when a NON-IGNORED AUTHORITATIVE aggregator
+        // for that suite family is green (#3167 Greptile P1s):
+        // - Unrelated greens (CodeQL, Socket) never clear
+        // - Green primary/failover never clear a cancelled aggregator
+        // - Operator-ignored aggregator never clears
+        // - Green aggregator clears cancelled primary/failover (failover path done)
+        // - Non-suite required cancellations always block (mixed cancel)
+        // Strip trailing " (conclusion)" without nested-paren regex (CodeQL js/polynomial-redos).
+        const stripConclusionParen = (label) => {
+            const open = label.lastIndexOf(" (");
+            if (open < 0 || !label.endsWith(")")) {
+                return label;
+            }
+            return label.slice(0, open);
+        };
+        const cancelledNonSuite = cancelledRequired.filter((label) => suiteFamilyOf(stripConclusionParen(label)) === null);
+        const cancelledFamilies = new Set(cancelledRequired
+            .map((label) => suiteFamilyOf(stripConclusionParen(label)))
+            .filter((f) => f !== null));
+        const greenAuthoritativeFamilies = new Set(conclusions
+            .filter((c) => c.required &&
+            !c.ignored &&
+            c.status === "completed" &&
+            AUTHORITATIVE_CLEAR_CONCLUSIONS.has(c.conclusion) &&
+            isAuthoritativeSuiteAggregator(c.name))
+            .map((c) => suiteFamilyOf(c.name)));
+        const unclearedFamilies = [...cancelledFamilies].filter((f) => !greenAuthoritativeFamilies.has(f));
+        if (unclearedFamilies.length > 0 || cancelledNonSuite.length > 0) {
+            readyState = "ci_cancelled_no_failover";
+            failedRequired = [...cancelledRequired];
+            failures.push(`Required CI check-runs cancelled without failover (ci_cancelled_no_failover): ` +
+                `${cancelledRequired.join(", ")}. ` +
+                "Cancelled required check with no green non-ignored authoritative suite aggregator (#3167 / #3168). " +
+                "Do not multi-hour re-push thrash; BLOCKED after thrash caps.");
+        }
+        else {
+            // Every cancelled suite family has a green non-ignored aggregator; no non-suite cancels.
+            readyState = "ready";
+        }
+    }
     else {
         readyState = "ready";
     }
@@ -105,6 +271,7 @@ export function evaluateCiGate(checkRuns, options = {}) {
             failed_required: failedRequired,
             pending_required: pendingRequired,
             capacity_stalled_required: capacityStalledRequired,
+            cancelled_required: cancelledRequired,
             conclusions,
         },
     };

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

@@ -6,6 +6,7 @@ import { fetchCheckRunsRest, fetchGreptileBodyRest, fetchGreptileCommentBody, fe
 import { fetchUnresolvedGreptileInlineFindings, inlineFindingsToDict, } from "./greptile-inline.js";
 import { fetchMergeability, isGithubMergeableClean, mergeabilityToDict, verdictBlockIsSoftOnly, verdictShaIsStale, } from "./mergeability.js";
 import { emptyVerdict, parseGreptileBody } from "./parse.js";
+import { attachPlatformStatusUrls } from "./platform-status.js";
 import { evaluateSlizardGate, isSlizardCheck } from "./slizard-gate.js";
 function buildGateResult(prNumber, repo, headSha, body, via, partialData = {}, error = null, inline = null, minConfidence) {
     const verdict = parseGreptileBody(body);
@@ -40,9 +41,15 @@ function evaluateCiAndSlizard(checkRuns, options) {
         ignoreCheckNames: [...(options.ignoreCheckNames ?? []), ...slizardNames],
     };
     const ciResult = evaluateCiGate(checkRuns, ciOptions);
+    const ci = {
+        ...ciResult.summary,
+        summary_line: buildCiSummaryLine(ciResult.summary),
+    };
+    // #3180: static status URLs when weather-class (no network fetch).
+    attachPlatformStatusUrls(ci, ciResult.summary.ready_state);
     return {
         failures: [...ciResult.failures, ...slizardResult.failures],
-        ci: { ...ciResult.summary, summary_line: buildCiSummaryLine(ciResult.summary) },
+        ci,
         slizard: { ...slizardResult.summary },
     };
 }
@@ -85,6 +92,8 @@ function applyCiGateForHead(repo, headSha, runGh, options) {
                 ignored_checks: [...(options.ignoreCheckNames ?? [])],
                 failed_required: [],
                 pending_required: [],
+                capacity_stalled_required: [],
+                cancelled_required: [],
                 conclusions: [],
             },
             slizard: {

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

@@ -1,4 +1,4 @@
-export { buildCiSummaryLine, type CiCheckConclusion, type CiGateOptions, type CiGateResult, type CiGateSummary, type CiReadyState, evaluateCiGate, } from "./ci-gate.js";
+export { buildCiSummaryLine, type CiCheckConclusion, type CiGateOptions, type CiGateResult, type CiGateSummary, type CiReadyState, evaluateCiGate, isAuthoritativeSuiteAggregator, isBotReviewCheck, suiteFamilyOf, } from "./ci-gate.js";
 export { type ComputeGateOptions, computeGateResult, type FetchMergeabilityFn } from "./compute.js";
 export * from "./constants.js";
 export { evaluateGates, isMergeReady } from "./evaluate.js";
@@ -8,6 +8,7 @@ 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 { attachPlatformStatusUrls, CI_WEATHER_READY_STATES, type CiWeatherReadyState, isCiWeatherReadyState, PLATFORM_STATUS_BLACKSMITH_URL, PLATFORM_STATUS_GITHUB_URL, platformStatusUrlsForWeather, } from "./platform-status.js";
 export { type CapacityStallOptions, type CapacityStallProbe, classifyCapacityStalledRequired, DEFAULT_CAPACITY_STALL_MS, isRunnerCapacityStalled, } from "./runner-capacity-stall.js";
 export type { SlizardGateOptions, SlizardGateResult, SlizardGateSummary, SlizardVerdict, } from "./slizard-gate.js";
 export { evaluateSlizardGate, isSlizardCheck, parseSlizardVerdict, SLIZARD_CHECK_NAME, } from "./slizard-gate.js";

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

@@ -1,4 +1,4 @@
-export { buildCiSummaryLine, evaluateCiGate, } from "./ci-gate.js";
+export { buildCiSummaryLine, evaluateCiGate, isAuthoritativeSuiteAggregator, isBotReviewCheck, suiteFamilyOf, } from "./ci-gate.js";
 export { computeGateResult } from "./compute.js";
 export * from "./constants.js";
 export { evaluateGates, isMergeReady } from "./evaluate.js";
@@ -8,6 +8,7 @@ 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 { attachPlatformStatusUrls, CI_WEATHER_READY_STATES, isCiWeatherReadyState, PLATFORM_STATUS_BLACKSMITH_URL, PLATFORM_STATUS_GITHUB_URL, platformStatusUrlsForWeather, } from "./platform-status.js";
 export { classifyCapacityStalledRequired, DEFAULT_CAPACITY_STALL_MS, isRunnerCapacityStalled, } from "./runner-capacity-stall.js";
 export { evaluateSlizardGate, isSlizardCheck, parseSlizardVerdict, SLIZARD_CHECK_NAME, } from "./slizard-gate.js";
 //# sourceMappingURL=index.js.map

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

@@ -1,5 +1,6 @@
 import { EXIT_EXTERNAL_ERROR, EXIT_MERGE_BLOCKED, EXIT_OK, VIA_ERROR, VIA_FALLBACK2, } from "./constants.js";
 import { isMergeReady } from "./evaluate.js";
+import { isCiWeatherReadyState, PLATFORM_STATUS_BLACKSMITH_URL, PLATFORM_STATUS_GITHUB_URL, } from "./platform-status.js";
 function verdictToDict(verdict) {
     return {
         found: verdict.found,
@@ -68,6 +69,19 @@ export function printHuman(result) {
         else if (typeof ci.ready_state === "string") {
             lines.push(`  CI check-runs: ${ci.ready_state}`);
         }
+        // #3180: surface static status URLs on weather-class CI (human + JSON partial_data).
+        const readyState = typeof ci.ready_state === "string" ? ci.ready_state : null;
+        if (isCiWeatherReadyState(readyState)) {
+            const gh = typeof ci.platform_status_github === "string"
+                ? ci.platform_status_github
+                : PLATFORM_STATUS_GITHUB_URL;
+            const bs = typeof ci.platform_status_blacksmith === "string"
+                ? ci.platform_status_blacksmith
+                : PLATFORM_STATUS_BLACKSMITH_URL;
+            lines.push(`  Platform status GH: ${gh}`);
+            lines.push(`  Platform status BS: ${bs}`);
+            lines.push("  Probe status pages before workflow edits (#3180)");
+        }
     }
     const slizardBlock = result.partialData.slizard;
     if (slizardBlock !== null && typeof slizardBlock === "object" && !Array.isArray(slizardBlock)) {

package/dist/pr-merge-readiness/platform-status.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Static platform status page URLs for CI weather attribution (#3180).
+ *
+ * v1 surfaces URLs only — no network fetch. Agents MUST open these pages when
+ * weather-class `ci_ready_state` fires (or CI never starts for HEAD) and apply
+ * the attribution table in scm/github.md + review-cycle.
+ */
+/** Public GitHub Status (Actions / Webhooks components). */
+export declare const PLATFORM_STATUS_GITHUB_URL = "https://www.githubstatus.com/";
+/** Public Blacksmith Status (runner provider; may mirror GH Actions health). */
+export declare const PLATFORM_STATUS_BLACKSMITH_URL = "https://status.blacksmith.sh/";
+/**
+ * Weather-class ready_state values from evaluateCiGate (#3167).
+ * Status URLs are attached only for these (not ordinary ready / not_ready_yet).
+ */
+export declare const CI_WEATHER_READY_STATES: readonly ["ci_never_scheduled", "runner_capacity_stall", "ci_failures", "ci_cancelled_no_failover"];
+export type CiWeatherReadyState = (typeof CI_WEATHER_READY_STATES)[number];
+export declare function isCiWeatherReadyState(state: string | null | undefined): state is CiWeatherReadyState;
+/** Static status URL fields for weather-class states; null when not weather. */
+export declare function platformStatusUrlsForWeather(state: string | null | undefined): {
+    platform_status_github: string;
+    platform_status_blacksmith: string;
+} | null;
+/**
+ * Attach static status URLs onto a CI partial/summary record when weather-class.
+ * Mutates and returns the same object for call-site chaining.
+ */
+export declare function attachPlatformStatusUrls(ci: Record<string, unknown>, readyState?: string | null): Record<string, unknown>;
+//# sourceMappingURL=platform-status.d.ts.map

package/dist/pr-merge-readiness/platform-status.js

@@ -0,0 +1,49 @@
+/**
+ * Static platform status page URLs for CI weather attribution (#3180).
+ *
+ * v1 surfaces URLs only — no network fetch. Agents MUST open these pages when
+ * weather-class `ci_ready_state` fires (or CI never starts for HEAD) and apply
+ * the attribution table in scm/github.md + review-cycle.
+ */
+/** Public GitHub Status (Actions / Webhooks components). */
+export const PLATFORM_STATUS_GITHUB_URL = "https://www.githubstatus.com/";
+/** Public Blacksmith Status (runner provider; may mirror GH Actions health). */
+export const PLATFORM_STATUS_BLACKSMITH_URL = "https://status.blacksmith.sh/";
+/**
+ * Weather-class ready_state values from evaluateCiGate (#3167).
+ * Status URLs are attached only for these (not ordinary ready / not_ready_yet).
+ */
+export const CI_WEATHER_READY_STATES = [
+    "ci_never_scheduled",
+    "runner_capacity_stall",
+    "ci_failures",
+    "ci_cancelled_no_failover",
+];
+const WEATHER_SET = new Set(CI_WEATHER_READY_STATES);
+export function isCiWeatherReadyState(state) {
+    return state != null && WEATHER_SET.has(state);
+}
+/** Static status URL fields for weather-class states; null when not weather. */
+export function platformStatusUrlsForWeather(state) {
+    if (!isCiWeatherReadyState(state)) {
+        return null;
+    }
+    return {
+        platform_status_github: PLATFORM_STATUS_GITHUB_URL,
+        platform_status_blacksmith: PLATFORM_STATUS_BLACKSMITH_URL,
+    };
+}
+/**
+ * Attach static status URLs onto a CI partial/summary record when weather-class.
+ * Mutates and returns the same object for call-site chaining.
+ */
+export function attachPlatformStatusUrls(ci, readyState) {
+    const state = readyState ?? (typeof ci.ready_state === "string" ? ci.ready_state : null);
+    const urls = platformStatusUrlsForWeather(state);
+    if (urls !== null) {
+        ci.platform_status_github = urls.platform_status_github;
+        ci.platform_status_blacksmith = urls.platform_status_blacksmith;
+    }
+    return ci;
+}
+//# sourceMappingURL=platform-status.js.map

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

@@ -30,6 +30,16 @@ export declare const VERDICT_CI_BLOCKED = "CI_BLOCKED";
  * claimed (#2672). Exit 2 — wait for auto-failover; never --skip-ci.
  */
 export declare const VERDICT_RUNNER_CAPACITY_STALL = "RUNNER_CAPACITY_STALL";
+/**
+ * No CI workflow check-run scheduled for HEAD (bots-only or empty) (#3167).
+ * Exit 2 — thrash-cap then BLOCKED; do not multi-hour empty-commit loops.
+ */
+export declare const VERDICT_CI_NEVER_SCHEDULED = "CI_NEVER_SCHEDULED";
+/**
+ * Primary CI cancelled and no green required sibling / failover (#3167).
+ * Exit 2 — thrash-cap then BLOCKED; workflow arming is sibling #3168.
+ */
+export declare const VERDICT_CI_CANCELLED_NO_FAILOVER = "CI_CANCELLED_NO_FAILOVER";
 /** --one-shot only: a single probe with no terminal verdict yet. */
 export declare const VERDICT_PENDING = "PENDING";
 /** External/config fault mid-probe (unresolvable repo/HEAD, gh unavailable). */

package/dist/pr-watch/constants.js

@@ -30,6 +30,16 @@ export const VERDICT_CI_BLOCKED = "CI_BLOCKED";
  * claimed (#2672). Exit 2 — wait for auto-failover; never --skip-ci.
  */
 export const VERDICT_RUNNER_CAPACITY_STALL = "RUNNER_CAPACITY_STALL";
+/**
+ * No CI workflow check-run scheduled for HEAD (bots-only or empty) (#3167).
+ * Exit 2 — thrash-cap then BLOCKED; do not multi-hour empty-commit loops.
+ */
+export const VERDICT_CI_NEVER_SCHEDULED = "CI_NEVER_SCHEDULED";
+/**
+ * Primary CI cancelled and no green required sibling / failover (#3167).
+ * Exit 2 — thrash-cap then BLOCKED; workflow arming is sibling #3168.
+ */
+export const VERDICT_CI_CANCELLED_NO_FAILOVER = "CI_CANCELLED_NO_FAILOVER";
 /** --one-shot only: a single probe with no terminal verdict yet. */
 export const VERDICT_PENDING = "PENDING";
 /** External/config fault mid-probe (unresolvable repo/HEAD, gh unavailable). */
@@ -62,7 +72,8 @@ export const WATCH_HELP = "usage: task pr:watch -- <pr_number> [options]\n" +
     "exit codes:\n" +
     "  0  CLEAN       SHA-matched review, confidence >= policy min (default 4; dogfood 5), no P0/P1, CI green\n" +
     "  1  NEW_P0_P1   Blocking findings on the current (SHA-matched) review\n" +
-    "  2  ERRORED | STALL | TIMEOUT | CI_BLOCKED | RUNNER_CAPACITY_STALL | config / usage error\n";
+    "  2  ERRORED | STALL | TIMEOUT | CI_BLOCKED | RUNNER_CAPACITY_STALL |\n" +
+    "     CI_NEVER_SCHEDULED | CI_CANCELLED_NO_FAILOVER | config / usage error\n";
 /**
  * Consecutive polls where the CLEAN gate is wedged on HEAD (!has_blocking &&
  * !is_clean with a holdout other than sha_match) before STALL (#1039). Stale-SHA