pr-shepherd 0.2.0

package/src/cache/file-cache.test.mts

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { randomBytes } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { cacheGet, cacheSet, type CacheKey } from "./file-cache.mts";
+
+// Use a unique test prefix so runs never collide.
+function testKey(shape = "test"): CacheKey {
+  return {
+    owner: "test-owner",
+    repo: "test-repo",
+    pr: Math.floor(Math.random() * 900000) + 100000,
+    shape,
+  };
+}
+
+let testCacheDir: string;
+
+beforeEach(() => {
+  // Point cache at a temp subdir isolated per test run.
+  testCacheDir = `${process.env["TMPDIR"] ?? "/tmp"}/shepherd-test-${randomBytes(4).toString("hex")}`;
+  process.env["PR_SHEPHERD_CACHE_DIR"] = testCacheDir;
+});
+
+afterEach(async () => {
+  delete process.env["PR_SHEPHERD_CACHE_DIR"];
+  await rm(testCacheDir, { recursive: true, force: true });
+});
+
+describe("cacheGet / cacheSet", () => {
+  it("returns null on a cache miss", async () => {
+    const result = await cacheGet<string>(testKey());
+    expect(result).toBeNull();
+  });
+
+  it("returns the stored value on a cache hit", async () => {
+    const key = testKey();
+    const value = { foo: "bar", n: 42 };
+    await cacheSet(key, value);
+    const result = await cacheGet<typeof value>(key);
+    expect(result).toEqual(value);
+  });
+
+  it("returns null when the cache entry is expired", async () => {
+    const key = testKey();
+    await cacheSet(key, { data: "stale" });
+    // ttlSeconds=0 means the entry is immediately expired.
+    const result = await cacheGet(key, { ttlSeconds: 0 });
+    expect(result).toBeNull();
+  });
+
+  it("returns the value within TTL", async () => {
+    const key = testKey();
+    await cacheSet(key, "fresh");
+    const result = await cacheGet<string>(key, { ttlSeconds: 60 });
+    expect(result).toBe("fresh");
+  });
+
+  it("returns null when disabled", async () => {
+    const key = testKey();
+    await cacheSet(key, "should-not-be-returned", { disabled: false });
+    const result = await cacheGet(key, { disabled: true });
+    expect(result).toBeNull();
+  });
+
+  it("does not write when disabled", async () => {
+    const key = testKey();
+    await cacheSet(key, "ignored", { disabled: true });
+    const result = await cacheGet(key);
+    expect(result).toBeNull();
+  });
+
+  it("overwrites an existing cache entry", async () => {
+    const key = testKey();
+    await cacheSet(key, "first");
+    await cacheSet(key, "second");
+    const result = await cacheGet<string>(key);
+    expect(result).toBe("second");
+  });
+
+  it("handles different shapes as separate entries", async () => {
+    const pr = Math.floor(Math.random() * 900000) + 100000;
+    const keyA: CacheKey = { owner: "o", repo: "r", pr, shape: "shape-a" };
+    const keyB: CacheKey = { owner: "o", repo: "r", pr, shape: "shape-b" };
+
+    await cacheSet(keyA, "valueA");
+    await cacheSet(keyB, "valueB");
+
+    expect(await cacheGet<string>(keyA)).toBe("valueA");
+    expect(await cacheGet<string>(keyB)).toBe("valueB");
+  });
+});

package/src/cache/fix-attempts.mts

@@ -0,0 +1,86 @@
+/**
+ * Persistent attempt counter for the iterate escalation guard.
+ *
+ * Tracks how many times each review thread has been dispatched to the fix_code
+ * handler without being resolved. Counts are reset automatically when the HEAD
+ * commit SHA changes (i.e. a new push landed).
+ *
+ * State lives in `$TMPDIR/pr-shepherd-cache/<owner>-<repo>/<pr>/fix-attempts.json`.
+ */
+
+import { readFile, writeFile, rename, unlink, mkdir } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { SAFE_SEGMENT } from "../util/path-segment.mts";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface FixAttemptsState {
+  /** HEAD SHA at the time the counts were last written. Reset key. */
+  headSha: string;
+  /** Map from thread ID → number of fix_code dispatches that included this thread. */
+  threadAttempts: Record<string, number>;
+}
+
+interface CacheKey {
+  owner: string;
+  repo: string;
+  pr: number;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/** Read the current attempt state. Returns null on miss. */
+export async function readFixAttempts(key: CacheKey): Promise<FixAttemptsState | null> {
+  try {
+    const raw = await readFile(resolvePath(key), "utf8");
+    return JSON.parse(raw) as FixAttemptsState;
+  } catch {
+    return null;
+  }
+}
+
+/** Write attempt state (fire-and-forget — never throws). */
+export async function writeFixAttempts(key: CacheKey, state: FixAttemptsState): Promise<void> {
+  let tmp: string | undefined;
+  try {
+    const path = resolvePath(key);
+    tmp = `${path}.${randomUUID()}.tmp`;
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(tmp, JSON.stringify(state), "utf8");
+    await rename(tmp, path);
+    tmp = undefined;
+  } catch {
+    // Best-effort.
+  } finally {
+    if (tmp !== undefined) {
+      try {
+        await unlink(tmp);
+      } catch {
+        // Best-effort cleanup.
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function resolvePath(key: CacheKey): string {
+  for (const [field, value] of [
+    ["owner", key.owner],
+    ["repo", key.repo],
+  ] as const) {
+    if (!SAFE_SEGMENT.test(value)) {
+      throw new Error(`Invalid cache key segment "${field}": ${value}`);
+    }
+  }
+  const base = process.env["PR_SHEPHERD_CACHE_DIR"] ?? join(tmpdir(), "pr-shepherd-cache");
+  return join(base, `${key.owner}-${key.repo}`, String(key.pr), "fix-attempts.json");
+}

package/src/checks/classify.mts

@@ -0,0 +1,80 @@
+/**
+ * Classifies check runs into shepherd categories and filters out irrelevant ones.
+ *
+ * Rules:
+ *   1. Skip checks whose workflow event is NOT `pull_request` or `pull_request_target`.
+ *      Push-triggered, merge-queue, schedule, and workflow-dispatch runs are irrelevant
+ *      to PR readiness.
+ *   2. Drop checks with `conclusion == SKIPPED` or `conclusion == NEUTRAL` from the
+ *      pass/fail tally. Report them as "skipped" for transparency but don't block on them.
+ */
+
+import type { CheckRun, ClassifiedCheck } from "../types.mts";
+import { loadConfig } from "../config/load.mts";
+
+const RELEVANT_EVENTS = new Set(loadConfig().checks.ciTriggerEvents);
+
+/**
+ * Classify a list of raw check runs into shepherd categories.
+ *
+ * @param checks Raw check runs from the batch query.
+ * @returns Classified checks. "filtered" items were excluded from the tally.
+ */
+export function classifyChecks(checks: CheckRun[]): ClassifiedCheck[] {
+  return checks.map((c) => classify(c));
+}
+
+function classify(check: CheckRun): ClassifiedCheck {
+  // Filter: runs from non-PR events don't count toward PR readiness.
+  if (check.event !== null && !RELEVANT_EVENTS.has(check.event)) {
+    return { ...check, category: "filtered" };
+  }
+
+  const { status, conclusion } = check;
+
+  // Not yet finished.
+  if (status !== "COMPLETED") {
+    return { ...check, category: "in_progress" };
+  }
+
+  // Skipped / neutral — report but don't block.
+  if (conclusion === "SKIPPED" || conclusion === "NEUTRAL") {
+    return { ...check, category: "skipped" };
+  }
+
+  // Success.
+  if (conclusion === "SUCCESS") {
+    return { ...check, category: "passed" };
+  }
+
+  // Everything else (FAILURE, TIMED_OUT, CANCELLED, ACTION_REQUIRED, STARTUP_FAILURE, STALE).
+  return { ...check, category: "failing" };
+}
+
+// ---------------------------------------------------------------------------
+// Aggregate verdict helpers
+// ---------------------------------------------------------------------------
+
+export interface CiVerdict {
+  /** True when all relevant (non-filtered, non-skipped) checks passed. */
+  allPassed: boolean;
+  /** True when at least one check is still running/queued. */
+  anyInProgress: boolean;
+  /** True when at least one check failed. */
+  anyFailing: boolean;
+  /** Names of checks that were filtered out (triggered by non-PR events). */
+  filteredNames: string[];
+}
+
+/** Compute a high-level CI verdict from a list of classified checks. */
+export function getCiVerdict(classified: ClassifiedCheck[]): CiVerdict {
+  const relevant = classified.filter((c) => c.category !== "filtered" && c.category !== "skipped");
+  const anyInProgress = relevant.some((c) => c.category === "in_progress");
+  const anyFailing = relevant.some((c) => c.category === "failing");
+  // When there are no relevant checks (e.g. docs-only PR where all checks are filtered/skipped),
+  // treat as allPassed rather than blocking — there's nothing to fail.
+  const allPassed = !anyInProgress && !anyFailing;
+  const filteredNames = classified.filter((c) => c.category === "filtered").map((c) => c.name);
+
+  return { allPassed, anyInProgress, anyFailing, filteredNames };
+}

package/src/checks/classify.test.mts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from "vitest";
+import { classifyChecks, getCiVerdict } from "./classify.mts";
+import type { CheckRun } from "../types.mts";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makeCheck(overrides: Partial<CheckRun>): CheckRun {
+  return {
+    name: "tests",
+    status: "COMPLETED",
+    conclusion: "SUCCESS",
+    detailsUrl: "https://github.com/owner/repo/actions/runs/123/jobs/456",
+    event: "pull_request",
+    runId: "123",
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// classifyChecks
+// ---------------------------------------------------------------------------
+
+describe("classifyChecks — event filtering", () => {
+  it("keeps pull_request checks", () => {
+    const [c] = classifyChecks([makeCheck({ event: "pull_request" })]);
+    expect(c!.category).not.toBe("filtered");
+  });
+
+  it("keeps pull_request_target checks", () => {
+    const [c] = classifyChecks([makeCheck({ event: "pull_request_target" })]);
+    expect(c!.category).not.toBe("filtered");
+  });
+
+  it("filters push-triggered checks", () => {
+    const [c] = classifyChecks([makeCheck({ event: "push" })]);
+    expect(c!.category).toBe("filtered");
+  });
+
+  it("filters merge_group-triggered checks", () => {
+    const [c] = classifyChecks([makeCheck({ event: "merge_group" })]);
+    expect(c!.category).toBe("filtered");
+  });
+
+  it("filters schedule-triggered checks", () => {
+    const [c] = classifyChecks([makeCheck({ event: "schedule" })]);
+    expect(c!.category).toBe("filtered");
+  });
+
+  it("filters workflow_dispatch checks", () => {
+    const [c] = classifyChecks([makeCheck({ event: "workflow_dispatch" })]);
+    expect(c!.category).toBe("filtered");
+  });
+
+  it("keeps checks with null event (StatusContext nodes, no event available)", () => {
+    const [c] = classifyChecks([makeCheck({ event: null })]);
+    expect(c!.category).not.toBe("filtered");
+  });
+});
+
+describe("classifyChecks — conclusion mapping", () => {
+  it("classifies SUCCESS as passed", () => {
+    const [c] = classifyChecks([makeCheck({ conclusion: "SUCCESS" })]);
+    expect(c!.category).toBe("passed");
+  });
+
+  it("classifies SKIPPED as skipped", () => {
+    const [c] = classifyChecks([makeCheck({ conclusion: "SKIPPED" })]);
+    expect(c!.category).toBe("skipped");
+  });
+
+  it("classifies NEUTRAL as skipped", () => {
+    const [c] = classifyChecks([makeCheck({ conclusion: "NEUTRAL" })]);
+    expect(c!.category).toBe("skipped");
+  });
+
+  it("classifies FAILURE as failing", () => {
+    const [c] = classifyChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(c!.category).toBe("failing");
+  });
+
+  it("classifies TIMED_OUT as failing", () => {
+    const [c] = classifyChecks([makeCheck({ conclusion: "TIMED_OUT" })]);
+    expect(c!.category).toBe("failing");
+  });
+
+  it("classifies CANCELLED as failing", () => {
+    const [c] = classifyChecks([makeCheck({ conclusion: "CANCELLED" })]);
+    expect(c!.category).toBe("failing");
+  });
+
+  it("classifies ACTION_REQUIRED as failing", () => {
+    const [c] = classifyChecks([makeCheck({ conclusion: "ACTION_REQUIRED" })]);
+    expect(c!.category).toBe("failing");
+  });
+
+  it("classifies in-progress check (QUEUED) as in_progress", () => {
+    const [c] = classifyChecks([makeCheck({ status: "QUEUED", conclusion: null })]);
+    expect(c!.category).toBe("in_progress");
+  });
+
+  it("classifies in-progress check (IN_PROGRESS) as in_progress", () => {
+    const [c] = classifyChecks([makeCheck({ status: "IN_PROGRESS", conclusion: null })]);
+    expect(c!.category).toBe("in_progress");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getCiVerdict
+// ---------------------------------------------------------------------------
+
+describe("getCiVerdict", () => {
+  it("returns allPassed true when all relevant checks passed", () => {
+    const classified = classifyChecks([
+      makeCheck({ conclusion: "SUCCESS" }),
+      makeCheck({ name: "lint", conclusion: "SUCCESS" }),
+    ]);
+    const verdict = getCiVerdict(classified);
+    expect(verdict.allPassed).toBe(true);
+    expect(verdict.anyFailing).toBe(false);
+    expect(verdict.anyInProgress).toBe(false);
+  });
+
+  it("returns anyFailing when a check failed", () => {
+    const classified = classifyChecks([
+      makeCheck({ conclusion: "SUCCESS" }),
+      makeCheck({ name: "lint", conclusion: "FAILURE" }),
+    ]);
+    const verdict = getCiVerdict(classified);
+    expect(verdict.anyFailing).toBe(true);
+    expect(verdict.allPassed).toBe(false);
+  });
+
+  it("returns anyInProgress when a check is still running", () => {
+    const classified = classifyChecks([
+      makeCheck({ conclusion: "SUCCESS" }),
+      makeCheck({ name: "tests", status: "IN_PROGRESS", conclusion: null }),
+    ]);
+    const verdict = getCiVerdict(classified);
+    expect(verdict.anyInProgress).toBe(true);
+    expect(verdict.allPassed).toBe(false);
+  });
+
+  it("ignores filtered and skipped checks in the verdict", () => {
+    const classified = classifyChecks([
+      makeCheck({ event: "push", conclusion: "FAILURE" }), // filtered
+      makeCheck({ conclusion: "SKIPPED" }), // skipped
+      makeCheck({ name: "tests", conclusion: "SUCCESS" }), // passes
+    ]);
+    const verdict = getCiVerdict(classified);
+    expect(verdict.allPassed).toBe(true);
+    expect(verdict.anyFailing).toBe(false);
+  });
+
+  it("returns allPassed true when no relevant checks exist (e.g. docs-only PR)", () => {
+    // Only filtered checks — no relevant checks → allPassed true (nothing to fail).
+    const classified = classifyChecks([makeCheck({ event: "push", conclusion: "SUCCESS" })]);
+    const verdict = getCiVerdict(classified);
+    expect(verdict.allPassed).toBe(true);
+    expect(verdict.anyFailing).toBe(false);
+    expect(verdict.anyInProgress).toBe(false);
+  });
+});

package/src/checks/triage.mock.test.mts

@@ -0,0 +1,202 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Hoist mock BEFORE any imports so node:child_process is replaced before
+// triage.mts captures a reference to execFile via promisify().
+// ---------------------------------------------------------------------------
+
+const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
+
+vi.mock("node:child_process", () => ({
+  execFile: (
+    _cmd: string,
+    _args: string[],
+    _opts: Record<string, unknown>,
+    cb: (err: Error | null, result: { stdout: string }) => void,
+  ) => {
+    // Simulate promisify-compatible callback shape.
+    mockExecFile(_cmd, _args, _opts)
+      .then((result: { stdout: string }) => cb(null, result))
+      .catch((err: Error) => cb(err, { stdout: "" }));
+  },
+}));
+
+import { triageFailingChecks } from "./triage.mts";
+import type { ClassifiedCheck } from "../types.mts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeCheck(overrides: Partial<ClassifiedCheck> = {}): ClassifiedCheck {
+  return {
+    name: "tests",
+    status: "COMPLETED",
+    conclusion: "FAILURE",
+    detailsUrl: "https://github.com/owner/repo/actions/runs/99/jobs/1",
+    event: "pull_request",
+    runId: "run-99",
+    category: "failing",
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  mockExecFile.mockReset();
+});
+
+describe("triageFailingChecks — no runId", () => {
+  it("skips log fetch and returns actionable when runId is null", async () => {
+    const check = makeCheck({ runId: null });
+    const [result] = await triageFailingChecks([check]);
+    expect(result!.failureKind).toBe("actionable");
+    expect(mockExecFile).not.toHaveBeenCalled();
+  });
+});
+
+describe("triageFailingChecks — TIMED_OUT", () => {
+  it("returns timeout for TIMED_OUT conclusion regardless of logs", async () => {
+    mockExecFile.mockResolvedValue({ stdout: "test output: all good\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "TIMED_OUT" })]);
+    expect(result!.failureKind).toBe("timeout");
+  });
+
+  it('returns timeout when logs contain "exceeded the maximum execution time"', async () => {
+    mockExecFile.mockResolvedValue({ stdout: "Run exceeded the maximum execution time\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("timeout");
+  });
+
+  it('returns timeout when logs contain "cancel timeout"', async () => {
+    mockExecFile.mockResolvedValue({ stdout: "cancel timeout after 6 hours\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("timeout");
+  });
+
+  it('returns timeout when logs contain "job was cancelled"', async () => {
+    mockExecFile.mockResolvedValue({ stdout: "Job was cancelled due to timeout\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "CANCELLED" })]);
+    expect(result!.failureKind).toBe("timeout");
+  });
+});
+
+describe("triageFailingChecks — infrastructure", () => {
+  it("returns infrastructure for CANCELLED + runner error logs", async () => {
+    mockExecFile.mockResolvedValue({ stdout: "Runner error: the runner crashed\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "CANCELLED" })]);
+    expect(result!.failureKind).toBe("infrastructure");
+  });
+
+  it("returns infrastructure for CANCELLED + ECONNRESET logs", async () => {
+    mockExecFile.mockResolvedValue({ stdout: "Error: ECONNRESET connection reset\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "CANCELLED" })]);
+    expect(result!.failureKind).toBe("infrastructure");
+  });
+
+  it('returns infrastructure for CANCELLED + "lost communication with the server"', async () => {
+    mockExecFile.mockResolvedValue({
+      stdout: "The runner has lost communication with the server\n",
+    });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "CANCELLED" })]);
+    expect(result!.failureKind).toBe("infrastructure");
+  });
+
+  it("returns infrastructure when gh run view fails (empty logs)", async () => {
+    mockExecFile.mockRejectedValue(new Error("exit 1"));
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("infrastructure");
+  });
+
+  it("returns infrastructure for blank logs even with FAILURE conclusion", async () => {
+    mockExecFile.mockResolvedValue({ stdout: "   \n  \n  " });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("infrastructure");
+  });
+});
+
+describe("triageFailingChecks — flaky", () => {
+  it('returns flaky when logs contain "flaky"', async () => {
+    mockExecFile.mockResolvedValue({ stdout: "Test is flaky: TestFooBar failed 1/3 runs\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("flaky");
+  });
+
+  it('returns flaky when logs contain "race condition"', async () => {
+    mockExecFile.mockResolvedValue({ stdout: "Detected race condition in TestBar\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("flaky");
+  });
+
+  it('returns flaky when logs contain "retry"', async () => {
+    mockExecFile.mockResolvedValue({ stdout: "Attempt 3/3 failed, no retry left\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("flaky");
+  });
+});
+
+describe("triageFailingChecks — actionable", () => {
+  it("returns actionable for compile errors", async () => {
+    mockExecFile.mockResolvedValue({
+      stdout: "error TS2345: Argument of type 'string' is not assignable\n",
+    });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("actionable");
+  });
+
+  it("returns actionable for test assertion failures", async () => {
+    mockExecFile.mockResolvedValue({ stdout: "AssertionError: expected 42 to equal 43\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("actionable");
+  });
+
+  it("returns actionable for lint violations", async () => {
+    mockExecFile.mockResolvedValue({
+      stdout: "no-unused-vars: variable `foo` is defined but never used\n",
+    });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.failureKind).toBe("actionable");
+  });
+});
+
+describe("triageFailingChecks — logExcerpt", () => {
+  it("attaches logExcerpt for actionable failures", async () => {
+    mockExecFile.mockResolvedValue({ stdout: "Error: test failed\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.logExcerpt).toBeDefined();
+    expect(result!.logExcerpt).toContain("Error: test failed");
+  });
+
+  it("truncates logExcerpt to 3000 chars", async () => {
+    mockExecFile.mockResolvedValue({ stdout: "x".repeat(10_000) });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect((result!.logExcerpt?.length ?? 0) <= 3000).toBe(true);
+  });
+
+  it("strips ANSI escape codes from logs", async () => {
+    mockExecFile.mockResolvedValue({ stdout: "\u001B[31mERROR\u001B[0m: something failed\n" });
+    const [result] = await triageFailingChecks([makeCheck({ conclusion: "FAILURE" })]);
+    expect(result!.logExcerpt).not.toContain("\u001B");
+    expect(result!.logExcerpt).toContain("ERROR: something failed");
+  });
+});
+
+describe("triageFailingChecks — batch", () => {
+  it("triages multiple checks in parallel", async () => {
+    mockExecFile
+      .mockResolvedValueOnce({ stdout: "AssertionError: expected 1 to equal 2\n" })
+      .mockResolvedValueOnce({ stdout: "Runner error: crashed\n" });
+
+    const checks: ClassifiedCheck[] = [
+      makeCheck({ name: "tests", runId: "run-1", conclusion: "FAILURE" }),
+      makeCheck({ name: "build", runId: "run-2", conclusion: "CANCELLED" }),
+    ];
+    const results = await triageFailingChecks(checks);
+    expect(results).toHaveLength(2);
+    expect(results[0]!.failureKind).toBe("actionable");
+    expect(results[1]!.failureKind).toBe("infrastructure");
+  });
+});