@quickchatai/pi-quickreview 0.0.0-stage → 1.1.0

package/dist/src/authwatch.js

@@ -0,0 +1,210 @@
+// Passive pi auth-failure detection: no smoke calls — watch the session
+// JSONLs pi already writes and raise when sessions start failing with
+// token-expired API errors. The live signature:
+//   "errorMessage":"Provided authentication token is expired."
+// The scanner tail-reads recently-modified *.jsonl under the pi sessions dir
+// (one nesting level: pi groups sessions by cwd) — cheap enough for a 60s
+// tick, and entirely observational: it never talks to any API.
+// Only a record's own `errorMessage` FIELD is tested — never the raw line:
+// reviewer sessions store tool results verbatim (diffs, file reads, CI logs),
+// and a PR touching OAuth code puts "invalid_grant" in them as plain text.
+import { closeSync, openSync, readSync, readdirSync, statSync } from "node:fs";
+import { join, sep } from "node:path";
+export const PI_AUTH_ERROR_RE = /authentication token is expired|invalid_grant|401 unauthorized/i;
+/** True when a JSONL line is a record carrying an auth-failure `errorMessage`
+ * field — at any depth, since a subagent's failed message arrives nested in
+ * its tool result. Text inside string values (tool output, quoted JSON) never
+ * matches: it is data, not a key. Non-JSON lines never match. */
+export function lineHasAuthError(line) {
+    if (!line.includes("errorMessage"))
+        return false;
+    let record;
+    try {
+        record = JSON.parse(line);
+    }
+    catch {
+        return false;
+    }
+    const visit = (x, depth) => {
+        if (depth > 12 || typeof x !== "object" || x === null)
+            return false;
+        if (Array.isArray(x))
+            return x.some((y) => visit(y, depth + 1));
+        const r = x;
+        const msg = r["errorMessage"];
+        if (typeof msg === "string" && PI_AUTH_ERROR_RE.test(msg))
+            return true;
+        return Object.values(r).some((v) => visit(v, depth + 1));
+    };
+    return visit(record, 0);
+}
+/** Only the tail is read: session JSONLs grow large, and a live auth failure
+ * is by definition near the end of the file. */
+export const AUTH_TAIL_BYTES = 128 * 1024;
+/** The complete lines of `path` not yet scanned: from `from` (clamped into the
+ * last `bytes`) up to the last newline. Returns the text and the offset the
+ * NEXT read starts at — just past that newline, so a line still being written
+ * is read whole, exactly once, next time rather than split or counted twice. */
+function readFrom(path, from, bytes) {
+    const fd = openSync(path, "r");
+    try {
+        const size = statSync(path).size;
+        // A file that shrank was rewritten: its old offset means nothing.
+        const start = Math.max(from > size ? 0 : from, size - bytes, 0);
+        const buf = Buffer.alloc(size - start);
+        readSync(fd, buf, 0, buf.length, start);
+        // Only COMPLETE lines are tested: a trailing partial line is left for the
+        // next scan, so testing it now too would count the same error twice.
+        const lastNl = buf.lastIndexOf(0x0a);
+        if (lastNl < 0)
+            return { text: "", next: start };
+        return { text: buf.subarray(0, lastNl + 1).toString("utf8"), next: start + lastNl + 1 };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Scan *.jsonl files modified at/after `sinceMs` (dir + one sublevel) for
+ * auth-error signatures. Unreadable files are skipped — observation must
+ * never throw into the daemon tick — and counted (`scanPiAuth`'s `unread`),
+ * so a caller keeps them inside its next window.
+ *
+ * `seen` (path → byte offset, updated in place) makes the scan read only what
+ * was appended since the last scan, so an old error still inside the tail
+ * never matches again after a re-login and the flag can clear. A file not in
+ * `seen` is read tail-only.
+ *
+ * `seen` is also pruned: an entry under `sessionsDir` whose file
+ * the listing no longer shows — archived, or its whole session dir gone — is
+ * dropped, so the map tracks the live tree instead of every file that ever
+ * existed. Only a listing that answered prunes: an entry under a directory
+ * that could not be read stays (its file is unknown, never gone). */
+export function scanPiAuthErrors(sessionsDir, sinceMs, seen) {
+    return scanPiAuth(sessionsDir, sinceMs, seen).hits;
+}
+/** `scanPiAuthErrors`, with how many observations failed (a directory that
+ * could not be listed, an entry that could not be stat'd, a file that could
+ * not be read): those were not seen, so they are not "quiet". */
+function scanPiAuth(sessionsDir, sinceMs, seen) {
+    const hits = [];
+    let unread = 0;
+    /** Every path the listing showed, and the dirs it could not list. */
+    const present = new Set();
+    const unlisted = [];
+    const visit = (dir, depth) => {
+        let names = [];
+        try {
+            names = readdirSync(dir);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                unlisted.push(dir);
+                unread++;
+            }
+            return;
+        }
+        for (const name of names) {
+            const path = join(dir, name);
+            present.add(path);
+            let st;
+            try {
+                st = statSync(path);
+            }
+            catch (err) {
+                // Gone since the listing: nothing to see. Anything else is unknown —
+                // its offsets (a directory's, or the file's own) are kept.
+                if (err.code !== "ENOENT") {
+                    unlisted.push(path);
+                    unread++;
+                }
+                continue;
+            }
+            if (st.isDirectory()) {
+                if (depth < 1)
+                    visit(path, depth + 1);
+                else
+                    unlisted.push(path); // deeper than the scan reads: unknown
+                continue;
+            }
+            if (!name.endsWith(".jsonl") || st.mtimeMs < sinceMs)
+                continue;
+            try {
+                const { text, next } = readFrom(path, seen?.get(path) ?? 0, AUTH_TAIL_BYTES);
+                seen?.set(path, next);
+                if (text.split("\n").some(lineHasAuthError))
+                    hits.push({ file: path, mtimeMs: st.mtimeMs });
+            }
+            catch {
+                unread++;
+            }
+        }
+    };
+    visit(sessionsDir, 0);
+    if (seen) {
+        const under = `${sessionsDir}${sep}`;
+        for (const path of [...seen.keys()]) {
+            if (!path.startsWith(under) || present.has(path))
+                continue;
+            if (unlisted.some((d) => path === d || path.startsWith(`${d}${sep}`)))
+                continue;
+            seen.delete(path);
+        }
+    }
+    return { hits, unread };
+}
+/** How long a detection keeps the status flag up with no fresh errors. */
+export const AUTH_FLAG_FRESH_MS = 30 * 60 * 1000;
+/**
+ * Stateful watcher for the daemon tick. Each scan covers files modified since
+ * the previous scan (first scan looks 10 minutes back). `status()` reports
+ * the flag while the last detection is fresh (< AUTH_FLAG_FRESH_MS) — the
+ * flag clears itself once the errors stop.
+ */
+export class PiAuthWatch {
+    now;
+    sinceMs;
+    lastErrorAt = null;
+    totalHits = 0;
+    /** Per-file offset already scanned — a match is a NEW error line, never an
+     * old one the tail still holds. */
+    seen = new Map();
+    sessionsDirs;
+    constructor(
+    /** One root, or several: each is scanned the same way (dir + one sublevel). */
+    sessionsDirs, now = () => new Date()) {
+        this.now = now;
+        this.sessionsDirs = typeof sessionsDirs === "string" ? [sessionsDirs] : [...sessionsDirs];
+        this.sinceMs = this.now().getTime() - 10 * 60 * 1000;
+    }
+    /** How many files the scan is tracking an offset for — the live tree's
+     * session files it has read, never every file that ever existed. */
+    trackedFiles() {
+        return this.seen.size;
+    }
+    /** Returns the NEW hits found this scan (empty array when quiet). */
+    scan() {
+        const started = this.now().getTime();
+        const scans = this.sessionsDirs.map((dir) => scanPiAuth(dir, this.sinceMs, this.seen));
+        const hits = scans.flatMap((x) => x.hits);
+        // Next scan starts at this scan's start, minus a minute of overlap so a
+        // write racing the scan is never missed; the per-file offsets keep the
+        // overlap from re-reading (and re-counting) bytes already scanned. A scan
+        // that could not read something keeps its window: what it missed stays
+        // eligible until a scan reads it (the offsets still stop a re-count).
+        if (scans.every((x) => x.unread === 0))
+            this.sinceMs = started - 60 * 1000;
+        if (hits.length > 0) {
+            this.lastErrorAt = started;
+            this.totalHits += hits.length;
+        }
+        return hits;
+    }
+    status() {
+        if (this.lastErrorAt === null)
+            return undefined;
+        if (this.now().getTime() - this.lastErrorAt > AUTH_FLAG_FRESH_MS)
+            return undefined;
+        return { last_at: new Date(this.lastErrorAt).toISOString(), hits: this.totalHits };
+    }
+}
+//# sourceMappingURL=authwatch.js.map

package/dist/src/authwatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authwatch.js","sourceRoot":"","sources":["../../src/authwatch.ts"],"names":[],"mappings":"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"}

package/dist/src/budget.d.ts

@@ -0,0 +1,15 @@
+export type Bounded<T> = {
+    kind: "done";
+    value: T;
+} | {
+    kind: "budget";
+};
+/**
+ * `work`'s answer, or `{ kind: "budget" }` once `ms` has passed — whichever
+ * comes first; the timer is cleared either way and never holds the process
+ * open. The work is NOT cancelled (a read already in the kernel cannot be): it
+ * runs on, and its late answer or rejection is dropped. A rejection BEFORE the
+ * budget is the caller's to catch.
+ */
+export declare function withinBudget<T>(work: Promise<T>, ms: number): Promise<Bounded<T>>;
+//# sourceMappingURL=budget.d.ts.map

package/dist/src/budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../src/budget.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEzE;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAgBvF"}

package/dist/src/budget.js

@@ -0,0 +1,32 @@
+// A bounded wait. A round end waits for its transcripts and its
+// integrity re-hash, and a dispatch for its integrity baseline, at most so
+// long — then goes on without the answer. A filesystem read that never
+// returns must cost a bounded wait and an honest "unknown", never a verdict
+// that is not applied or a dispatch pump that never moves again.
+/**
+ * `work`'s answer, or `{ kind: "budget" }` once `ms` has passed — whichever
+ * comes first; the timer is cleared either way and never holds the process
+ * open. The work is NOT cancelled (a read already in the kernel cannot be): it
+ * runs on, and its late answer or rejection is dropped. A rejection BEFORE the
+ * budget is the caller's to catch.
+ */
+export async function withinBudget(work, ms) {
+    let timer;
+    const budget = new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ kind: "budget" }), Math.max(0, ms));
+        timer.unref?.();
+    });
+    // Keeps a loser's late rejection handled.
+    work.catch(() => undefined);
+    try {
+        return await Promise.race([
+            work.then((value) => ({ kind: "done", value })),
+            budget,
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=budget.js.map

package/dist/src/budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.js","sourceRoot":"","sources":["../../src/budget.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,2EAA2E;AAC3E,uEAAuE;AACvE,4EAA4E;AAC5E,iEAAiE;AAIjE;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAI,IAAgB,EAAE,EAAU;IAChE,IAAI,KAAgD,CAAC;IACrD,MAAM,MAAM,GAAG,IAAI,OAAO,CAAa,CAAC,OAAO,EAAE,EAAE;QACjD,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QACvE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;IAClB,CAAC,CAAC,CAAC;IACH,0CAA0C;IAC1C,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IAC5B,IAAI,CAAC;QACH,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,EAAc,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;YAC3D,MAAM;SACP,CAAC,CAAC;IACL,CAAC;YAAS,CAAC;QACT,IAAI,KAAK,KAAK,SAAS;YAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC"}

package/dist/src/casebudget.d.ts

@@ -0,0 +1,3 @@
+/** Time reserved for a leaf pi process to stop after cancellation. */
+export declare const CASE_STOP_GRACE_MS = 5000;
+//# sourceMappingURL=casebudget.d.ts.map

package/dist/src/casebudget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"casebudget.d.ts","sourceRoot":"","sources":["../../src/casebudget.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,OAAQ,CAAC"}

package/dist/src/casebudget.js

@@ -0,0 +1,3 @@
+/** Time reserved for a leaf pi process to stop after cancellation. */
+export const CASE_STOP_GRACE_MS = 5_000;
+//# sourceMappingURL=casebudget.js.map

package/dist/src/casebudget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"casebudget.js","sourceRoot":"","sources":["../../src/casebudget.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,CAAC"}

package/dist/src/cigate.d.ts

@@ -0,0 +1,116 @@
+/**
+ * One check at a head, as GitHub's check-runs / statuses APIs report it.
+ *
+ * `source` says which of the two APIs it came from, and the adapter
+ * (`github.ts listChecks`) is its ONLY writer. It is the carrier the
+ * latest-run rule keys on: a check-run can supersede an older
+ * check-run of its name; a commit status never supersedes anything and is
+ * never superseded. Without the kind on the row, a status and a check-run of
+ * one name are told apart only by whether `started_at` happens to be set —
+ * and a check-run GitHub reports with a null start then reads as a status.
+ */
+export interface CheckSummary {
+    name: string;
+    /** `check_run` from the check-runs API; `status` from the combined status
+     * endpoint (which already dedupes statuses per context). */
+    source: "check_run" | "status";
+    /** `queued` | `in_progress` | `completed` (statuses map onto these). */
+    status: string;
+    /** `success` | `failure` | `cancelled` | `timed_out` | `skipped` | … */
+    conclusion: string | null;
+    /** When the run started — the recency key for latest-run-per-name
+     * among check-runs. Set on check-runs (nullable in GitHub's schema)
+     * and never on commit statuses: the adapter does not carry a time for
+     * them, and `latestRunPerName` does not collapse them at all. */
+    started_at?: string | null;
+}
+/**
+ * The four things CI can be at a head:
+ *
+ *  - `green`   every check completed and at least one really succeeded
+ *  - `red`     something completed badly — failure, cancelled, timed out,
+ *              action_required, stale. No special-casing: an infra
+ *              cancellation blocks exactly like a failing test.
+ *  - `pending` a check is still queued or running — not green *yet*
+ *  - `none`    no check reported at this head at all
+ */
+export type CiState = "green" | "red" | "pending" | "none";
+/**
+ * Only the most recent run of each check name counts. GitHub auto-cancels
+ * superseded workflow runs, leaving permanent `completed/cancelled` husks
+ * beside the run that actually finished; counting every run would classify
+ * such a head red forever and no withheld approval could ever release.
+ *
+ * The rule, exactly, keyed on `source`:
+ *
+ *  - Only CHECK-RUNS collapse. Among check-runs of one name that carry a
+ *    `started_at`, the latest start wins; an equal start resolves to the
+ *    later list position. A check-run WITHOUT a timestamp (null in GitHub's
+ *    schema) never competes with a timestamped one in either direction — it
+ *    stands beside that name's latest timestamped run and counts on its own;
+ *    among untimestamped check-runs of one name the later list position wins.
+ *    A missing timestamp is unknown, never "older than everything".
+ *  - A COMMIT STATUS is never collapsed with anything — not with a check-run
+ *    of its name, not with another status. The combined status endpoint
+ *    already dedupes per context, and a status under the same context as a
+ *    check-run is a second check, not a superseded run.
+ *
+ * Why the kind and not the timestamp decides: collapsing a status with a
+ * same-named check-run lets one hide the other. A failing status could lose
+ * to a passing check-run, or an untimestamped check-run (queued, or failed
+ * with a null start) could lose to a passing status listed after it — either
+ * way red or pending reads green. `scripts/pr-checks.sh` reads check-runs and commit statuses and applies
+ * both clauses. Keep the two in step (`tests/fences-cigate.test.ts`).
+ */
+export declare function latestRunPerName(checks: readonly CheckSummary[]): CheckSummary[];
+/**
+ * Classify the checks at one head. Pure — both the gate guard and the shell
+ * mirror answer from this table, so "green" means the same thing on every
+ * posting route.
+ *
+ * A suite whose every check is skipped or neutral is not green: it reports
+ * `red`, because there is no evidence this PR's code passed anything.
+ */
+export declare function classifyCi(allChecks: readonly CheckSummary[]): CiState;
+/**
+ * One check's outcome — the per-check half of `classifyCi`, and the one
+ * reading of a check anything else (the escalation's failing-check rule)
+ * may use. `failed` is every finished conclusion that is neither a success
+ * nor inert: failure, cancelled, timed_out, action_required, stale, …
+ */
+export declare function checkOutcome(c: CheckSummary): "pending" | "success" | "inert" | "failed";
+/**
+ * Does this CI state make APPROVE unavailable?
+ *
+ * `none` blocks only when `noChecksIsRed` says so: in a repo that normally
+ * runs CI, a head with zero check-runs — a conflicted PR, or CI that has not
+ * started — carries no execution evidence, so approval waits for checks to
+ * appear and pass. The flag is off by default so a repo with no CI at all is
+ * never permanently wedged.
+ */
+export declare function ciBlocksApproval(state: CiState, opts?: {
+    noChecksIsRed?: boolean;
+}): boolean;
+/** Plain-words reason, for the note and the logs. */
+export declare function ciStateReason(state: CiState): string;
+/**
+ * The paragraph a withheld review carries. It says the two things the author
+ * needs — that the review is finished and found nothing blocking, and that the
+ * approval is waiting on CI and on nothing else — so the work is never
+ * invisible while CI is broken.
+ */
+export declare function withheldApprovalNote(state: CiState, headSha: string): string;
+/** The review payload as it appears inside a `create_review` intent. */
+export interface CiReviewBody {
+    commit_id?: string;
+    event?: string;
+    body?: string;
+    comments?: unknown[];
+}
+/**
+ * APPROVE → COMMENT, findings untouched, with the withheld note appended.
+ * Never REQUEST_CHANGES: there is nothing for the author to change on the
+ * review's account, and the fault may be the base branch or infra.
+ */
+export declare function withholdApproval(body: CiReviewBody, state: CiState, headSha: string): CiReviewBody;
+//# sourceMappingURL=cigate.d.ts.map

package/dist/src/cigate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cigate.d.ts","sourceRoot":"","sources":["../../src/cigate.ts"],"names":[],"mappings":"AA2BA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb;gEAC4D;IAC5D,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC/B,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;qEAGiE;IACjE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,GAAG,KAAK,GAAG,SAAS,GAAG,MAAM,CAAC;AAS3D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,EAAE,CAwBhF;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAatE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAOxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAGhG;AAED,qDAAqD;AACrD,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAWpD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAO5E;AAED,wEAAwE;AACxE,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,GACd,YAAY,CAMd"}

package/dist/src/cigate.js

@@ -0,0 +1,176 @@
+// Red CI hard-gates APPROVE.
+//
+// The rule: no green CI at this head ⇒ APPROVE is unavailable, regardless of
+// findings. Infra problems block as well — deliberately simpler and stricter
+// than judging whether a failure is attributable to the PR, because a rule
+// that is argued case by case in prose makes the verdict depend on which
+// reviewer ran. The code is still reviewed and the findings still posted;
+// only the verdict is gated.
+//
+// Where the rule lives:
+//
+//   round-*.md Decide step ─► the session withholds the approval itself and
+//                             posts the full review as a COMMENT
+//   guards.ts (guard 4)    ─► the gate rewrites an APPROVE review to COMMENT
+//   this module            ─► the classifier both halves share
+//   ciretry.ts             ─► the retry (the bot's half)
+//
+// The retry is what makes the gate safe: a PR whose approval is withheld needs
+// something to notice when CI goes green, or an infra flake becomes a
+// permanently stuck PR. `approval_withheld` (state.ts) is the mark, the
+// `ci_completed` webhook is the trigger, and `retryWithheldApproval`
+// (src/ciretry.ts) re-queues the PR so its session can decide again — at
+// which point the approval is simply available.
+//
+// Nothing here triggers, re-runs or cancels CI: every call in this module is a
+// GET, exactly as the no-exec policy requires (`gh pr checks` / `gh api` only).
+/** Conclusions that are neither a success nor a failure: a path-filtered job
+ * skipped, an advisory check. They neither make CI green nor make it red. */
+const INERT_CONCLUSIONS = new Set(["skipped", "neutral"]);
+/** Not-yet-finished statuses. Anything else is treated as completed. */
+const UNFINISHED = new Set(["queued", "in_progress", "waiting", "pending", "requested"]);
+/**
+ * Only the most recent run of each check name counts. GitHub auto-cancels
+ * superseded workflow runs, leaving permanent `completed/cancelled` husks
+ * beside the run that actually finished; counting every run would classify
+ * such a head red forever and no withheld approval could ever release.
+ *
+ * The rule, exactly, keyed on `source`:
+ *
+ *  - Only CHECK-RUNS collapse. Among check-runs of one name that carry a
+ *    `started_at`, the latest start wins; an equal start resolves to the
+ *    later list position. A check-run WITHOUT a timestamp (null in GitHub's
+ *    schema) never competes with a timestamped one in either direction — it
+ *    stands beside that name's latest timestamped run and counts on its own;
+ *    among untimestamped check-runs of one name the later list position wins.
+ *    A missing timestamp is unknown, never "older than everything".
+ *  - A COMMIT STATUS is never collapsed with anything — not with a check-run
+ *    of its name, not with another status. The combined status endpoint
+ *    already dedupes per context, and a status under the same context as a
+ *    check-run is a second check, not a superseded run.
+ *
+ * Why the kind and not the timestamp decides: collapsing a status with a
+ * same-named check-run lets one hide the other. A failing status could lose
+ * to a passing check-run, or an untimestamped check-run (queued, or failed
+ * with a null start) could lose to a passing status listed after it — either
+ * way red or pending reads green. `scripts/pr-checks.sh` reads check-runs and commit statuses and applies
+ * both clauses. Keep the two in step (`tests/fences-cigate.test.ts`).
+ */
+export function latestRunPerName(checks) {
+    const kept = [];
+    const timedRuns = new Map();
+    const untimedRuns = new Map();
+    checks.forEach((check, idx) => {
+        if (check.source !== "check_run") {
+            kept.push({ check, idx }); // a status is never collapsed, in either direction
+            return;
+        }
+        const at = check.started_at || null; // "" carries no time either
+        if (at === null) {
+            untimedRuns.set(check.name, { check, idx });
+            return;
+        }
+        const prev = timedRuns.get(check.name);
+        if (!prev || at >= prev.at)
+            timedRuns.set(check.name, { check, idx, at });
+    });
+    return [...kept, ...timedRuns.values(), ...untimedRuns.values()]
+        .sort((x, y) => x.idx - y.idx)
+        .map((e) => e.check);
+}
+/**
+ * Classify the checks at one head. Pure — both the gate guard and the shell
+ * mirror answer from this table, so "green" means the same thing on every
+ * posting route.
+ *
+ * A suite whose every check is skipped or neutral is not green: it reports
+ * `red`, because there is no evidence this PR's code passed anything.
+ */
+export function classifyCi(allChecks) {
+    const checks = latestRunPerName(allChecks);
+    if (checks.length === 0)
+        return "none";
+    let pending = false;
+    let succeeded = false;
+    for (const c of checks) {
+        const outcome = checkOutcome(c);
+        if (outcome === "failed")
+            return "red";
+        if (outcome === "pending")
+            pending = true;
+        if (outcome === "success")
+            succeeded = true;
+    }
+    if (pending)
+        return "pending";
+    return succeeded ? "green" : "red";
+}
+/**
+ * One check's outcome — the per-check half of `classifyCi`, and the one
+ * reading of a check anything else (the escalation's failing-check rule)
+ * may use. `failed` is every finished conclusion that is neither a success
+ * nor inert: failure, cancelled, timed_out, action_required, stale, …
+ */
+export function checkOutcome(c) {
+    const status = (c.status ?? "").toLowerCase();
+    const conclusion = (c.conclusion ?? "").toLowerCase();
+    if (UNFINISHED.has(status) || (status !== "completed" && conclusion === ""))
+        return "pending";
+    if (conclusion === "success")
+        return "success";
+    if (INERT_CONCLUSIONS.has(conclusion))
+        return "inert";
+    return "failed";
+}
+/**
+ * Does this CI state make APPROVE unavailable?
+ *
+ * `none` blocks only when `noChecksIsRed` says so: in a repo that normally
+ * runs CI, a head with zero check-runs — a conflicted PR, or CI that has not
+ * started — carries no execution evidence, so approval waits for checks to
+ * appear and pass. The flag is off by default so a repo with no CI at all is
+ * never permanently wedged.
+ */
+export function ciBlocksApproval(state, opts = {}) {
+    if (state === "none")
+        return opts.noChecksIsRed === true;
+    return state === "red" || state === "pending";
+}
+/** Plain-words reason, for the note and the logs. */
+export function ciStateReason(state) {
+    switch (state) {
+        case "red":
+            return "CI is not green at this head";
+        case "pending":
+            return "CI has not finished at this head";
+        case "green":
+            return "CI is green at this head";
+        case "none":
+            return "no CI reported at this head";
+    }
+}
+/**
+ * The paragraph a withheld review carries. It says the two things the author
+ * needs — that the review is finished and found nothing blocking, and that the
+ * approval is waiting on CI and on nothing else — so the work is never
+ * invisible while CI is broken.
+ */
+export function withheldApprovalNote(state, headSha) {
+    return (`_**No blockers were found in this review.** Approval is withheld because ` +
+        `${ciStateReason(state)} (\`${headSha.slice(0, 7)}\`) — nothing above asks you to change anything, ` +
+        "and the failures may well be infrastructure or the base branch rather than this PR. " +
+        "The approval is waiting on green CI alone, and is re-attempted automatically once CI is green at this head._");
+}
+/**
+ * APPROVE → COMMENT, findings untouched, with the withheld note appended.
+ * Never REQUEST_CHANGES: there is nothing for the author to change on the
+ * review's account, and the fault may be the base branch or infra.
+ */
+export function withholdApproval(body, state, headSha) {
+    return {
+        ...body,
+        event: "COMMENT",
+        body: `${body.body ?? ""}\n\n${withheldApprovalNote(state, headSha)}`,
+    };
+}
+//# sourceMappingURL=cigate.js.map

package/dist/src/cigate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cigate.js","sourceRoot":"","sources":["../../src/cigate.ts"],"names":[],"mappings":"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"}

package/dist/src/codespan.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Author-controlled text rendered as Markdown DATA. A leaf module (no imports)
+ * so any renderer can use it without pulling in the prompt templates — the
+ * round prompts (`templates.ts`) and the escalation note (`escalation.ts`)
+ * both render repository paths, and both must keep them literal.
+ */
+/** The longest run of backticks in `text` (0 when none) — what a fence or a
+ * code span must out-length so nothing inside can close it (CommonMark). */
+export declare function longestBacktickRun(text: string): number;
+/** The backtick fence for a block of `text`: one longer than any backtick run
+ * inside it, and at least three, so nothing inside can close it. */
+export declare function backtickFence(text: string): string;
+/** Control characters (newlines included) as visible `\\uXXXX` escapes, so
+ * author-controlled text can never start a new line of prompt. */
+export declare function flatControls(text: string): string;
+/**
+ * A repository path as an inline code span that stays DATA. Git paths may hold
+ * backticks, pipes and newlines, and they are author-controlled: rendered raw
+ * they could close the span, split a plan-table row, or open a new line of
+ * daemon-authored prompt text. Control characters are shown as `\uXXXX`,
+ * and the fence is one backtick longer than any run inside the name
+ * (CommonMark), padded with a space when CommonMark would otherwise strip one
+ * of the name's own, so the name reads back exactly otherwise. Pipes are escaped
+ * only for a TABLE cell (`table`): GFM un-escapes `\|` there, even inside a
+ * code span, but everywhere else the backslash would read back as part of
+ * the path.
+ */
+export declare function codePath(path: string, opts?: {
+    table?: boolean;
+}): string;
+/**
+ * Author-derived text quoted inside a daemon-authored `("…")` in prompt text.
+ * It must not be able to close that quotation or start a new line of
+ * instructions: control characters collapse to a space and a double quote
+ * becomes a single one. No length cap — the caller owns the length (the round
+ * memory query is clamped at its own 600-character budget, and quoting it
+ * must not silently cut what the daemon actually asked).
+ */
+export declare function promptQuoted(text: string): string;
+/**
+ * A PR title quoted inside daemon-authored prompt text (`("{{title}}")` in the
+ * conversation system prompt and the round templates): `promptQuoted`, capped
+ * at 256 characters as GitHub caps titles.
+ */
+export declare function promptTitle(title: string): string;
+//# sourceMappingURL=codespan.d.ts.map

package/dist/src/codespan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codespan.d.ts","sourceRoot":"","sources":["../../src/codespan.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;4EAC4E;AAC5E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIvD;AAED;oEACoE;AACpE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAQD;kEACkE;AAClE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,MAAM,CAU7E;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD"}