@feigi/fleet-ctl 3.79.5 → 3.79.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feigi/fleet-ctl",
-  "version": "3.79.5",
+  "version": "3.79.6",
   "description": "Agent fleet: run-team controller, merge bot, PR reviewer, and the ticket pipeline they share",
   "license": "Apache-2.0",
   "repository": {

package/scripts/board-gather.mjs

@@ -34,7 +34,7 @@ import {
 import { readReceipt } from "./phase0-receipt.mjs";
 import { RECEIPT } from "./ledger-grammar.mjs";
 import { NAME, warnOnce, execRead } from "./board-common.mjs";
-import { mergedReadPrs } from "./compute-board.mjs";
+import { mergedReadPrs, issuesOfPrs } from "./compute-board.mjs";
 // The heartbeat's liveness mark and the controller record beside it, read here
 // and never written: the heartbeat is the mark's only writer and
 // `ledger.mjs rotate` the record's. stallOwner() reads the process table to
@@ -48,7 +48,7 @@ const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
 // The "is this a plain JSON object" predicate and its kind word, one
 // copy for the reads in this file that reject a parsed-but-wrong payload
 // WHOLE — gather's `--prev` payload, gather's per-entry `tickets[i]` check,
-// and readMerged()'s `data.repository`. Each carried its own inline
+// and readStates()'s `data.repository`. Each carried its own inline
 // copy of both halves before, which is three places for one policy to drift in.
 //
 // TWO functions and not one, because `typeof` alone cannot name the fault the
@@ -155,48 +155,60 @@ function hitLimit(parsed, limit) {
   return Array.isArray(parsed) && parsed.length >= limit;
 }
 
-// Which of `prNums` gh calls MERGED, in ONE `gh api graphql` query —
-// one aliased `pullRequest(number:)` field per PR, on the cwd's repository
-// (gh's own `{owner}`/`{repo}` placeholders, the repo every other read here
-// resolves) — so a PR merged at any age is found, and ten PRs cost what one
-// does. It replaced `gh pr list --state merged --limit 100`, the repo's 100
-// most recent merges: about six days on 2026-09-25, so a row PR merged
-// before that and never seen MERGED rendered REVIEW, turned stale and
-// counted as claimed. Measured 2026-09-26: 400 aliases answer in one call.
+// The merged and closed states of `prNums`, and the CLOSED-ness of `issueNums`,
+// in ONE `gh api graphql` query — one aliased `pullRequest(number:)` field per
+// PR and one `issue(number:)` field per issue, on the cwd's repository (gh's own
+// `{owner}`/`{repo}` placeholders, the repo every other read here resolves) — so
+// a PR merged at any age is found, and ten PRs cost what one does. It replaced
+// `gh pr list --state merged --limit 100`, the repo's 100 most recent merges: about
+// six days on 2026-09-25, so a row PR merged before that and never seen MERGED
+// rendered REVIEW, turned stale and counted as claimed. Measured 2026-09-26: 400
+// aliases answer in one call.
 //
-// An empty `prNums` makes no read at all. `state` is checked, so an entry gh
-// does not call MERGED never makes a card MERGED on its own account.
+// An empty `prNums` makes no read at all. `state` is checked per alias, so an
+// entry gh does not call MERGED is never merged, and one it does not call CLOSED
+// is never closed; an issue not CLOSED is not CLOSED.
 //
 // A body with an object `data.repository` IS an answer even at exit 1:
-// GitHub resolves every alias it can and nulls the rest — a number that is
-// not a PR comes back null beside a NOT_FOUND error, and gh exits 1 with the
-// whole body on stdout (measured 2026-09-26, gh 2.101.0, which also names
-// the number on stderr). Refusing that body would let one such row — a
-// typo, or a row with no impl token keyed by an issue number — put every other
-// row PR back in REVIEW on every tick. A null alias reads as not merged,
-// which is what a failed read means for that one PR.
+// GitHub resolves every alias it can and nulls the rest — a number that is not
+// a PR (or, for an issue alias, not an issue) comes back null beside a
+// NOT_FOUND error, and gh exits 1 with the whole body on stdout (measured
+// 2026-09-26, gh 2.101.0, which also names the number on stderr). Refusing that
+// body would let one such row — a typo, or a row with no impl token keyed by an
+// issue number — put every other row PR back in REVIEW on every tick. A null
+// alias reads as not merged and not closed, which is what a failed read means
+// for that one number.
 //
-// Real GitHub always answers EVERY requested `p<N>` alias, null or an
-// object — never omits one — so an object naming NONE of `prNums` is not a
-// shape the API produces, only a corrupted or truncated one; `isJsonObject`
-// alone cannot tell that apart from a genuine "checked, nothing merged"
-// answer, so it is checked for too. Anything else is a failed read: `[]`,
-// and computeBoard()'s carry-forward rule takes it from there.
-async function readMerged(prNums) {
-  if (!prNums.length) return [];
-  const fields = prNums.map((n) => `p${n}:pullRequest(number:${n}){state}`).join(" ");
+// Real GitHub always answers EVERY requested PR alias, null or an object — never
+// omits one — so an object naming NONE of the PR numbers is not a shape the API
+// produces, only a corrupted or truncated one; `isJsonObject` alone cannot tell
+// that apart from a genuine "checked, nothing matched" answer, so it is checked
+// for too. Anything else is a failed read: every list empty, and
+// computeBoard()'s carry-forward rule takes it from there.
+async function readStates(prNums, issueNums) {
+  const none = { merged: [], closed: [], closedIssues: [] };
+  if (!prNums.length) return none;
+  const fields = [
+    ...prNums.map((n) => `p${n}:pullRequest(number:${n}){state}`),
+    ...issueNums.map((n) => `i${n}:issue(number:${n}){state}`),
+  ].join(" ");
   const r = await execRead("gh", ["api", "graphql", "-F", "owner={owner}", "-F", "name={repo}",
     "-f", `query=query($owner:String!,$name:String!){repository(owner:$owner,name:$name){${fields}}}`]);
   let repo;
   try { repo = JSON.parse(r.stdout)?.data?.repository; } catch {}
   if (!isJsonObject(repo) || !prNums.some((n) => Object.prototype.hasOwnProperty.call(repo, `p${n}`))) {
     // `how` as runCiState() spells it; never r.error.message, which repeats
-    // the whole query — one field per PR — into every failed tick's line.
+    // the whole query — one field per number — into every failed tick's line.
     const how = r.code ?? (r.signal ? `killed by ${r.signal}` : `exit ${r.status}`);
-    console.error(`${NAME}: gh api graphql merged read (${prNums.length} PR${prNums.length === 1 ? "" : "s"}) failed (${how}) with no usable answer; they read as not merged`);
-    return [];
+    const n = prNums.length;
+    console.error(`${NAME}: gh api graphql merged read (${n} PR${n === 1 ? "" : "s"}) failed (${how}) with no usable answer`);
+    return none;
   }
-  return prNums.filter((n) => repo[`p${n}`]?.state === "MERGED");
+  return {
+    merged: prNums.filter((n) => repo[`p${n}`]?.state === "MERGED"),
+    closed: prNums.filter((n) => repo[`p${n}`]?.state === "CLOSED"),
+    closedIssues: issueNums.filter((n) => repo[`i${n}`]?.state === "CLOSED"),
+  };
 }
 
 // labels: gh emits an array of {name,...} objects, but a malformed row can
@@ -692,7 +704,7 @@ export async function gather({ ledgerFile, prevFile, stateFile = null, scriptDir
       // JSON.parse SUCCEEDS on `null`, a bare number, a string and an array,
       // none of which is a board; `null` in particular is absent, not an
       // object, and `typeof null` alone would let it through. Same check and
-      // same wording as readMerged()'s `data.repository` read, which is this
+      // same wording as readStates()'s `data.repository` read, which is this
       // repo's precedent for rejecting a parsed-but-wrong payload at its own
       // read — literally the same, both calling the shared predicate.
       const p = JSON.parse(readFileSync(prevFile, "utf8"));
@@ -711,7 +723,7 @@ export async function gather({ ledgerFile, prevFile, stateFile = null, scriptDir
         // (drop the bad entry, keep the rest) would make this a new, fourth policy for
         // one payload class in this file — mapCi's null-only guard and tryParse's
         // unguarded read are the other two — rather than the reject-whole-payload
-        // policy this guard already shares with readMerged()'s own read.
+        // policy this guard already shares with readStates()'s own read.
         const bad = p.tickets.findIndex((t) => !isJsonObject(t));
         if (bad !== -1)
           throw new TypeError(`expected tickets[${bad}] to be a JSON object, got ${jsonKind(p.tickets[bad])}`);
@@ -805,11 +817,13 @@ export async function gather({ ledgerFile, prevFile, stateFile = null, scriptDir
   // <sha>`, and the open list above drops a PR the moment it merges. It is
   // asked only about mergedReadPrs()'s set — row PRs absent from the open
   // list, with no token, not carried forward — in one batched read
-  // that answers whatever their merge age; see readMerged(). A failed read
-  // is `[]`, and the carry-forward in computeBoard() covers exactly the
-  // PRs this set leaves out, so a failure costs only a PR never yet seen
-  // MERGED, which reads REVIEW.
-  const merged = await readMerged(mergedReadPrs({ ledger, prs, prev }));
+  // that answers whatever their merge age; see readStates(). A failed read
+  // leaves every list empty, and the carry-forward in computeBoard() covers
+  // exactly the PRs this set leaves out, so a failure costs only a PR never
+  // yet seen MERGED, which reads REVIEW — and flags no pr-closed, since the
+  // closed lists are empty too.
+  const asked = mergedReadPrs({ ledger, prs, prev });
+  const { merged, closed, closedIssues } = await readStates(asked, issuesOfPrs({ ledger, prs: asked }));
 
   // CI per open PR. On failure, carry the previous board's value for that PR.
   const prevCi = new Map((prev?.tickets || []).filter((t) => t.pr != null).map((t) => [t.pr, t.ci]));
@@ -869,7 +883,7 @@ export async function gather({ ledgerFile, prevFile, stateFile = null, scriptDir
   // stalled, so a healthy board reads none. computeBoard() words it.
   const now = Date.now();
   const stallOwnerOf = isStalled(assessBeat({ beat, ticked, acted, controller, now })) ? stallOwner(controller, NAME) : null;
-  return { ledger, issues, prs, merged, ci, prev, repo, repoUrl, workspace, port, spend, beat, ticked, acted, controller, stallOwner: stallOwnerOf, poolOk,
+  return { ledger, issues, prs, merged, closed, closedIssues, ci, prev, repo, repoUrl, workspace, port, spend, beat, ticked, acted, controller, stallOwner: stallOwnerOf, poolOk,
     poolCapped, prsCapped,
     now, interval };
 }

package/scripts/compute-board.mjs

@@ -197,7 +197,8 @@ export function parseRow(row) {
   const alive = live.filter((e) => !settled.has(e.name));
   const implOutcome = lastImpl ? (implOutcomes.get(lastImpl.name) ?? null) : null;
   const prM = implOutcome && /^PR#(\d+)$/.exec(implOutcome);
-  let pr = prM ? Number(prM[1]) : null;
+  const implPr = prM ? Number(prM[1]) : null;
+  let pr = implPr;
   // A row with NO impl token — a malformed one still
   // counts, since that row's key is a ticket — is keyed, once THIS row
   // carries a PR-bound signal, the way fleet-tick.mjs's rowPr-then-
@@ -217,6 +218,7 @@ export function parseRow(row) {
     excluded,
     impl: lastImpl?.name ?? null,
     implOutcome,
+    implPr,
     agent: alive.length ? alive[alive.length - 1].name : null,
     pr,
     merged: !!mergedM,
@@ -287,8 +289,12 @@ export function deriveFlags(parsed, ctx) {
   if (ctx.finisher?.startsWith("halted:") && ctx.column === "REVIEW") flags.push(ctx.finisher);
   if (ctx.finisher === "labelled" && ctx.column === "REVIEW") flags.push("unlabelled");
   if ((ctx.finisher === "failed" || ctx.finisher === "killed") && ctx.column === "REVIEW") flags.push(`finisher:${ctx.finisher}`);
+  // A closed-unmerged PR's card reads `pr-closed` in place of `stale`: the
+  // closed PR is what a reader has to act on, not how long the card has sat.
+  const prClosed = ctx.prClosed === true && ctx.column === "REVIEW";
+  if (prClosed) flags.push("pr-closed");
   const limit = STALE_MS[ctx.column];
-  if (limit != null && ctx.sinceEnteredStage != null && ctx.now - ctx.sinceEnteredStage > limit) {
+  if (!prClosed && limit != null && ctx.sinceEnteredStage != null && ctx.now - ctx.sinceEnteredStage > limit) {
     flags.push("stale");
   }
   return flags;
@@ -315,7 +321,7 @@ function titleFor(issue, pr, issues) {
 }
 
 const FLAG_SEVERITY = {
-  "red-ci": 5, "ledger-error": 5, killed: 4, "tier-mismatch": 4, blocked: 4, "sha-off-branch": 4, unlabelled: 4,
+  "red-ci": 5, "ledger-error": 5, killed: 4, "tier-mismatch": 4, "pr-closed": 4, blocked: 4, "sha-off-branch": 4, unlabelled: 4,
   "finisher:failed": 4, "finisher:killed": 4,
   ...Object.fromEntries(HALT_CAUSES.map((c) => [`halted:${c}`, 4])),
   stale: 1,
@@ -432,6 +438,20 @@ export function mergedReadPrs({ ledger, prs, prev }) {
   return [...need].sort((a, b) => a - b);
 }
 
+// The ticket issues whose row's latest settled impl PR is one of `prs`, sorted
+// and once each. gather() reads their state in the same call as the PR read;
+// computeBoard() takes the CLOSED ones as `closedIssues`. An Exclusion is none.
+// An issue number outside Number.isSafeInteger is left out for the reason
+// mergedReadPrs() leaves such a PR out: its `i1e+21` alias would fail the
+// whole batched query, PR aliases included.
+export function issuesOfPrs({ ledger, prs }) {
+  const set = new Set(prs);
+  const issues = (ledger.rows || []).map(parseRow).filter(Boolean)
+    .filter((p) => !p.excluded && p.implPr != null && set.has(p.implPr) && Number.isSafeInteger(p.issue))
+    .map((p) => p.issue);
+  return [...new Set(issues)].sort((a, b) => a - b);
+}
+
 // `merged` is gh's list of merged PR numbers, consulted only for a row
 // PR absent from the open list `prs`; absent means none known, and a PR in
 // neither list (closed unmerged, or a failed read) keeps REVIEW — unless
@@ -441,10 +461,16 @@ export function mergedReadPrs({ ledger, prs, prev }) {
 // this carry-forward — only the "absent from both `prs` and (maybe)
 // `merged`" branch below ever consults it. gather() asks gh only about
 // mergedReadPrs()'s set, so `merged` never lists more than that.
+// `closed` is the same read's CLOSED PRs, and `closedIssues` the CLOSED issues
+// among issuesOfPrs(). A pr-closed flag needs both: a missing `closed`
+// flags nothing, and a failed issue read reads as not CLOSED, as closedTickets()
+// reads its own failed probe.
 export function computeBoard(inputs) {
   const { ledger, issues, prs, ci, prev, now } = inputs;
   const prByNum = new Map(prs.map((p) => [p.number, p]));
   const mergedPrs = new Set(inputs.merged || []);
+  const closedPrs = new Set(inputs.closed || []);
+  const closedIssues = new Set(inputs.closedIssues || []);
   const prevByIssue = new Map((prev?.tickets || []).map((t) => [t.issue, t]));
   const ruledByPr = new Map();
   for (const r of ledger.ruled || []) {
@@ -501,7 +527,8 @@ export function computeBoard(inputs) {
     rowIssues.add(p.issue);
     const sinceEnteredStage = stageEntry(prevTicket, column, now);
     const ciState = p.pr != null ? (ci[p.pr] ?? "unknown") : null;
-    const flags = deriveFlags(p, { ci: ciState, column, sinceEnteredStage, now, finisher: latestFinishers.get(p.pr) });
+    const prClosed = pr === undefined && p.implPr != null && closedPrs.has(p.pr) && !closedIssues.has(p.issue);
+    const flags = deriveFlags(p, { ci: ciState, column, sinceEnteredStage, now, finisher: latestFinishers.get(p.pr), prClosed });
     tickets.push({
       issue: p.issue,
       title: titleFor(p.issue, pr, issues),