9555152 · fc643fe · 38da4d7 · a8ce284 · 927bbd5 · df0381c
@@ -0,0 +1,8 @@
# Batch doctor (#7555)
When the merge queue's re-gate hands a pull back red (the re-gate carries it alone, so a red on top of other pulls is the queue's own search, #4999), `src/checks/doctor.ts` classes the red (`doctor_classify.ts`) and acts, in `crew/autonomy.ts`'s `handBack`:
- **functional, alone on its merge**: the pull is held "until green" (out of the line), commented with the test, file, error line and `bun test ./file` to reproduce, and assigned back to its builder. A new head that passes its own check lifts the hold (`releaseOnGreen`). A red is held only when it reproduces on the queue's re-gate (the same head and base red again), so a flaky red still lands (#3155). A hold already on the pull (a person's) is kept, never overwritten.
- **budget / infra**: recorded as `recheck`, not held. the queue re-gates a red pull alone later (#3155).
Every act is a `maintenance_run` row (`duty = batch-doctor`): batch (`base:head`), culprit pull, class, action, probe (the first error line); the newest 200 per repository are kept (`RUNS_KEPT`). A sealed pull's number, batch and probe are told by no door. Read them on the flow panel (Batch doctor card), in the terminal Flow dialog, or as `doctor` in MCP `queue_gates` (all `doctorRuns`). A doctor's hold reason begins `batch doctor:` (`HOLD_PREFIX`, `isDoctorHold`). The infra class matches errno codes, `no space left`, `disk quota` and `tar:` lines only.
@@ -0,0 +1,184 @@
/**
 * The batch doctor (#7555): a merge-queue gate found one pull red. It classes
 * the red (`doctor_classify.ts`), and only a functional red of a pull alone
 * on its merge is held — out of the line, with a comment naming the exact
 * test, its file, the error line and the command to reproduce, and the pull
 * handed back to its builder. The hold is "until green": the first check
 * that passes on a new head lets it go (`actions/holds.ts` `releaseOnGreen`).
 * A hold already on the pull — a person's above all — is never overwritten.
 * Budget and infra reds are recorded and left to the queue's own re-gate.
 * It is called only on the queue's re-gate, which carries the pull alone.
 * Every act is one `maintenance_run` row; the newest `RUNS_KEPT` per
 * repository are kept.
 */
import type { Database } from "bun:sqlite";
import type { App } from "../app.ts";
import { builderOf } from "../actions/give_back.ts";
import { addComment } from "../actions/issues.ts";
import { getHold, setHold } from "../core/holds.ts";
import { getIssueById, setAssignee } from "../core/issues.ts";
import type { Pull } from "../core/pulls.ts";
import type { Repo } from "../core/repos.ts";
import type { User } from "../core/users.ts";
import { classify, reproduce, type Diagnosis } from "./doctor_classify.ts";
import type { Red } from "./queue.ts";
export const DUTY = "batch-doctor";
/** What every doctor hold's reason begins with: how a person and `releaseOnGreen` tell it from the autonomy user's own. */
export const HOLD_PREFIX = "batch doctor:";
export const isDoctorHold = (why: string): boolean => why.startsWith(HOLD_PREFIX);
export type DoctorAction = "held" | "recheck" | "kept";
/** The most `maintenance_run` rows the doctor keeps per repository; older ones are pruned on each write. */
export const RUNS_KEPT = 200;
export interface DoctorRun {
  /** `base:head`, blank for a sealed pull. */
  readonly batch: string;
  /** The pull's number, null for a sealed pull. */
  readonly culprit: number | null;
  readonly class: string;
  readonly action: string;
  readonly probe: string;
  readonly at: string;
  /** The culprit is a sealed pull: its number, batch and probe are not told. */
  readonly sealed: boolean;
}
/** Text a pull's author controls, made safe inside a markdown span: no backtick, `@`, newline or control character. */
export function plain(text: string): string {
  return text.replace(/[`@\u0000-\u001f\u007f]+/g, " ").replace(/ {2,}/g, " ").trim();
}
function cleaned(d: Diagnosis): Diagnosis {
  return {
    ...d,
    probe: plain(d.probe),
    ...(d.test === undefined
      ? {}
      : { test: { ...d.test, name: plain(d.test.name), ...(d.test.file === undefined ? {} : { file: plain(d.test.file) }) } }),
  };
      
        sentinelcrew
        21h ago
        outdated
      
      Untrusted test name, file and error text go into backtick spans unescaped. Sanitise them (backticks, newlines, @), same for whyLine and the stored hold.why.
    
}
/** Why a held pull says it is held: one line, the test first. */
function whyLine(d: Diagnosis): string {
  const name = d.test?.name ?? "the check";
  return `${HOLD_PREFIX} ${name} fails alone`;
}
/** The comment a held pull gets: test, file, error line, command, what lifts it. */
export function holdComment(d: Diagnosis, builder: User | undefined): string {
  const lines = ["The batch doctor held this pull: it is red on its own merge with main, in a functional test."];
  if (d.test !== undefined) {
    lines.push("", `- test: \`${d.test.name}\``);
    if (d.test.file !== undefined) lines.push(`- file: \`${d.test.file}\``);
  }
  lines.push(`- error: \`${d.probe}\``);
  const cmd = reproduce(d.test);
  if (cmd !== undefined) lines.push(`- reproduce: \`${cmd}\``);
  lines.push(
    "",
    `Rebase on main and fix it, then push: the hold lifts when the new head passes its own check.${builder ? ` Back to @${builder.username}.` : ""}`,
  );
  return lines.join("\n");
}
function record(app: App, repo: Repo, pull: Pull, batch: string, d: Diagnosis, action: DoctorAction): void {
  app.db
    .query(
      `INSERT INTO maintenance_run (duty, started, finished, findings, actions, probes, outcome, repo_id, issue_id, batch, culprit, class, action, probe)
       VALUES (?1, ?2, ?2, ?3, ?4, ?5, 'ok', ?6, ?7, ?8, ?9, ?10, ?11, ?12)`,
    )
    .run(
      DUTY,
      new Date().toISOString(),
      JSON.stringify([`${d.class} red on pull #${pull.number}`]),
      JSON.stringify([action]),
      JSON.stringify([d.probe]),
      repo.id,
      pull.id,
      batch,
      pull.number,
      d.class,
      action,
      d.probe,
    );
  app.db
    .query(
      `DELETE FROM maintenance_run WHERE duty = ?1 AND repo_id = ?2 AND id NOT IN
         (SELECT id FROM maintenance_run WHERE duty = ?1 AND repo_id = ?2 ORDER BY id DESC LIMIT ?3)`,
    )
    .run(DUTY, repo.id, RUNS_KEPT);
}
/** Treat one red the queue's re-gate handed back, the pull alone on its merge. `by` acts. */
export function treatRed(app: App, repo: Repo, by: User, pull: Pull, red: Red, baseOid: string): DoctorAction {
  const batch = `${baseOid.slice(0, 12)}:${pull.headOid.slice(0, 12)}`;
  const d = cleaned(classify(red.reason, red.tests));
  let action: DoctorAction;
  if (d.class !== "functional") action = "recheck";
  else if (getHold(app.db, pull.id) !== undefined) action = "kept";
  else {
    action = "held";
    const issue = getIssueById(app.db, pull.id);
    const hold = setHold(app.db, pull.id, by.id, whyLine(d).slice(0, 200), "green");
    app.bus.append({
      kind: "pull.held",
      repoId: repo.id,
      actorId: by.id,
      payload: { number: pull.number, why: hold.why },
    });
    if (issue !== undefined) {
      const builder = builderOf(app.db, repo, issue);
      addComment(app, by, repo, issue, holdComment(d, builder));
      if (builder && setAssignee(app.db, issue.id, builder.id))
        app.bus.append({
          kind: "pull.assigned",
          repoId: repo.id,
          actorId: by.id,
          payload: { number: pull.number, assignee: builder.username, agent: true },
        });
    }
  }
  record(app, repo, pull, batch, d, action);
  return action;
}
/** What a reader is told of one run: a sealed pull's number, batch and probe are blanked. */
const RUN_COLUMNS = `CASE WHEN i.sealed = 1 THEN '' ELSE m.batch END AS batch,
       CASE WHEN i.sealed = 1 THEN NULL ELSE m.culprit END AS culprit, m.class, m.action,
       CASE WHEN i.sealed = 1 THEN '' ELSE m.probe END AS probe, m.started AS at, COALESCE(i.sealed, 0) AS sealed`;
type RunRow = Omit<DoctorRun, "sealed"> & { sealed: number };
const toRun = ({ sealed, ...r }: RunRow): DoctorRun => ({ ...r, sealed: sealed === 1 });
/** The doctor's last runs on a repository, newest first; a sealed pull is not named. */
export function doctorRuns(db: Database, repoId: string, limit = 20): DoctorRun[] {
  return db
    .query<RunRow, [string, string, number]>(
      `SELECT ${RUN_COLUMNS}
         FROM maintenance_run m LEFT JOIN issue i ON i.id = m.issue_id
        WHERE m.duty = ?1 AND m.repo_id = ?2 ORDER BY m.id DESC LIMIT ?3`,
    )
    .all(DUTY, repoId, limit)
    .map(toRun);
}
/** The doctor's newest runs across repositories, in one read: every repository for `all`, public ones otherwise. */
export function recentDoctorRuns(db: Database, all: boolean, limit: number): { repo: string; run: DoctorRun }[] {
  return db
    .query<RunRow & { repo: string }, [string, number]>(
      `SELECT ${RUN_COLUMNS}, u.username || '/' || r.name AS repo
         FROM maintenance_run m
         JOIN repo r ON r.id = m.repo_id JOIN user u ON u.id = r.owner_id
         LEFT JOIN issue i ON i.id = m.issue_id
        WHERE m.duty = ?1${all ? "" : " AND r.visibility = 'public'"}
        ORDER BY m.id DESC LIMIT ?2`,
    )
    .all(DUTY, limit)
    .map(({ repo, ...r }) => ({ repo, run: toRun(r) }));
}
@@ -0,0 +1,59 @@
/**
 * The batch doctor's first question about a red (#7555): was it the load,
 * the machine, or the code? Read off the verdict the gate already carries
 * (`reason`, `tests`), never off a log.
 *
 * - `budget`: every failing test threw `expectBudget` — the gate's own load
 *   (the queue re-gates a red pull alone later); not held.
 * - `infra`: the gate stopped before tests, or a test died on the machine
 *   (extract, ENOENT, tarball, disk); not held.
 * - `functional`: a test the code made fail; held when alone.
 *
 * Plain data in, plain data out: no I/O.
 */
import type { GateReason } from "./gate_reason.ts";
import type { FailedTest, GateTests } from "./gate_tests.ts";
/** What a test's `expectBudget` throws: the mark of a timing red, not a logic one. */
const BUDGET_MARK = "over budget (expectBudget)";
export type RedClass = "budget" | "infra" | "functional";
export interface Diagnosis {
  readonly class: RedClass;
  /** The first failing test, when the gate named one. */
  readonly test?: FailedTest;
  /** The line the class went on: the first error line, else the reason. */
  readonly probe: string;
}
// Specific shapes only: a bare word like `extract` is as likely a function under test.
const INFRA = /\b(ENOENT|ENOSPC|EMFILE|ETIMEDOUT|ECONNRESET)\b|no space left|disk quota|(^|\s)tar: /i;
const PROBE_MAX = 300;
const clip = (s: string): string => (s.length > PROBE_MAX ? `${s.slice(0, PROBE_MAX - 1)}…` : s);
/** Class a red from its reason and the tests it named. */
export function classify(reason: GateReason | undefined, tests: GateTests | undefined): Diagnosis {
  if (reason !== undefined && (reason.kind === "install" || reason.kind === "setup" || reason.kind === "timeout"))
    return { class: "infra", probe: reason.kind };
  const failing = tests?.failing ?? [];
  const first = failing[0];
  const probe = clip(first?.errors[0] ?? (reason?.kind ?? "check"));
  // No test named: nothing to hold it by, so it is the queue's to re-gate.
  if (first === undefined) return { class: "infra", probe };
  const errors = (t: FailedTest): string => t.errors.join("\n");
  if (failing.every((t) => t.errors[0]?.includes(BUDGET_MARK))) return { class: "budget", test: first, probe };
  if (failing.every((t) => INFRA.test(errors(t)))) return { class: "infra", test: first, probe };
  return { class: "functional", test: first, probe };
}
const SAFE = /^[\w@./+-]{1,200}$/;
/** The command that reproduces a failing test, or undefined when its file is not a plain path. */
export function reproduce(test: FailedTest | undefined): string | undefined {
  if (test?.file === undefined || !SAFE.test(test.file)) return undefined;
  const path = test.file.startsWith("./") || test.file.startsWith("/") ? test.file : `./${test.file}`;
  return `bun test ${path}`;
}
@@ -0,0 +1,1 @@
e88ce9739bfc9660667668ab3ca760a26d48aa98064a8a4cb79908e44b5d9c77
@@ -0,0 +1,13 @@
// The batch doctor's acts (#7555) are `maintenance_run` rows (duty `batch-doctor`):
// the repository and pull they concern, the batch, the culprit pull, how the red
// was classed, what was done and the test output line it went on. Additive: columns only.
export default `
  ALTER TABLE maintenance_run ADD COLUMN repo_id TEXT;
  ALTER TABLE maintenance_run ADD COLUMN issue_id TEXT;
      
        sentinelcrew
        21h ago
        
      
      No cascade on these new columns: rows outlive their repository. Delete a repository's batch-doctor rows when the repository is deleted.
    
  ALTER TABLE maintenance_run ADD COLUMN batch TEXT NOT NULL DEFAULT '';
  ALTER TABLE maintenance_run ADD COLUMN culprit INTEGER;
  ALTER TABLE maintenance_run ADD COLUMN class TEXT NOT NULL DEFAULT '';
  ALTER TABLE maintenance_run ADD COLUMN action TEXT NOT NULL DEFAULT '';
  ALTER TABLE maintenance_run ADD COLUMN probe TEXT NOT NULL DEFAULT '';
  CREATE INDEX maintenance_run_repo ON maintenance_run (duty, repo_id, id);
  `;
@@ -1050,6 +1050,8 @@
export async function deleteRepo(
  // still reported.
  const removed = await deleteRepoDir(dir);
  if (!removed.ok && present) return err("delete_failed");
  // The doctor's rows carry `repo_id` without a foreign key (added columns on `maintenance_run`).
  db.query("DELETE FROM maintenance_run WHERE duty = 'batch-doctor' AND repo_id = ?1").run(repo.id);
  db.query("DELETE FROM repo WHERE id = ?1").run(repo.id);
  forgetRepoCursors(db, repo.id);
  forgetListings(db);
@@ -12,6 +12,7 @@
 * repository's origin.
 */
import { treatRed } from "../checks/doctor.ts";
import { tickBets } from "../actions/bets.ts";
import { betsInUse } from "../core/bets.ts";
import { onlyListDocs, resolveListConflicts } from "../actions/list-conflicts.ts";
@@ -2196,6 +2197,8 @@
async function admit(
      });
      addLearned(app.config.dataDir, pull.id, red.learn);
      if (!again) addComment(app, by, repo, getIssueById(app.db, pull.id) ?? pull, clashSaid(red.comment, together));
      // A red that reproduces on the re-gate is the code's: only then is it the doctor's to hold.
      if (again) treatRed(app, repo, by, pull, red, baseOid);
    },
  });
}
@@ -1,9 +1,10 @@
import { doctorRuns } from "../../../checks/doctor.ts";
import { recentGates } from "../../../checks/gate_result.ts";
import { good, bad, type Tool, REPO_ARG, repoArg, isAnswer } from "../shared.ts";
export const tool: Tool = {
  name: "queue_gates",
  doc: "`{ repo, limit? }`: the merge queue's recent gates, newest first (`limit` 1–100, default 20), as `GET …/queue/gates` answers: each gate's pulls, state, reason, counts and failing tests by name with their first error lines, a test red in two gates that share no pull flagged `flaky`",
  doc: "`{ repo, limit? }`: the merge queue's recent gates, newest first (`limit` 1–100, default 20), as `GET …/queue/gates` answers: each gate's pulls, state, reason, counts and failing tests by name with their first error lines, a test red in two gates that share no pull flagged `flaky`; `doctor`: the batch doctor's last acts on the repository (`culprit`, `class`, `action` held/recheck/kept, `probe`; a sealed pull's `culprit` is null and its `batch` and `probe` blank)",
  description: "Recent merge-queue gates: pulls, verdicts, failing tests.",
  inputSchema: {
    type: "object",
@@ -22,6 +23,6 @@
export const tool: Tool = {
      return bad("invalid", "`limit` is a whole number from 1 to 100");
    const gates = recentGates(ctx.app.db, repo.id, limit);
    const red = gates.filter((g) => g.state === "red").length;
    return good({ says: `${gates.length} gate(s), ${red} red.`, gates });
    return good({ says: `${gates.length} gate(s), ${red} red.`, gates, doctor: doctorRuns(ctx.app.db, repo.id, limit) });
  },
};
@@ -21,6 +21,7 @@
 */
import type { Database } from "bun:sqlite";
import { doctorRuns, type DoctorRun } from "../../checks/doctor.ts";
import { recentGates, type KeptResult } from "../../checks/gate_result.ts";
import { reportLine } from "../../checks/report.ts";
import { HOLDS } from "../../crew/held.ts";
@@ -133,6 +134,7 @@
export function flowLines(
          return [
            `${pad(truncate(q.repo, 15), 15)} ${pad(String(q.queued), 6, "right")} ${pad(String(q.gating), 6, "right")} ${pad(String(q.gates), 5, "right")} ${pad(String(q.landedHour), 9, "right")} ${pad(q.approvedToLanded === null ? "—" : String(q.approvedToLanded), 12, "right")}`,
            ...gateLines(id === undefined ? [] : recentGates(db, id, GATES_SHOWN), now.getTime(), inner),
            ...doctorLines(id === undefined ? [] : doctorRuns(db, id, DOCTOR_SHOWN), now.getTime(), inner),
          ];
        })),
    ...(red.length === 0
@@ -216,6 +218,17 @@
export function gateLines(gates: readonly KeptResult[], now: number, inner: numb
  });
}
/** The doctor's acts shown under a repository's gates. */
const DOCTOR_SHOWN = 3;
/** One indented line per batch-doctor act (#7555), newest first: `doctor #14 held · functional · how long ago · the error line`; none when it has not acted. */
export function doctorLines(runs: readonly DoctorRun[], now: number, inner: number): string[] {
  return runs.map((r) => {
    const pull = r.sealed || r.culprit === null ? "a sealed pull" : `#${r.culprit}`;
    return truncate(`  doctor ${pull} ${r.action} · ${r.class} · ${ago(Date.parse(r.at), now)}${r.probe === "" ? "" : ` · ${r.probe}`}`, inner);
  });
}
/** Idle pulls shown before `+N more`. */
const IDLE_SHOWN = 5;
@@ -0,0 +1,33 @@
/**
 * The batch doctor's last acts (#7555), for the flow panel: the newest ten
 * across the repositories the reader may see, one row each with when, the
 * culprit pull, what the doctor did and how it classed the red. A sealed
 * pull is named only as `a sealed pull`, with no probe; one read
 * (`recentDoctorRuns`).
 */
import type { Database } from "bun:sqlite";
import { recentDoctorRuns, type DoctorRun } from "../../checks/doctor.ts";
import { span } from "../../flow/pipeline.ts";
import { html, type Html } from "../html.ts";
import { badge, card, row } from "../ui.ts";
/** The most runs the card lists. */
export const DOCTOR_LISTED = 10;
function runRow(repo: string, run: DoctorRun, now: number): Html {
  const tone = run.action === "held" ? "danger" : "default";
  return row({
    data: { doctor: run.action },
    title: html`${run.sealed || run.culprit === null ? html`<span class="muted">a sealed pull</span>` : html`<a href="/${repo}/pulls/${String(run.culprit)}">#${String(run.culprit)}</a>`} ${badge(run.action, { tone })}`,
    meta: html`${span(Math.max(0, now - Date.parse(run.at)))} ago · ${repo} · ${run.class}`,
    ...(run.probe === "" ? {} : { facts: [{ label: "error", value: html`<span class="break">${run.probe}</span>` }] }),
  });
}
      
        sentinelcrew
        21h ago
        outdated
      
      Principle 1: say in one plain sentence what this card is for. Principle 7: the dotted meta line mixes repo, class and probe, so give the probe its own row.
    
/** The "Batch doctor" card: nothing until the doctor has treated a red (an empty card is one more note on a page held to a count). */
export function doctorCard(db: Database, owner: boolean, now: number): Html {
  const top = recentDoctorRuns(db, owner, DOCTOR_LISTED);
  if (top.length === 0) return html``;
  return card(html`<h2>Batch doctor</h2><p class="muted">When a merge gate finds a pull red on its own, the doctor names the failing test and holds the pull until it passes.</p><ul class="list">${top.map((l) => runRow(l.repo, l.run, now))}</ul>`, { id: "doctor" });
}
@@ -51,6 +51,7 @@
import { readHeld } from "../../flow/held.ts";
import { readVerified, verifiedSays, type VerifiedRow } from "../../flow/verified.ts";
import type { App } from "../../app.ts";
import { html, type Html } from "../html.ts";
import { doctorCard } from "./boards-doctor.ts";
import { keeperRow } from "../studio/keeper_row.ts";
import { gatesSection } from "./boards-gates.ts";
import { heldCard } from "./boards-held.ts";
@@ -233,6 +234,7 @@
export function flowPanel(app: App, reader: Reader, url: URL, base: string): Htm
    ${heldCard(readHeld(app, reader.kind === "owner", now))}
    ${queueCard(queuesFor(app, reader, new Date(now), { batches: true }))}
    ${gatesSection(app.db, reader.kind === "owner", now)}
    ${doctorCard(app.db, reader.kind === "owner", now)}
    ${url.searchParams.get("idle") === "all" && idle.length > 0 ? idleList(idle) : null}
    ${listed === null || shown === undefined ? null : outList(shown, listed.hour, now)}`;
}
@@ -0,0 +1,51 @@
import { describe, expect, test } from "bun:test";
import { classify, reproduce } from "../src/checks/doctor_classify.ts";
import { redFor } from "./helpers/doctor.ts";
const of = (error: string, reason?: Parameters<typeof redFor>[3]) => {
  const red = redFor("t", "test/a.test.ts", error, reason);
  return classify(red.reason, red.tests);
};
describe("the batch doctor classes a red", () => {
  test("every test over its budget is a budget red", () => {
    const d = of("error: over budget (expectBudget): GET / took 90ms, budget 50ms");
    expect(d.class).toBe("budget");
    expect(d.probe).toContain("over budget");
  });
  test("ENOENT, tarball and disk errors are infra", () => {
    expect(of("error: ENOENT: no such file or directory, open 'x'").class).toBe("infra");
    expect(of("error: tar: extract failed: unexpected end of tarball").class).toBe("infra");
    expect(of("error: ENOSPC: no space left on device").class).toBe("infra");
  });
  test("a functional error that merely says extract or tarball is not infra", () => {
    expect(of("error: expected extract() to return 3").class).toBe("functional");
    expect(of("error: tarball is not a function").class).toBe("functional");
  });
  test("a gate that stopped before its tests is infra", () => {
    expect(of("", { kind: "install" }).class).toBe("infra");
    expect(of("", { kind: "timeout" }).class).toBe("infra");
  });
  test("anything else is functional, with the test and its error line as the probe", () => {
    const d = of("error: expect(received).toBe(expected)");
    expect(d.class).toBe("functional");
    expect(d.test?.name).toBe("t");
    expect(d.probe).toBe("error: expect(received).toBe(expected)");
  });
  test("a mix of budget and functional reds is functional", () => {
    const red = redFor("a", "test/a.test.ts", "error: over budget (expectBudget): slow");
    const tests = { ...red.tests!, failed: 2, failing: [...red.tests!.failing, { name: "b", file: "test/b.test.ts", errors: ["error: boom"] }] };
    expect(classify(red.reason, tests).class).toBe("functional");
  });
  test("the reproduce command refuses a file that is not a plain path", () => {
    expect(reproduce({ name: "t", file: "test/a.test.ts", errors: [] })).toBe("bun test ./test/a.test.ts");
    expect(reproduce({ name: "t", file: "a; rm -rf /", errors: [] })).toBeUndefined();
    expect(reproduce(undefined)).toBeUndefined();
  });
});
@@ -0,0 +1,80 @@
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { deleteRepo } from "../src/actions/repos.ts";
import { doctorRuns, HOLD_PREFIX, isDoctorHold, RUNS_KEPT, treatRed } from "../src/checks/doctor.ts";
import { getHold } from "../src/core/holds.ts";
import { listComments } from "../src/core/issues.ts";
import { doctorWorld, redFor, type Doctor } from "./helpers/doctor.ts";
describe("the batch doctor and a red culprit", () => {
  let w: Doctor;
  beforeAll(async () => {
    w = await doctorWorld("culprit");
  });
  afterAll(() => w.close());
  test("a functional red alone is held with a comment naming test, file, error and command; the batch is recorded", async () => {
    const pull = await w.pull("bad.ts");
    const red = redFor("adds two numbers", "test/add.test.ts", "error: expect(received).toBe(expected)");
    expect(treatRed(w.app, w.repo, w.alice, pull, red, "b".repeat(40))).toBe("held");
    const hold = getHold(w.app.db, pull.id)!;
    expect(hold.until).toBe("green");
    expect(hold.why).toContain("adds two numbers");
    expect(hold.why.startsWith(HOLD_PREFIX)).toBe(true);
    expect(isDoctorHold(hold.why)).toBe(true);
    expect(isDoctorHold("waiting on a person")).toBe(false);
    const said = listComments(w.app.db, pull.id).map((c) => c.body).join("\n");
    expect(said).toContain("adds two numbers");
    expect(said).toContain("test/add.test.ts");
    expect(said).toContain("expect(received).toBe(expected)");
    expect(said).toContain("bun test ./test/add.test.ts");
    const [run] = doctorRuns(w.app.db, w.repo.id);
    expect(run).toMatchObject({ culprit: pull.number, class: "functional", action: "held" });
    expect(run!.batch).toStartWith("bbbbbbbbbbbb:");
    expect(run!.probe).toContain("expect(received)");
  });
  test("a budget-only red is rechecked, not held", async () => {
    const pull = await w.pull("slow.ts");
    const red = redFor("serves /", "test/slow.test.ts", "error: over budget (expectBudget): 90ms");
    expect(treatRed(w.app, w.repo, w.alice, pull, red, "c".repeat(40))).toBe("recheck");
    expect(getHold(w.app.db, pull.id)).toBeUndefined();
    expect(doctorRuns(w.app.db, w.repo.id)[0]).toMatchObject({ class: "budget", action: "recheck" });
  });
  test("the doctor keeps only its newest RUNS_KEPT runs per repository", async () => {
    const pull = await w.pull("many.ts");
    const red = redFor("serves /", "test/slow.test.ts", "error: over budget (expectBudget): 90ms");
    for (let i = 0; i < RUNS_KEPT + 5; i++) treatRed(w.app, w.repo, w.alice, pull, red, "e".repeat(40));
    const kept = w.app.db
      .query<{ n: number }, [string]>("SELECT COUNT(*) AS n FROM maintenance_run WHERE repo_id = ?1")
      .get(w.repo.id)!.n;
    expect(kept).toBe(RUNS_KEPT);
  });
  test("a test name with a backtick and @admin cannot break out of the span in the comment or the hold", async () => {
    const pull = await w.pull("evil.ts");
    const red = redFor("x` @admin [a](http://e.test) `", "test/e`@bob.test.ts", "error: boom` @carol");
    expect(treatRed(w.app, w.repo, w.alice, pull, red, "f".repeat(40))).toBe("held");
    const said = listComments(w.app.db, pull.id).map((c) => c.body).join("\n");
    expect(said).not.toContain("@admin");
    expect(said).not.toContain("@bob");
    expect(said).not.toContain("@carol");
    expect(getHold(w.app.db, pull.id)!.why).not.toContain("@");
    expect(getHold(w.app.db, pull.id)!.why).not.toContain("`");
    expect(said.split("`").length % 2).toBe(1);
    expect(said.match(/`[^`\n]*`/g)!.join("")).not.toContain("@");
  });
  test("deleting the repository deletes its doctor rows", async () => {
    const other = await doctorWorld("culprit-gone");
    try {
      const pull = await other.pull("g.ts");
      treatRed(other.app, other.repo, other.alice, pull, redFor("t", "test/t.test.ts", "error: x"), "a".repeat(40));
      expect(doctorRuns(other.app.db, other.repo.id).length).toBe(1);
      expect((await deleteRepo(other.app, other.alice, other.repo)).ok).toBe(true);
      expect(doctorRuns(other.app.db, other.repo.id).length).toBe(0);
    } finally {
      await other.close();
    }
  });
});
@@ -0,0 +1,91 @@
/**
 * The batch doctor's runs are reachable (#7555): the flow panel, the terminal Flow dialog and MCP `queue_gates`
 * each show them, and none tells a guest or a sealed pull's probe.
 */
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { treatRed } from "../src/checks/doctor.ts";
import { createToken } from "../src/core/tokens.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { doctorLines, flowLines } from "../src/tui/screens/flow.ts";
import { doctorWorld, redFor, type Doctor } from "./helpers/doctor.ts";
describe("the batch doctor's runs are reachable", () => {
  let w: Doctor;
  let servers: Servers;
  let pullNumber = 0;
  beforeAll(async () => {
    w = await doctorWorld("doors");
    servers = await serve(w.app);
    const pull = await w.pull("bad.ts");
    pullNumber = pull.number;
    treatRed(w.app, w.repo, w.alice, pull, redFor("adds two", "test/add.test.ts", "error: expected 3 got 4"), "c".repeat(40));
  });
  afterAll(async () => {
    servers.stop();
    await w.close();
  });
  const login = async (): Promise<string> => {
    const res = await fetch(`${servers.url}/signin`, {
      method: "POST",
      redirect: "manual",
      headers: { "content-type": "application/x-www-form-urlencoded", origin: servers.url },
      body: new URLSearchParams({ username: "alice", password: "a-good-passphrase" }),
    });
    return (res.headers.get("set-cookie") ?? "").split(";")[0] ?? "";
  };
  const mcp = async () => {
    const res = await fetch(`${servers.url}/mcp`, {
      method: "POST",
      headers: {
        authorization: `Bearer ${createToken(w.app.db, w.alice.id, "t", "ro").token}`,
        "content-type": "application/json",
        accept: "application/json, text/event-stream",
      },
      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "queue_gates", arguments: { repo: "alice/doors" } } }),
    });
    const body = (await res.json()) as { result: { isError?: boolean; content: { text: string }[] } };
    expect(body.result.isError).not.toBe(true);
    return JSON.parse(body.result.content[0]!.text) as { doctor: { culprit: number | null; batch: string; action: string; class: string; probe: string; sealed: boolean }[] };
  };
  const seal = (on: number) => w.app.db.query("UPDATE issue SET sealed = ?2 WHERE repo_id = ?1 AND number = ?3").run(w.repo.id, on, pullNumber);
  test("the flow panel lists it for the owner and not for a guest", async () => {
    const page = await (await fetch(`${servers.url}/boards`, { headers: { cookie: await login() } })).text();
    expect(page).toContain("Batch doctor");
    expect(page).toContain(`/alice/doors/pulls/${pullNumber}`);
    expect(page).toContain("expected 3 got 4");
    const guest = await (await fetch(`${servers.url}/boards`)).text();
    expect(guest).not.toContain("alice/doors");
    expect(guest).not.toContain("expected 3 got 4");
  });
  test("the terminal Flow dialog lists it under the repository's queue line", () => {
    const queues = [{ repo: "alice/doors", queued: 1, gating: 0, gates: 0, landedHour: 0, approvedToLanded: null }];
    const lines = flowLines(w.app.db, new Date(), [], { queues }, []);
    expect(lines.some((l) => l.startsWith(`  doctor #${pullNumber} held · functional`))).toBe(true);
  });
  test("MCP queue_gates carries it, and a read-only token may read it", async () => {
    const { doctor } = await mcp();
    expect(doctor[0]).toMatchObject({ culprit: pullNumber, action: "held", class: "functional", sealed: false });
    expect(doctor[0]!.probe).toContain("expected 3 got 4");
  });
  test("a sealed culprit is named by no door and its probe is blank", async () => {
    seal(1);
    try {
      const { doctor } = await mcp();
      expect(doctor[0]).toMatchObject({ sealed: true, probe: "", culprit: null, batch: "" });
      expect(JSON.stringify(doctor)).not.toContain(`"culprit":${pullNumber}`);
      const page = await (await fetch(`${servers.url}/boards`, { headers: { cookie: await login() } })).text();
      expect(page).toContain("a sealed pull");
      expect(page).not.toContain("expected 3 got 4");
      const lines = doctorLines(doctor.map((d) => ({ ...d, at: new Date().toISOString() })), Date.now(), 70);
      expect(lines[0]).toContain("a sealed pull");
      expect(lines[0]).not.toContain("expected 3 got 4");
    } finally {
      seal(0);
    }
  });
});
@@ -0,0 +1,30 @@
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { releaseOnGreen } from "../src/actions/holds.ts";
import { treatRed } from "../src/checks/doctor.ts";
import { getHold } from "../src/core/holds.ts";
import { claimRun, createRun, finishRun } from "../src/core/runs.ts";
import { doctorWorld, redFor, type Doctor } from "./helpers/doctor.ts";
describe("a hold the doctor set lifts on a green new head", () => {
  let w: Doctor;
  beforeAll(async () => {
    w = await doctorWorld("lift");
  });
  afterAll(() => w.close());
  const check = (pullId: string, number: number, commitOid: string, state: "ok" | "failed") => {
    const run = createRun(w.app.db, { repoId: w.repo.id, kind: "check", issueId: pullId, env: `pull-${number}`, commitOid, reason: "pull" });
    claimRun(w.app.db, run.id);
    return finishRun(w.app.db, run.id, { state, summary: state })!;
  };
  test("a red check keeps it, a green check of the head lets it go", async () => {
    const pull = await w.pull("lift.ts");
    treatRed(w.app, w.repo, w.alice, pull, redFor("t", "test/t.test.ts", "error: boom"), "e".repeat(40));
    expect(getHold(w.app.db, pull.id)).toBeDefined();
    expect(releaseOnGreen(w.app, check(pull.id, pull.number, pull.headOid, "failed"))).toBe(false);
    expect(getHold(w.app.db, pull.id)).toBeDefined();
    expect(releaseOnGreen(w.app, check(pull.id, pull.number, pull.headOid, "ok"))).toBe(true);
    expect(getHold(w.app.db, pull.id)).toBeUndefined();
  });
});
@@ -0,0 +1,32 @@
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { releaseOnGreen } from "../src/actions/holds.ts";
import { doctorRuns, treatRed } from "../src/checks/doctor.ts";
import { getHold, setHold } from "../src/core/holds.ts";
import { claimRun, createRun, finishRun } from "../src/core/runs.ts";
import { doctorWorld, redFor, type Doctor } from "./helpers/doctor.ts";
describe("the doctor never touches a hold a person set", () => {
  let w: Doctor;
  beforeAll(async () => {
    w = await doctorWorld("person");
  });
  afterAll(() => w.close());
  test("a person's hold stands through a functional red: kept, not overwritten", async () => {
    const pull = await w.pull("mine.ts");
    setHold(w.app.db, pull.id, w.alice.id, "waiting on design");
    const action = treatRed(w.app, w.repo, w.alice, pull, redFor("t", "test/t.test.ts", "error: boom"), "f".repeat(40));
    expect(action).toBe("kept");
    expect(getHold(w.app.db, pull.id)).toMatchObject({ why: "waiting on design", heldByName: "alice" });
    expect(doctorRuns(w.app.db, w.repo.id)[0]).toMatchObject({ action: "kept" });
  });
  test("a green check does not lift a person's plain hold", async () => {
    const pull = await w.pull("mine2.ts");
    setHold(w.app.db, pull.id, w.alice.id, "waiting on design");
    const run = createRun(w.app.db, { repoId: w.repo.id, kind: "check", issueId: pull.id, env: `pull-${pull.number}`, commitOid: pull.headOid, reason: "pull" });
    claimRun(w.app.db, run.id);
    expect(releaseOnGreen(w.app, finishRun(w.app.db, run.id, { state: "ok", summary: "ok" })!)).toBe(false);
    expect(getHold(w.app.db, pull.id)).toBeDefined();
  });
});
@@ -0,0 +1,76 @@
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../../src/app.ts";
import { openPull } from "../../src/actions/pulls.ts";
import { commitToBranch, createRepo } from "../../src/actions/repos.ts";
import type { Red } from "../../src/checks/queue.ts";
import { getPull, type Pull } from "../../src/core/pulls.ts";
import { getRepoById, type Repo } from "../../src/core/repos.ts";
import { createUser, type User } from "../../src/core/users.ts";
export interface Doctor {
  readonly app: App;
  readonly alice: User;
  readonly repo: Repo;
  /** Open one more pull from a fresh branch. */
  pull(path: string): Promise<Pull>;
  close(): Promise<void>;
}
/** A forge with one person, one repository, and a way to open pulls: what the doctor treats. */
export async function doctorWorld(name: string): Promise<Doctor> {
  const dataDir = await mkdtemp(join(tmpdir(), `forge-doctor-${name}-`));
  const app = createApp({ dataDir, port: 0 });
  const a = await createUser(app.db, {
    origin: "seed",
    trusted: true,
    username: "alice",
    email: "[email protected]",
    password: "a-good-passphrase",
    adminIfFirst: true,
  });
  if (!a.ok) throw new Error(a.error);
  const alice = a.value;
  const made = await createRepo(app, alice, { name, visibility: "private" });
  if (!made.ok) throw new Error(String(made.error));
  const seeded = await commitToBranch(app, alice, made.value, {
    message: "Start",
    files: [{ path: "README.md", content: `# ${name}\n` }],
  });
  if (!seeded.ok) throw new Error(JSON.stringify(seeded.error));
  const repo = getRepoById(app.db, made.value.id)!;
  return {
    app,
    alice,
    repo,
    async pull(path) {
      const pushed = await commitToBranch(app, alice, repo, {
        branch: `feature/${path}`,
        base: "main",
        message: path,
        files: [{ path, content: `export const n = "${path}";\n` }],
      });
      if (!pushed.ok) throw new Error(JSON.stringify(pushed.error));
      const opened = await openPull(app, alice, repo, { title: path, baseBranch: "main", headBranch: `feature/${path}` });
      if (!opened.ok) throw new Error(String(opened.error));
      return getPull(app.db, repo.id, opened.value.number)!;
    },
    async close() {
      await app.close?.();
      await rm(dataDir, { recursive: true, force: true });
    },
  };
}
/** A red verdict naming one failing test with this error line. */
export function redFor(name: string, file: string, error: string, reason: Red["reason"] = { kind: "tests", failed: 1 }): Red {
  return {
    lands: false,
    reopen: true,
    comment: "red",
    learn: [file],
    ...(reason === undefined ? {} : { reason }),
    tests: { passed: 10, failed: 1, failing: [{ name, file, errors: [error] }] },
  };
}
@@ -23,6 +23,8 @@
import { claimRun, createRun, finishRun } from "../src/core/runs.ts";
import { createUser, type User } from "../src/core/users.ts";
import { landIfGreen, REGATE_RED_MS, regateDue, sweepGreen } from "../src/crew/autonomy.ts";
import { listComments } from "../src/core/issues.ts";
import { doctorRuns, isDoctorHold } from "../src/checks/doctor.ts";
import { getHold } from "../src/core/holds.ts";
import { readQueues } from "../src/flow/queue.ts";
import { repoDir } from "../src/git/repos.ts";
import { logLevel, setLogLevel } from "../src/kernel/log.ts";
@@ -681,6 +683,39 @@
describe("the merge queue", () => {
    expect(await sweepGreen(app, repo)).toBe(1);
    expect(gatesOf(repo)).toHaveLength(before + 1);
    expect(merged(repo, pull)).toBe(true);
    // A red that went green on the re-gate was never the doctor's.
    expect(getHold(app.db, pull.id)).toBeUndefined();
    expect(doctorRuns(app.db, repo.id)).toEqual([]);
  });
  test("the batch doctor holds a red only once it reproduces on the re-gate, with its own comment (#7555)", async () => {
    const repo = await autonomousRepo("doctor-wiring");
    const pull = await greenPull(repo, "red-a.ts");
    expect(await sweepGreen(app, repo)).toBe(0);
    // First red: told, not held, nothing recorded.
    expect(getHold(app.db, pull.id)).toBeUndefined();
    expect(doctorRuns(app.db, repo.id)).toEqual([]);
    age(pull);
    expect(await sweepGreen(app, repo)).toBe(0);
    // The same head and base red again: held, marked as the doctor's, recorded.
    const hold = getHold(app.db, pull.id);
    expect(hold?.until).toBe("green");
    expect(isDoctorHold(hold!.why)).toBe(true);
    expect(hold!.why).toContain("goes red");
    const [run] = doctorRuns(app.db, repo.id);
    expect(run).toMatchObject({ culprit: pull.number, class: "functional", action: "held" });
    expect(listComments(app.db, pull.id).at(-1)!.body).toContain("bun test ./test/red.test.ts");
  });
  test("a red handed back while others landed ahead of it is not held by the doctor (#7555)", async () => {
    const repo = await autonomousRepo("doctor-on-top");
    const pulls = [];
    for (const name of ["a.ts", "b.ts", "red-c.ts"]) pulls.push(await greenPull(repo, name));
    expect(await sweepGreen(app, repo)).toBe(2);
    const red = pulls[2]!;
    expect(latestDecision(app.db, red.id, "land")?.answer).toBe("red");
    expect(getHold(app.db, red.id)).toBeUndefined();
    expect(doctorRuns(app.db, repo.id)).toEqual([]);
  });
  test("a red that reproduces on the re-gate stays red, told once", async () => {
@@ -695,7 +730,12 @@
describe("the merge queue", () => {
    expect(again?.answer).toBe("red");
    expect((again?.state as { again?: boolean }).again).toBe(true);
    expect(regateDue(again!, Date.now() + 10 * REGATE_RED_MS)).toBe(false);
    expect(listComments(app.db, pull.id)).toHaveLength(comments);
    // The red is not told twice. The one comment added is the doctor's hold
    // notice: it says the red reproduced, which the first comment could not.
    const added = listComments(app.db, pull.id).slice(comments);
    expect(added).toHaveLength(1);
    expect(added[0]!.body).toContain("The batch doctor held this pull");
    expect(added[0]!.body).toContain("goes red");
    // However long it waits now, it is not gated again until a side moves.
    age(pull);
    const before = gatesOf(repo).length;
		@@ -0,0 +1,8 @@
	1	# Batch doctor (#7555)
	2
	3	When the merge queue's re-gate hands a pull back red (the re-gate carries it alone, so a red on top of other pulls is the queue's own search, #4999), `src/checks/doctor.ts` classes the red (`doctor_classify.ts`) and acts, in `crew/autonomy.ts`'s `handBack`:
	4
	5	- functional, alone on its merge: the pull is held "until green" (out of the line), commented with the test, file, error line and `bun test ./file` to reproduce, and assigned back to its builder. A new head that passes its own check lifts the hold (`releaseOnGreen`). A red is held only when it reproduces on the queue's re-gate (the same head and base red again), so a flaky red still lands (#3155). A hold already on the pull (a person's) is kept, never overwritten.
	6	- budget / infra: recorded as `recheck`, not held. the queue re-gates a red pull alone later (#3155).
	7
	8	Every act is a `maintenance_run` row (`duty = batch-doctor`): batch (`base:head`), culprit pull, class, action, probe (the first error line); the newest 200 per repository are kept (`RUNS_KEPT`). A sealed pull's number, batch and probe are told by no door. Read them on the flow panel (Batch doctor card), in the terminal Flow dialog, or as `doctor` in MCP `queue_gates` (all `doctorRuns`). A doctor's hold reason begins `batch doctor:` (`HOLD_PREFIX`, `isDoctorHold`). The infra class matches errno codes, `no space left`, `disk quota` and `tar:` lines only.
		@@ -0,0 +1,184 @@
	1	/**
	2	* The batch doctor (#7555): a merge-queue gate found one pull red. It classes
	3	* the red (`doctor_classify.ts`), and only a functional red of a pull alone
	4	* on its merge is held — out of the line, with a comment naming the exact
	5	* test, its file, the error line and the command to reproduce, and the pull
	6	* handed back to its builder. The hold is "until green": the first check
	7	* that passes on a new head lets it go (`actions/holds.ts` `releaseOnGreen`).
	8	* A hold already on the pull — a person's above all — is never overwritten.
	9	* Budget and infra reds are recorded and left to the queue's own re-gate.
	10	* It is called only on the queue's re-gate, which carries the pull alone.
	11	* Every act is one `maintenance_run` row; the newest `RUNS_KEPT` per
	12	* repository are kept.
	13	*/
	14
	15	import type { Database } from "bun:sqlite";
	16	import type { App } from "../app.ts";
	17	import { builderOf } from "../actions/give_back.ts";
	18	import { addComment } from "../actions/issues.ts";
	19	import { getHold, setHold } from "../core/holds.ts";
	20	import { getIssueById, setAssignee } from "../core/issues.ts";
	21	import type { Pull } from "../core/pulls.ts";
	22	import type { Repo } from "../core/repos.ts";
	23	import type { User } from "../core/users.ts";
	24	import { classify, reproduce, type Diagnosis } from "./doctor_classify.ts";
	25	import type { Red } from "./queue.ts";
	26
	27	export const DUTY = "batch-doctor";
	28
	29	/** What every doctor hold's reason begins with: how a person and `releaseOnGreen` tell it from the autonomy user's own. */
	30	export const HOLD_PREFIX = "batch doctor:";
	31
	32	export const isDoctorHold = (why: string): boolean => why.startsWith(HOLD_PREFIX);
	33
	34	export type DoctorAction = "held" \| "recheck" \| "kept";
	35
	36	/** The most `maintenance_run` rows the doctor keeps per repository; older ones are pruned on each write. */
	37	export const RUNS_KEPT = 200;
	38
	39	export interface DoctorRun {
	40	/** `base:head`, blank for a sealed pull. */
	41	readonly batch: string;
	42	/** The pull's number, null for a sealed pull. */
	43	readonly culprit: number \| null;
	44	readonly class: string;
	45	readonly action: string;
	46	readonly probe: string;
	47	readonly at: string;
	48	/** The culprit is a sealed pull: its number, batch and probe are not told. */
	49	readonly sealed: boolean;
	50	}
	51
	52	/** Text a pull's author controls, made safe inside a markdown span: no backtick, `@`, newline or control character. */
	53	export function plain(text: string): string {
	54	return text.replace(/[`@\u0000-\u001f\u007f]+/g, " ").replace(/ {2,}/g, " ").trim();
	55	}
	56
	57	function cleaned(d: Diagnosis): Diagnosis {
	58	return {
	59	...d,
	60	probe: plain(d.probe),
	61	...(d.test === undefined
	62	? {}
	63	: { test: { ...d.test, name: plain(d.test.name), ...(d.test.file === undefined ? {} : { file: plain(d.test.file) }) } }),
	64	};
		sentinelcrew 21h ago outdated Untrusted test name, file and error text go into backtick spans unescaped. Sanitise them (backticks, newlines, `@`), same for `whyLine` and the stored `hold.why`.
	65	}
	66
	67	/** Why a held pull says it is held: one line, the test first. */
	68	function whyLine(d: Diagnosis): string {
	69	const name = d.test?.name ?? "the check";
	70	return `${HOLD_PREFIX} ${name} fails alone`;
	71	}
	72
	73	/** The comment a held pull gets: test, file, error line, command, what lifts it. */
	74	export function holdComment(d: Diagnosis, builder: User \| undefined): string {
	75	const lines = ["The batch doctor held this pull: it is red on its own merge with main, in a functional test."];
	76	if (d.test !== undefined) {
	77	lines.push("", `- test: \`${d.test.name}\``);
	78	if (d.test.file !== undefined) lines.push(`- file: \`${d.test.file}\``);
	79	}
	80	lines.push(`- error: \`${d.probe}\``);
	81	const cmd = reproduce(d.test);
	82	if (cmd !== undefined) lines.push(`- reproduce: \`${cmd}\``);
	83	lines.push(
	84	"",
	85	`Rebase on main and fix it, then push: the hold lifts when the new head passes its own check.${builder ? ` Back to @${builder.username}.` : ""}`,
	86	);
	87	return lines.join("\n");
	88	}
	89
	90	function record(app: App, repo: Repo, pull: Pull, batch: string, d: Diagnosis, action: DoctorAction): void {
	91	app.db
	92	.query(
	93	`INSERT INTO maintenance_run (duty, started, finished, findings, actions, probes, outcome, repo_id, issue_id, batch, culprit, class, action, probe)
	94	VALUES (?1, ?2, ?2, ?3, ?4, ?5, 'ok', ?6, ?7, ?8, ?9, ?10, ?11, ?12)`,
	95	)
	96	.run(
	97	DUTY,
	98	new Date().toISOString(),
	99	JSON.stringify([`${d.class} red on pull #${pull.number}`]),
	100	JSON.stringify([action]),
	101	JSON.stringify([d.probe]),
	102	repo.id,
	103	pull.id,
	104	batch,
	105	pull.number,
	106	d.class,
	107	action,
	108	d.probe,
	109	);
	110	app.db
	111	.query(
	112	`DELETE FROM maintenance_run WHERE duty = ?1 AND repo_id = ?2 AND id NOT IN
	113	(SELECT id FROM maintenance_run WHERE duty = ?1 AND repo_id = ?2 ORDER BY id DESC LIMIT ?3)`,
	114	)
	115	.run(DUTY, repo.id, RUNS_KEPT);
	116	}
	117
	118	/** Treat one red the queue's re-gate handed back, the pull alone on its merge. `by` acts. */
	119	export function treatRed(app: App, repo: Repo, by: User, pull: Pull, red: Red, baseOid: string): DoctorAction {
	120	const batch = `${baseOid.slice(0, 12)}:${pull.headOid.slice(0, 12)}`;
	121	const d = cleaned(classify(red.reason, red.tests));
	122	let action: DoctorAction;
	123	if (d.class !== "functional") action = "recheck";
	124	else if (getHold(app.db, pull.id) !== undefined) action = "kept";
	125	else {
	126	action = "held";
	127	const issue = getIssueById(app.db, pull.id);
	128	const hold = setHold(app.db, pull.id, by.id, whyLine(d).slice(0, 200), "green");
	129	app.bus.append({
	130	kind: "pull.held",
	131	repoId: repo.id,
	132	actorId: by.id,
	133	payload: { number: pull.number, why: hold.why },
	134	});
	135	if (issue !== undefined) {
	136	const builder = builderOf(app.db, repo, issue);
	137	addComment(app, by, repo, issue, holdComment(d, builder));
	138	if (builder && setAssignee(app.db, issue.id, builder.id))
	139	app.bus.append({
	140	kind: "pull.assigned",
	141	repoId: repo.id,
	142	actorId: by.id,
	143	payload: { number: pull.number, assignee: builder.username, agent: true },
	144	});
	145	}
	146	}
	147	record(app, repo, pull, batch, d, action);
	148	return action;
	149	}
	150
	151	/** What a reader is told of one run: a sealed pull's number, batch and probe are blanked. */
	152	const RUN_COLUMNS = `CASE WHEN i.sealed = 1 THEN '' ELSE m.batch END AS batch,
	153	CASE WHEN i.sealed = 1 THEN NULL ELSE m.culprit END AS culprit, m.class, m.action,
	154	CASE WHEN i.sealed = 1 THEN '' ELSE m.probe END AS probe, m.started AS at, COALESCE(i.sealed, 0) AS sealed`;
	155
	156	type RunRow = Omit<DoctorRun, "sealed"> & { sealed: number };
	157	const toRun = ({ sealed, ...r }: RunRow): DoctorRun => ({ ...r, sealed: sealed === 1 });
	158
	159	/** The doctor's last runs on a repository, newest first; a sealed pull is not named. */
	160	export function doctorRuns(db: Database, repoId: string, limit = 20): DoctorRun[] {
	161	return db
	162	.query<RunRow, [string, string, number]>(
	163	`SELECT ${RUN_COLUMNS}
	164	FROM maintenance_run m LEFT JOIN issue i ON i.id = m.issue_id
	165	WHERE m.duty = ?1 AND m.repo_id = ?2 ORDER BY m.id DESC LIMIT ?3`,
	166	)
	167	.all(DUTY, repoId, limit)
	168	.map(toRun);
	169	}
	170
	171	/** The doctor's newest runs across repositories, in one read: every repository for `all`, public ones otherwise. */
	172	export function recentDoctorRuns(db: Database, all: boolean, limit: number): { repo: string; run: DoctorRun }[] {
	173	return db
	174	.query<RunRow & { repo: string }, [string, number]>(
	175	`SELECT ${RUN_COLUMNS}, u.username \|\| '/' \|\| r.name AS repo
	176	FROM maintenance_run m
	177	JOIN repo r ON r.id = m.repo_id JOIN user u ON u.id = r.owner_id
	178	LEFT JOIN issue i ON i.id = m.issue_id
	179	WHERE m.duty = ?1${all ? "" : " AND r.visibility = 'public'"}
	180	ORDER BY m.id DESC LIMIT ?2`,
	181	)
	182	.all(DUTY, limit)
	183	.map(({ repo, ...r }) => ({ repo, run: toRun(r) }));
	184	}
		@@ -0,0 +1,59 @@
	1	/**
	2	* The batch doctor's first question about a red (#7555): was it the load,
	3	* the machine, or the code? Read off the verdict the gate already carries
	4	* (`reason`, `tests`), never off a log.
	5	*
	6	* - `budget`: every failing test threw `expectBudget` — the gate's own load
	7	* (the queue re-gates a red pull alone later); not held.
	8	* - `infra`: the gate stopped before tests, or a test died on the machine
	9	* (extract, ENOENT, tarball, disk); not held.
	10	* - `functional`: a test the code made fail; held when alone.
	11	*
	12	* Plain data in, plain data out: no I/O.
	13	*/
	14
	15	import type { GateReason } from "./gate_reason.ts";
	16	import type { FailedTest, GateTests } from "./gate_tests.ts";
	17
	18	/** What a test's `expectBudget` throws: the mark of a timing red, not a logic one. */
	19	const BUDGET_MARK = "over budget (expectBudget)";
	20
	21	export type RedClass = "budget" \| "infra" \| "functional";
	22
	23	export interface Diagnosis {
	24	readonly class: RedClass;
	25	/** The first failing test, when the gate named one. */
	26	readonly test?: FailedTest;
	27	/** The line the class went on: the first error line, else the reason. */
	28	readonly probe: string;
	29	}
	30
	31	// Specific shapes only: a bare word like `extract` is as likely a function under test.
	32	const INFRA = /\b(ENOENT\|ENOSPC\|EMFILE\|ETIMEDOUT\|ECONNRESET)\b\|no space left\|disk quota\|(^\|\s)tar: /i;
	33	const PROBE_MAX = 300;
	34
	35	const clip = (s: string): string => (s.length > PROBE_MAX ? `${s.slice(0, PROBE_MAX - 1)}…` : s);
	36
	37	/** Class a red from its reason and the tests it named. */
	38	export function classify(reason: GateReason \| undefined, tests: GateTests \| undefined): Diagnosis {
	39	if (reason !== undefined && (reason.kind === "install" \|\| reason.kind === "setup" \|\| reason.kind === "timeout"))
	40	return { class: "infra", probe: reason.kind };
	41	const failing = tests?.failing ?? [];
	42	const first = failing[0];
	43	const probe = clip(first?.errors[0] ?? (reason?.kind ?? "check"));
	44	// No test named: nothing to hold it by, so it is the queue's to re-gate.
	45	if (first === undefined) return { class: "infra", probe };
	46	const errors = (t: FailedTest): string => t.errors.join("\n");
	47	if (failing.every((t) => t.errors[0]?.includes(BUDGET_MARK))) return { class: "budget", test: first, probe };
	48	if (failing.every((t) => INFRA.test(errors(t)))) return { class: "infra", test: first, probe };
	49	return { class: "functional", test: first, probe };
	50	}
	51
	52	const SAFE = /^[\w@./+-]{1,200}$/;
	53
	54	/** The command that reproduces a failing test, or undefined when its file is not a plain path. */
	55	export function reproduce(test: FailedTest \| undefined): string \| undefined {
	56	if (test?.file === undefined \|\| !SAFE.test(test.file)) return undefined;
	57	const path = test.file.startsWith("./") \|\| test.file.startsWith("/") ? test.file : `./${test.file}`;
	58	return `bun test ${path}`;
	59	}
		@@ -0,0 +1,1 @@
	1	e88ce9739bfc9660667668ab3ca760a26d48aa98064a8a4cb79908e44b5d9c77
		@@ -0,0 +1,13 @@
	1	// The batch doctor's acts (#7555) are `maintenance_run` rows (duty `batch-doctor`):
	2	// the repository and pull they concern, the batch, the culprit pull, how the red
	3	// was classed, what was done and the test output line it went on. Additive: columns only.
	4	export default `
	5	ALTER TABLE maintenance_run ADD COLUMN repo_id TEXT;
	6	ALTER TABLE maintenance_run ADD COLUMN issue_id TEXT;
		sentinelcrew 21h ago No cascade on these new columns: rows outlive their repository. Delete a repository's `batch-doctor` rows when the repository is deleted.
	7	ALTER TABLE maintenance_run ADD COLUMN batch TEXT NOT NULL DEFAULT '';
	8	ALTER TABLE maintenance_run ADD COLUMN culprit INTEGER;
	9	ALTER TABLE maintenance_run ADD COLUMN class TEXT NOT NULL DEFAULT '';
	10	ALTER TABLE maintenance_run ADD COLUMN action TEXT NOT NULL DEFAULT '';
	11	ALTER TABLE maintenance_run ADD COLUMN probe TEXT NOT NULL DEFAULT '';
	12	CREATE INDEX maintenance_run_repo ON maintenance_run (duty, repo_id, id);
	13	`;
		@@ -1050,6 +1050,8 @@ export async function deleteRepo(
1050	1050	// still reported.
1051	1051	const removed = await deleteRepoDir(dir);
1052	1052	if (!removed.ok && present) return err("delete_failed");
	1053	// The doctor's rows carry `repo_id` without a foreign key (added columns on `maintenance_run`).
	1054	db.query("DELETE FROM maintenance_run WHERE duty = 'batch-doctor' AND repo_id = ?1").run(repo.id);
1053	1055	db.query("DELETE FROM repo WHERE id = ?1").run(repo.id);
1054	1056	forgetRepoCursors(db, repo.id);
1055	1057	forgetListings(db);
		@@ -12,6 +12,7 @@
12	12	* repository's origin.
13	13	*/
14	14
	15	import { treatRed } from "../checks/doctor.ts";
15	16	import { tickBets } from "../actions/bets.ts";
16	17	import { betsInUse } from "../core/bets.ts";
17	18	import { onlyListDocs, resolveListConflicts } from "../actions/list-conflicts.ts";
		@@ -2196,6 +2197,8 @@ async function admit(
2196	2197	});
2197	2198	addLearned(app.config.dataDir, pull.id, red.learn);
2198	2199	if (!again) addComment(app, by, repo, getIssueById(app.db, pull.id) ?? pull, clashSaid(red.comment, together));
	2200	// A red that reproduces on the re-gate is the code's: only then is it the doctor's to hold.
	2201	if (again) treatRed(app, repo, by, pull, red, baseOid);
2199	2202	},
2200	2203	});
2201	2204	}
		@@ -1,9 +1,10 @@
	1	import { doctorRuns } from "../../../checks/doctor.ts";
1	2	import { recentGates } from "../../../checks/gate_result.ts";
2	3	import { good, bad, type Tool, REPO_ARG, repoArg, isAnswer } from "../shared.ts";
3	4
4	5	export const tool: Tool = {
5	6	name: "queue_gates",
6		doc: "`{ repo, limit? }`: the merge queue's recent gates, newest first (`limit` 1–100, default 20), as `GET …/queue/gates` answers: each gate's pulls, state, reason, counts and failing tests by name with their first error lines, a test red in two gates that share no pull flagged `flaky`",
	7	doc: "`{ repo, limit? }`: the merge queue's recent gates, newest first (`limit` 1–100, default 20), as `GET …/queue/gates` answers: each gate's pulls, state, reason, counts and failing tests by name with their first error lines, a test red in two gates that share no pull flagged `flaky`; `doctor`: the batch doctor's last acts on the repository (`culprit`, `class`, `action` held/recheck/kept, `probe`; a sealed pull's `culprit` is null and its `batch` and `probe` blank)",
7	8	description: "Recent merge-queue gates: pulls, verdicts, failing tests.",
8	9	inputSchema: {
9	10	type: "object",
		@@ -22,6 +23,6 @@ export const tool: Tool = {
22	23	return bad("invalid", "`limit` is a whole number from 1 to 100");
23	24	const gates = recentGates(ctx.app.db, repo.id, limit);
24	25	const red = gates.filter((g) => g.state === "red").length;
25		return good({ says: `${gates.length} gate(s), ${red} red.`, gates });
	26	return good({ says: `${gates.length} gate(s), ${red} red.`, gates, doctor: doctorRuns(ctx.app.db, repo.id, limit) });
26	27	},
27	28	};
		@@ -21,6 +21,7 @@
21	21	*/
22	22
23	23	import type { Database } from "bun:sqlite";
	24	import { doctorRuns, type DoctorRun } from "../../checks/doctor.ts";
24	25	import { recentGates, type KeptResult } from "../../checks/gate_result.ts";
25	26	import { reportLine } from "../../checks/report.ts";
26	27	import { HOLDS } from "../../crew/held.ts";
		@@ -133,6 +134,7 @@ export function flowLines(
133	134	return [
134	135	`${pad(truncate(q.repo, 15), 15)} ${pad(String(q.queued), 6, "right")} ${pad(String(q.gating), 6, "right")} ${pad(String(q.gates), 5, "right")} ${pad(String(q.landedHour), 9, "right")} ${pad(q.approvedToLanded === null ? "—" : String(q.approvedToLanded), 12, "right")}`,
135	136	...gateLines(id === undefined ? [] : recentGates(db, id, GATES_SHOWN), now.getTime(), inner),
	137	...doctorLines(id === undefined ? [] : doctorRuns(db, id, DOCTOR_SHOWN), now.getTime(), inner),
136	138	];
137	139	})),
138	140	...(red.length === 0
		@@ -216,6 +218,17 @@ export function gateLines(gates: readonly KeptResult[], now: number, inner: numb
216	218	});
217	219	}
218	220
	221	/** The doctor's acts shown under a repository's gates. */
	222	const DOCTOR_SHOWN = 3;
	223
	224	/** One indented line per batch-doctor act (#7555), newest first: `doctor #14 held · functional · how long ago · the error line`; none when it has not acted. */
	225	export function doctorLines(runs: readonly DoctorRun[], now: number, inner: number): string[] {
	226	return runs.map((r) => {
	227	const pull = r.sealed \|\| r.culprit === null ? "a sealed pull" : `#${r.culprit}`;
	228	return truncate(` doctor ${pull} ${r.action} · ${r.class} · ${ago(Date.parse(r.at), now)}${r.probe === "" ? "" : ` · ${r.probe}`}`, inner);
	229	});
	230	}
	231
219	232	/** Idle pulls shown before `+N more`. */
220	233	const IDLE_SHOWN = 5;
221	234
		@@ -0,0 +1,33 @@
	1	/**
	2	* The batch doctor's last acts (#7555), for the flow panel: the newest ten
	3	* across the repositories the reader may see, one row each with when, the
	4	* culprit pull, what the doctor did and how it classed the red. A sealed
	5	* pull is named only as `a sealed pull`, with no probe; one read
	6	* (`recentDoctorRuns`).
	7	*/
	8
	9	import type { Database } from "bun:sqlite";
	10	import { recentDoctorRuns, type DoctorRun } from "../../checks/doctor.ts";
	11	import { span } from "../../flow/pipeline.ts";
	12	import { html, type Html } from "../html.ts";
	13	import { badge, card, row } from "../ui.ts";
	14
	15	/** The most runs the card lists. */
	16	export const DOCTOR_LISTED = 10;
	17
	18	function runRow(repo: string, run: DoctorRun, now: number): Html {
	19	const tone = run.action === "held" ? "danger" : "default";
	20	return row({
	21	data: { doctor: run.action },
	22	title: html`${run.sealed \|\| run.culprit === null ? html`<span class="muted">a sealed pull</span>` : html`<a href="/${repo}/pulls/${String(run.culprit)}">#${String(run.culprit)}</a>`} ${badge(run.action, { tone })}`,
	23	meta: html`${span(Math.max(0, now - Date.parse(run.at)))} ago · ${repo} · ${run.class}`,
	24	...(run.probe === "" ? {} : { facts: [{ label: "error", value: html`<span class="break">${run.probe}</span>` }] }),
	25	});
	26	}
	27
		sentinelcrew 21h ago outdated Principle 1: say in one plain sentence what this card is for. Principle 7: the dotted meta line mixes repo, class and probe, so give the probe its own row.
	28	/** The "Batch doctor" card: nothing until the doctor has treated a red (an empty card is one more note on a page held to a count). */
	29	export function doctorCard(db: Database, owner: boolean, now: number): Html {
	30	const top = recentDoctorRuns(db, owner, DOCTOR_LISTED);
	31	if (top.length === 0) return html``;
	32	return card(html`<h2>Batch doctor</h2><p class="muted">When a merge gate finds a pull red on its own, the doctor names the failing test and holds the pull until it passes.</p><ul class="list">${top.map((l) => runRow(l.repo, l.run, now))}</ul>`, { id: "doctor" });
	33	}