@deftai/directive-core 0.96.0 → 0.97.0

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

package/dist/pr-watch/main.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { defaultRunGh } from "../pr-merge-readiness/gh.js";
+import { platformStatusUrlsForWeather } from "../pr-merge-readiness/platform-status.js";
 import { DEFAULT_MAX_WAIT_MINUTES, DEFAULT_POLL_SECONDS, EXIT_CLEAN, EXIT_TERMINAL_ERROR, WATCH_HELP, } from "./constants.js";
 import { watch } from "./watch.js";
 function fail(base, error) {
@@ -140,7 +141,7 @@ function pythonJsonDumps(value) {
 /** AC-4 stable --json shape (same field set as the #1039 Tier-1 instrumentation line). */
 export function watchResultToJson(result) {
     const p = result.probe;
-    return {
+    const payload = {
         verdict: result.verdict,
         pr_number: result.prNumber,
         head_sha: p.headSha,
@@ -159,6 +160,13 @@ export function watchResultToJson(result) {
         elapsed_seconds: result.elapsedSeconds,
         poll_count: result.pollCount,
     };
+    // #3180: static status URLs on weather-class ci_ready_state (no network fetch).
+    const statusUrls = platformStatusUrlsForWeather(p.ciReadyState);
+    if (statusUrls !== null) {
+        payload.platform_status_github = statusUrls.platform_status_github;
+        payload.platform_status_blacksmith = statusUrls.platform_status_blacksmith;
+    }
+    return payload;
 }
 export function emitWatchJson(result) {
     return `${pythonJsonDumps(watchResultToJson(result))}\n`;
@@ -183,6 +191,13 @@ export function printWatchHuman(result) {
     if (p.ciCapacityStalledChecks.length > 0) {
         lines.push(`  Capacity-stalled:   ${p.ciCapacityStalledChecks.join("; ")}`);
     }
+    // #3180: probe these pages before workflow thrash on weather states.
+    const statusUrls = platformStatusUrlsForWeather(p.ciReadyState);
+    if (statusUrls !== null) {
+        lines.push(`  Platform status GH: ${statusUrls.platform_status_github}`);
+        lines.push(`  Platform status BS: ${statusUrls.platform_status_blacksmith}`);
+        lines.push("  Probe status pages before workflow edits (#3180)");
+    }
     if (p.cleanGateHoldout !== null) {
         lines.push(`  Clean-gate holdout: ${p.cleanGateHoldout}`);
     }

package/dist/pr-watch/probe.js

@@ -82,7 +82,7 @@ export function probeOnce(prNumber, repoArg, runGh = defaultRunGh, projectRoot =
         }
     }
     const shaMatch = lastReviewedSha !== null && lastReviewedSha === headSha;
-    const [isClean, cleanGateHoldout] = evaluateCleanGate({
+    let [isClean, cleanGateHoldout] = evaluateCleanGate({
         lastReviewedSha,
         headSha,
         hasBlocking: findings.has_blocking,
@@ -92,6 +92,18 @@ export function probeOnce(prNumber, repoArg, runGh = defaultRunGh, projectRoot =
         terminalCheckRun,
         minConfidence,
     });
+    // #3167: weather not-ready states must never surface as CLEAN even when the
+    // Greptile side of the clean gate is satisfied (empty CI was previously ready).
+    if (isClean &&
+        (ciReadyState === "ci_never_scheduled" ||
+            ciReadyState === "runner_capacity_stall" ||
+            ciReadyState === "ci_cancelled_no_failover" ||
+            ciReadyState === "ci_failures" ||
+            ciReadyState === "blocked" ||
+            ciReadyState === "not_ready_yet")) {
+        isClean = false;
+        cleanGateHoldout = ciReadyState === "not_ready_yet" ? "terminal_check_run" : ciReadyState;
+    }
     return {
         found,
         headSha,

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

@@ -16,8 +16,9 @@ export interface WatchProbe {
     /** Failed required check identities (name + conclusion), when CI was probed. */
     readonly ciFailedChecks: readonly string[];
     /**
-     * CI gate ready_state from evaluateCiGate (#2169 / #2672).
-     * Includes `runner_capacity_stall` distinct from `not_ready_yet`.
+     * CI gate ready_state from evaluateCiGate (#2169 / #2672 / #3167).
+     * Weather codes: `ci_never_scheduled`, `runner_capacity_stall`,
+     * `ci_failures`, `ci_cancelled_no_failover` (plus `not_ready_yet` / `ready`).
      */
     readonly ciReadyState: string | null;
     /** Required checks classified as capacity-stalled (#2672). */

package/dist/pr-watch/watch.js

@@ -1,5 +1,5 @@
 import { defaultRunGh } from "../pr-merge-readiness/gh.js";
-import { DEFAULT_CI_BLOCKED_THRESHOLD, DEFAULT_MAX_WAIT_MINUTES, DEFAULT_POLL_SECONDS, DEFAULT_STALL_THRESHOLD, EXIT_CLEAN, EXIT_NEW_P0_P1, EXIT_TERMINAL_ERROR, VERDICT_CI_BLOCKED, VERDICT_CLEAN, VERDICT_CONFIG, VERDICT_ERRORED, VERDICT_NEW_P0_P1, VERDICT_PENDING, VERDICT_RUNNER_CAPACITY_STALL, VERDICT_STALL, VERDICT_TIMEOUT, } from "./constants.js";
+import { DEFAULT_CI_BLOCKED_THRESHOLD, DEFAULT_MAX_WAIT_MINUTES, DEFAULT_POLL_SECONDS, DEFAULT_STALL_THRESHOLD, EXIT_CLEAN, EXIT_NEW_P0_P1, EXIT_TERMINAL_ERROR, VERDICT_CI_BLOCKED, VERDICT_CI_CANCELLED_NO_FAILOVER, VERDICT_CI_NEVER_SCHEDULED, VERDICT_CLEAN, VERDICT_CONFIG, VERDICT_ERRORED, VERDICT_NEW_P0_P1, VERDICT_PENDING, VERDICT_RUNNER_CAPACITY_STALL, VERDICT_STALL, VERDICT_TIMEOUT, } from "./constants.js";
 import { probeOnce } from "./probe.js";
 const systemMonotonicClock = {
     now() {
@@ -81,20 +81,27 @@ export function watch(prNumber, repo, options = {}) {
         if (probe.errored) {
             return build(VERDICT_ERRORED, EXIT_TERMINAL_ERROR, probe, poll);
         }
-        // #2672: capacity stall is distinct from ordinary not_ready_yet — surface
-        // immediately (exit 2) so agents wait for auto-failover instead of --skip-ci.
+        // #2672 / #3167: CI weather states are distinct terminal exits (exit 2).
+        // Agents must thrash-cap / BLOCKED rather than multi-hour empty-commit loops.
         if (probe.ciReadyState === "runner_capacity_stall") {
             return build(VERDICT_RUNNER_CAPACITY_STALL, EXIT_TERMINAL_ERROR, probe, poll);
         }
-        // #2688: Greptile side satisfied on HEAD but CI red — fail loud toward a
-        // fix loop instead of burning max-wait-minutes on idle Greptile polls.
-        if (probe.cleanGateHoldout === "ci_failures") {
+        if (probe.ciReadyState === "ci_never_scheduled") {
+            return build(VERDICT_CI_NEVER_SCHEDULED, EXIT_TERMINAL_ERROR, probe, poll);
+        }
+        if (probe.ciReadyState === "ci_cancelled_no_failover") {
+            return build(VERDICT_CI_CANCELLED_NO_FAILOVER, EXIT_TERMINAL_ERROR, probe, poll);
+        }
+        // #2688 / #3167: Greptile side satisfied on HEAD but CI red (ci_failures) —
+        // fail loud toward a fix loop instead of burning max-wait-minutes.
+        const ciProductBlocked = probe.cleanGateHoldout === "ci_failures" || probe.ciReadyState === "ci_failures";
+        if (ciProductBlocked) {
             ciBlockedStreak += 1;
         }
         else {
             ciBlockedStreak = 0;
         }
-        if (oneShot && probe.cleanGateHoldout === "ci_failures") {
+        if (oneShot && ciProductBlocked) {
             return build(VERDICT_CI_BLOCKED, EXIT_TERMINAL_ERROR, probe, poll);
         }
         if (!oneShot && ciBlockedStreak >= DEFAULT_CI_BLOCKED_THRESHOLD) {