@deftai/directive-core 0.66.2 → 0.68.0

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

@@ -0,0 +1,105 @@
+/** REST `mergeable_state` value that mirrors GraphQL `mergeStateStatus: CLEAN`. */
+export 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 function fetchMergeability(prNumber, repo, runGh) {
+    const rc = runGh(["gh", "api", `repos/${repo}/pulls/${prNumber}`]);
+    if (rc.returncode !== 0) {
+        return {
+            mergeableState: null,
+            mergeable: null,
+            error: `gh api /pulls/${prNumber} failed: ${rc.stderr.trim()}`,
+        };
+    }
+    if (!rc.stdout.trim()) {
+        return { mergeableState: null, mergeable: null, error: "empty body from gh api /pulls/<N>" };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(rc.stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        return { mergeableState: null, mergeable: null, error: `could not parse PR JSON: ${message}` };
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        return {
+            mergeableState: null,
+            mergeable: null,
+            error: "unexpected PR JSON shape (not a dict)",
+        };
+    }
+    const pr = payload;
+    const rawState = pr.mergeable_state;
+    const rawMergeable = pr.mergeable;
+    return {
+        mergeableState: typeof rawState === "string" ? rawState : null,
+        mergeable: typeof rawMergeable === "boolean" ? rawMergeable : null,
+        error: null,
+    };
+}
+/** True when GitHub itself reports the PR as CLEAN + MERGEABLE (#2260). */
+export function isGithubMergeableClean(signal) {
+    return signal.mergeable === true && signal.mergeableState === MERGE_STATE_CLEAN;
+}
+/** Serialise the mergeability signal into the partial_data envelope shape. */
+export function mergeabilityToDict(signal) {
+    return {
+        mergeable_state: signal.mergeableState,
+        mergeable: signal.mergeable,
+        error: signal.error,
+    };
+}
+/** True when a parsed verdict SHA does not match the current PR head SHA. */
+export function verdictShaIsStale(verdict, headSha) {
+    if (!verdict.found || verdict.lastReviewedSha === null || !headSha) {
+        return false;
+    }
+    const reviewed = verdict.lastReviewedSha;
+    return !(headSha.startsWith(reviewed) || reviewed.startsWith(headSha));
+}
+/**
+ * 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 function verdictBlockIsSoftOnly(verdict, headSha) {
+    // Absent: no Greptile rolling-summary comment at all.
+    if (!verdict.found) {
+        return true;
+    }
+    // informal-clean (#1543) is a present-but-noncanonical verdict with its own
+    // remediation path; it is out of scope for the #2260 mergeability override.
+    if (verdict.informalClean) {
+        return false;
+    }
+    // Stale: verdict pinned to a prior head SHA -> its findings pertain to old code.
+    if (verdictShaIsStale(verdict, headSha)) {
+        return true;
+    }
+    // Verdict is current (or its SHA is unparseable). A genuine current-head
+    // finding is a hard block and must not be overridden.
+    if (verdict.errored) {
+        return false;
+    }
+    if (verdict.confidence !== null && verdict.confidence <= 3) {
+        return false;
+    }
+    if (verdict.p0Count > 0 || verdict.p1Count > 0) {
+        return false;
+    }
+    // No genuine finding: the block is a missing-canonical-field / not-yet-posted
+    // wait, which GitHub mergeability may resolve.
+    return true;
+}
+//# sourceMappingURL=mergeability.js.map

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

@@ -53,6 +53,26 @@ export function printHuman(result) {
     lines.push(`  Findings:           P0=${result.verdict.p0Count}  ` +
         `P1=${result.verdict.p1Count}  P2=${result.verdict.p2Count}`);
     lines.push(`  Errored sentinel:   ${result.verdict.errored ? "True" : "False"}`);
+    const ciBlock = result.partialData.ci;
+    if (ciBlock !== null && typeof ciBlock === "object" && !Array.isArray(ciBlock)) {
+        const ci = ciBlock;
+        if (typeof ci.summary_line === "string") {
+            lines.push(`  ${ci.summary_line}`);
+        }
+        else if (typeof ci.ready_state === "string") {
+            lines.push(`  CI check-runs: ${ci.ready_state}`);
+        }
+    }
+    const slizardBlock = result.partialData.slizard;
+    if (slizardBlock !== null && typeof slizardBlock === "object" && !Array.isArray(slizardBlock)) {
+        const slizard = slizardBlock;
+        if (typeof slizard.summary_line === "string") {
+            lines.push(`  ${slizard.summary_line}`);
+        }
+        else if (typeof slizard.ready_state === "string") {
+            lines.push(`  SLizard review: ${slizard.ready_state}`);
+        }
+    }
     if (result.via === VIA_FALLBACK2 && Object.keys(result.partialData).length > 0) {
         lines.push("  Fallback2 signal:");
         for (const key of ["pr_state", "merged", "mergeable", "mergeable_state"]) {

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

@@ -0,0 +1,47 @@
+import type { CheckRunRecord } from "./gh.js";
+/**
+ * Dedicated gate for the SLizard second-reviewer verdict (#2189).
+ *
+ * SLizard posts a check-run whose `output.summary` carries a structured verdict:
+ *
+ *   Decision: request_changes
+ *   Merge impact: blocking
+ *   Findings: 2 (P0: 0, P1: 1, P2: 0, P3: 0)
+ *
+ * The generic CI check-run gate (#2169) only fails closed on a check-run
+ * `conclusion` in the failed set, so a blocking *decision* carried on a
+ * non-`failure` conclusion (e.g. `neutral`) would slip through and the review
+ * is surfaced indistinctly among build/test checks. This gate parses the
+ * structured verdict and fails merge-readiness on a blocking decision.
+ */
+/** Canonical SLizard check-run name; matching is case-insensitive substring for resilience. */
+export declare const SLIZARD_CHECK_NAME = "SLizard";
+export type SlizardReadyState = "ready" | "blocked" | "not_ready_yet" | "skipped";
+export interface SlizardGateOptions {
+    readonly skipSlizard?: boolean;
+}
+export interface SlizardVerdict {
+    readonly decision: string | null;
+    readonly mergeImpact: string | null;
+    readonly p0Count: number | null;
+    readonly p1Count: number | null;
+    readonly p2Count: number | null;
+}
+export interface SlizardGateSummary {
+    readonly ready_state: SlizardReadyState;
+    readonly present: boolean;
+    readonly check_name: string | null;
+    readonly status: string | null;
+    readonly conclusion: string | null;
+    readonly verdict: SlizardVerdict | null;
+    readonly summary_line: string;
+}
+export interface SlizardGateResult {
+    readonly failures: readonly string[];
+    readonly summary: SlizardGateSummary;
+}
+export declare function isSlizardCheck(name: string): boolean;
+/** Parse a SLizard check-run `output.summary` into a structured verdict. */
+export declare function parseSlizardVerdict(summary: string | undefined | null): SlizardVerdict;
+export declare function evaluateSlizardGate(checkRuns: readonly CheckRunRecord[], options?: SlizardGateOptions): SlizardGateResult;
+//# sourceMappingURL=slizard-gate.d.ts.map

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

@@ -0,0 +1,119 @@
+/**
+ * Dedicated gate for the SLizard second-reviewer verdict (#2189).
+ *
+ * SLizard posts a check-run whose `output.summary` carries a structured verdict:
+ *
+ *   Decision: request_changes
+ *   Merge impact: blocking
+ *   Findings: 2 (P0: 0, P1: 1, P2: 0, P3: 0)
+ *
+ * The generic CI check-run gate (#2169) only fails closed on a check-run
+ * `conclusion` in the failed set, so a blocking *decision* carried on a
+ * non-`failure` conclusion (e.g. `neutral`) would slip through and the review
+ * is surfaced indistinctly among build/test checks. This gate parses the
+ * structured verdict and fails merge-readiness on a blocking decision.
+ */
+/** Canonical SLizard check-run name; matching is case-insensitive substring for resilience. */
+export const SLIZARD_CHECK_NAME = "SLizard";
+const FAILED_CONCLUSIONS = new Set(["failure", "cancelled", "timed_out"]);
+const PENDING_STATUSES = new Set(["queued", "in_progress"]);
+const BLOCKING_DECISIONS = new Set(["request_changes", "changes_requested", "reject"]);
+export function isSlizardCheck(name) {
+    return name.toLowerCase().includes("slizard");
+}
+function firstMatch(text, re) {
+    const m = re.exec(text);
+    return m?.[1] !== undefined ? m[1].trim() : null;
+}
+function countFor(text, sev) {
+    const m = new RegExp(`${sev}\\s*:\\s*(\\d+)`, "i").exec(text);
+    return m?.[1] !== undefined ? Number.parseInt(m[1], 10) : null;
+}
+/** Parse a SLizard check-run `output.summary` into a structured verdict. */
+export function parseSlizardVerdict(summary) {
+    const text = summary ?? "";
+    const decision = firstMatch(text, /Decision\s*:\s*([A-Za-z_]+)/i);
+    const mergeImpact = firstMatch(text, /Merge impact\s*:\s*([A-Za-z_-]+)/i);
+    return {
+        decision: decision ? decision.toLowerCase() : null,
+        mergeImpact: mergeImpact ? mergeImpact.toLowerCase() : null,
+        p0Count: countFor(text, "P0"),
+        p1Count: countFor(text, "P1"),
+        p2Count: countFor(text, "P2"),
+    };
+}
+function skippedSummary(reason) {
+    return {
+        ready_state: "skipped",
+        present: false,
+        check_name: null,
+        status: null,
+        conclusion: null,
+        verdict: null,
+        summary_line: `SLizard review: skipped (${reason})`,
+    };
+}
+function isPending(status, conclusion) {
+    if (PENDING_STATUSES.has(status)) {
+        return true;
+    }
+    return status !== "completed" || conclusion === "none";
+}
+export function evaluateSlizardGate(checkRuns, options = {}) {
+    if (options.skipSlizard === true) {
+        return { failures: [], summary: skippedSummary("--skip-slizard") };
+    }
+    const run = checkRuns.find((r) => isSlizardCheck(r.name));
+    if (run === undefined) {
+        // SLizard is an optional second reviewer; its absence does not block merge.
+        return { failures: [], summary: skippedSummary("no SLizard check-run on this commit") };
+    }
+    const verdict = parseSlizardVerdict(run.summary);
+    const blockingDecision = verdict.decision !== null && BLOCKING_DECISIONS.has(verdict.decision);
+    const blockingImpact = verdict.mergeImpact === "blocking";
+    const failedConclusion = FAILED_CONCLUSIONS.has(run.conclusion);
+    const failures = [];
+    let readyState;
+    if (blockingDecision || blockingImpact || failedConclusion) {
+        readyState = "blocked";
+        const reasons = [];
+        if (verdict.decision !== null) {
+            reasons.push(`decision=${verdict.decision}`);
+        }
+        if (verdict.mergeImpact !== null) {
+            reasons.push(`merge impact=${verdict.mergeImpact}`);
+        }
+        if (failedConclusion) {
+            reasons.push(`conclusion=${run.conclusion}`);
+        }
+        const findings = verdict.p0Count !== null || verdict.p1Count !== null || verdict.p2Count !== null
+            ? ` (P0=${verdict.p0Count ?? 0} P1=${verdict.p1Count ?? 0} P2=${verdict.p2Count ?? 0})`
+            : "";
+        failures.push(`SLizard review is blocking: ${reasons.join(", ")}${findings}. ` +
+            "Resolve the SLizard findings or pass --skip-slizard to override (#2189).");
+    }
+    else if (isPending(run.status, run.conclusion)) {
+        readyState = "not_ready_yet";
+        failures.push(`SLizard review still in progress (${run.status}); wait for the verdict before merge (#2189).`);
+    }
+    else {
+        readyState = "ready";
+    }
+    const parts = [
+        `decision=${verdict.decision ?? "?"}`,
+        `impact=${verdict.mergeImpact ?? "?"}`,
+    ];
+    return {
+        failures,
+        summary: {
+            ready_state: readyState,
+            present: true,
+            check_name: run.name,
+            status: run.status,
+            conclusion: run.conclusion,
+            verdict,
+            summary_line: `SLizard review: ${readyState} (${parts.join(", ")})`,
+        },
+    };
+}
+//# sourceMappingURL=slizard-gate.js.map

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

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

package/dist/pr-monitor/index.js

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

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

@@ -1,6 +1,12 @@
 import type { MonitorOptions, MonitorRunResult, PollResult } from "./types.js";
-/** One-line stderr status mirror per poll. */
-export declare function formatPollStatus(pollIndex: number, pollResult: PollResult): string;
+/** Pull GitHub's merge-state signal out of a readiness payload, if present. */
+export declare function mergeStateFromPayload(payload: Record<string, unknown>): string;
+/**
+ * One-line stderr heartbeat per poll (#2260): elapsed, poll#, via, head,
+ * GitHub merge-state, CLEAN/BLOCKED, and what the poll is blocked on. Emitting
+ * this every poll makes a live poll visibly distinct from a hung process.
+ */
+export declare function formatPollStatus(pollIndex: number, pollResult: PollResult, elapsedSeconds?: number): string;
 /** Detect merged / closed PR via fallback2 partial_data. */
 export declare function isTerminalPrState(payload: Record<string, unknown>): boolean;
 /** Loop readiness with adaptive cadence until CLEAN / cap / terminal. */

package/dist/pr-monitor/monitor.js

@@ -13,8 +13,34 @@ function defaultSleep(seconds) {
         // busy-wait fallback when no injectable sleep in production CLI path
     }
 }
-/** One-line stderr status mirror per poll. */
-export function formatPollStatus(pollIndex, pollResult) {
+/** Pull GitHub's merge-state signal out of a readiness payload, if present. */
+export function mergeStateFromPayload(payload) {
+    const partialRaw = payload.partial_data;
+    const partial = partialRaw !== null && typeof partialRaw === "object" && !Array.isArray(partialRaw)
+        ? partialRaw
+        : {};
+    const mergeabilityRaw = partial.mergeability;
+    if (mergeabilityRaw !== null &&
+        typeof mergeabilityRaw === "object" &&
+        !Array.isArray(mergeabilityRaw)) {
+        const state = mergeabilityRaw.mergeable_state;
+        if (typeof state === "string" && state.length > 0) {
+            return state;
+        }
+    }
+    // fallback2 surfaces mergeable_state directly on partial_data.
+    const flatState = partial.mergeable_state;
+    if (typeof flatState === "string" && flatState.length > 0) {
+        return flatState;
+    }
+    return "?";
+}
+/**
+ * One-line stderr heartbeat per poll (#2260): elapsed, poll#, via, head,
+ * GitHub merge-state, CLEAN/BLOCKED, and what the poll is blocked on. Emitting
+ * this every poll makes a live poll visibly distinct from a hung process.
+ */
+export function formatPollStatus(pollIndex, pollResult, elapsedSeconds = 0) {
     const payload = pollResult.payload;
     const via = typeof payload.via === "string" ? payload.via : "?";
     const mergeReady = payload.merge_ready === true;
@@ -30,10 +56,12 @@ export function formatPollStatus(pollIndex, pollResult) {
     const failures = Array.isArray(failuresRaw) ? failuresRaw.map(String) : [];
     const firstFailure = failures[0] ?? "";
     const label = mergeReady ? "CLEAN" : "BLOCKED";
-    let line = `[monitor_pr] poll #${pollIndex} via=${via} head=${headDisplay} ` +
-        `${label} (${failures.length} failures)`;
+    const elapsed = Math.max(0, Math.round(elapsedSeconds));
+    const mergeState = mergeStateFromPayload(payload);
+    let line = `[monitor_pr] poll #${pollIndex} t=${elapsed}s via=${via} head=${headDisplay} ` +
+        `mergeState=${mergeState} ${label} (${failures.length} failures)`;
     if (firstFailure.length > 0) {
-        line += ` -- ${firstFailure.slice(0, 80)}`;
+        line += ` -- blocked-on: ${firstFailure.slice(0, 80)}`;
     }
     return line;
 }
@@ -65,7 +93,8 @@ export function monitor(prNumber, repo, options = {}) {
         const pollResult = callReadinessFn(prNumber, repo);
         lastPayload = pollResult.payload;
         lastExit = pollResult.exitCode;
-        process.stderr.write(`${formatPollStatus(pollIndex, pollResult)}\n`);
+        const elapsedAtPoll = clockFn.now() - startedAt;
+        process.stderr.write(`${formatPollStatus(pollIndex, pollResult, elapsedAtPoll)}\n`);
         if (pollResult.rawStderr.trim().length > 0) {
             process.stderr.write(pollResult.rawStderr);
         }

package/dist/pr-wait-mergeable/wrappers.d.ts

@@ -4,8 +4,19 @@ export interface CaptureExecResult {
     readonly stdout: string;
     readonly stderr: string;
 }
+export interface CaptureExecOptions {
+    /**
+     * Stream the child's stderr straight to the parent's stderr (live) instead of
+     * capturing it. Used for long polls so the per-poll heartbeat is visible in
+     * real time rather than buffered until the subprocess exits (#2260). When set,
+     * the returned `stderr` is empty because it was not captured.
+     */
+    readonly inheritStderr?: boolean;
+    /** Environment for the child (defaults to `process.env`). */
+    readonly env?: NodeJS.ProcessEnv;
+}
 /** UTF-8-safe subprocess capture via spawnSync (no shell) — mirrors #1366. */
-export declare function captureExec(executable: string, args: readonly string[], timeoutMs: number): CaptureExecResult;
+export declare function captureExec(executable: string, args: readonly string[], timeoutMs: number, options?: CaptureExecOptions): CaptureExecResult;
 export interface RunProtectedCheckOptions {
     readonly nodeExecutable?: string;
     readonly timeout?: number;

package/dist/pr-wait-mergeable/wrappers.js

@@ -4,13 +4,13 @@ import { fileURLToPath } from "node:url";
 import { resolveBinary } from "../scm/binary.js";
 import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 /** UTF-8-safe subprocess capture via spawnSync (no shell) — mirrors #1366. */
-export function captureExec(executable, args, timeoutMs) {
+export function captureExec(executable, args, timeoutMs, options = {}) {
     const result = spawnSync(executable, args, {
         encoding: "utf8",
         timeout: timeoutMs,
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: ["ignore", "pipe", options.inheritStderr === true ? "inherit" : "pipe"],
         maxBuffer: SUBPROCESS_MAX_BUFFER,
-        env: process.env,
+        env: options.env ?? process.env,
     });
     if (result.error !== undefined) {
         const code = result.error.code;
@@ -56,7 +56,9 @@ export function runProtectedCheck(prNumber, repo, protectedIssues, options = {})
     if (repo) {
         cmd.push("--repo", repo);
     }
-    const result = captureExec(node, cmd, (options.timeout ?? 60) * 1000);
+    const result = captureExec(node, cmd, (options.timeout ?? 60) * 1000, {
+        env: { ...process.env, NODE_NO_WARNINGS: "1" },
+    });
     return [result.returncode, result.stdout, result.stderr];
 }
 /** Invoke pr-monitor CLI with --json and return (returncode, stdout, stderr). */
@@ -72,7 +74,13 @@ export function runMonitor(prNumber, repo, capMinutes, options = {}) {
         String(capMinutes),
         "--json",
     ];
-    const result = captureExec(node, cmd, timeoutSec * 1000);
+    // Stream the monitor's per-poll heartbeat live (a buffered poll looks like a
+    // hang, #2260) and suppress Node deprecation/engine warning noise so it never
+    // leaks onto the captured JSON stream or the final result line (#2240-class).
+    const result = captureExec(node, cmd, timeoutSec * 1000, {
+        inheritStderr: true,
+        env: { ...process.env, NODE_NO_WARNINGS: "1" },
+    });
     return [result.returncode, result.stdout, result.stderr];
 }
 /** Invoke ``gh pr merge --squash --delete-branch --admin``. */

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

@@ -0,0 +1,33 @@
+/**
+ * task pr:watch -- deterministic PR-verdict polling surface (#1056).
+ *
+ * Three-state exit contract (AC-1): mirrors scripts/preflight_branch.py (#747)
+ * and pr:merge-ready (#796) -- the invocation IS the wait, so an orchestrator
+ * cannot promise to poll and then silently forget (2026-05-11 three-strikes on
+ * #1051 / #1054).
+ */
+/** CLEAN: SHA-matched, non-errored, no P0/P1, confidence > 3, CI green. */
+export declare const EXIT_CLEAN = 0;
+/** NEW_P0_P1: blocking findings on the CURRENT (SHA-matched) review. */
+export declare const EXIT_NEW_P0_P1 = 1;
+/** ERRORED | STALL | TIMEOUT | config-error all collapse to a single non-zero. */
+export declare const EXIT_TERMINAL_ERROR = 2;
+export declare const VERDICT_CLEAN = "CLEAN";
+export declare const VERDICT_NEW_P0_P1 = "NEW_P0_P1";
+export declare const VERDICT_ERRORED = "ERRORED";
+export declare const VERDICT_STALL = "STALL";
+export declare const VERDICT_TIMEOUT = "TIMEOUT";
+/** --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). */
+export declare const VERDICT_CONFIG = "CONFIG";
+export declare const DEFAULT_MAX_WAIT_MINUTES = 30;
+export declare const DEFAULT_POLL_SECONDS = 90;
+/**
+ * Consecutive polls with a review PRESENT but stuck on a stale (non-HEAD)
+ * commit before the loop surfaces STALL instead of waiting the full cap. Keeps
+ * a Greptile review that never re-reviews the new HEAD from silently eating the
+ * whole 30-minute budget (#1039 STALL terminal).
+ */
+export declare const DEFAULT_STALL_THRESHOLD = 3;
+//# sourceMappingURL=constants.d.ts.map

package/dist/pr-watch/constants.js

@@ -0,0 +1,33 @@
+/**
+ * task pr:watch -- deterministic PR-verdict polling surface (#1056).
+ *
+ * Three-state exit contract (AC-1): mirrors scripts/preflight_branch.py (#747)
+ * and pr:merge-ready (#796) -- the invocation IS the wait, so an orchestrator
+ * cannot promise to poll and then silently forget (2026-05-11 three-strikes on
+ * #1051 / #1054).
+ */
+/** CLEAN: SHA-matched, non-errored, no P0/P1, confidence > 3, CI green. */
+export const EXIT_CLEAN = 0;
+/** NEW_P0_P1: blocking findings on the CURRENT (SHA-matched) review. */
+export const EXIT_NEW_P0_P1 = 1;
+/** ERRORED | STALL | TIMEOUT | config-error all collapse to a single non-zero. */
+export const EXIT_TERMINAL_ERROR = 2;
+export const VERDICT_CLEAN = "CLEAN";
+export const VERDICT_NEW_P0_P1 = "NEW_P0_P1";
+export const VERDICT_ERRORED = "ERRORED";
+export const VERDICT_STALL = "STALL";
+export const VERDICT_TIMEOUT = "TIMEOUT";
+/** --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). */
+export const VERDICT_CONFIG = "CONFIG";
+export const DEFAULT_MAX_WAIT_MINUTES = 30;
+export const DEFAULT_POLL_SECONDS = 90;
+/**
+ * Consecutive polls with a review PRESENT but stuck on a stale (non-HEAD)
+ * commit before the loop surfaces STALL instead of waiting the full cap. Keeps
+ * a Greptile review that never re-reviews the new HEAD from silently eating the
+ * whole 30-minute budget (#1039 STALL terminal).
+ */
+export const DEFAULT_STALL_THRESHOLD = 3;
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,6 @@
+export * from "./constants.js";
+export { cmdPrWatch, emitWatchJson, type ParsedWatchArgs, parseWatchArgs, printWatchHuman, type RunWatchOptions, runWatch, watchResultToJson, } from "./main.js";
+export { probeOnce } from "./probe.js";
+export * from "./types.js";
+export { formatWatchStatus, watch } from "./watch.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/pr-watch/index.js

@@ -0,0 +1,6 @@
+export * from "./constants.js";
+export { cmdPrWatch, emitWatchJson, parseWatchArgs, printWatchHuman, runWatch, watchResultToJson, } from "./main.js";
+export { probeOnce } from "./probe.js";
+export * from "./types.js";
+export { formatWatchStatus, watch } from "./watch.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,21 @@
+import type { WatchOptions, WatchResult } from "./types.js";
+export interface ParsedWatchArgs {
+    readonly prNumber: number | null;
+    readonly repo: string | null;
+    readonly maxWaitMinutes: number;
+    readonly pollSeconds: number;
+    readonly oneShot: boolean;
+    readonly emitJson: boolean;
+    readonly projectRoot: string | null;
+    readonly error?: string;
+}
+export declare function parseWatchArgs(argv: readonly string[]): ParsedWatchArgs;
+/** AC-4 stable --json shape (same field set as the #1039 Tier-1 instrumentation line). */
+export declare function watchResultToJson(result: WatchResult): Record<string, unknown>;
+export declare function emitWatchJson(result: WatchResult): string;
+export declare function printWatchHuman(result: WatchResult): string;
+export interface RunWatchOptions extends WatchOptions {
+}
+export declare function runWatch(argv: readonly string[], options?: RunWatchOptions): number;
+export declare function cmdPrWatch(argv: readonly string[], options?: RunWatchOptions): number;
+//# sourceMappingURL=main.d.ts.map