@feigi/fleet-ctl 3.83.0 → 3.83.1

package/package.json

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

package/scripts/fleet-tick.mjs

@@ -54,13 +54,13 @@
 //             whatever its state. Also, for each in-flight `review=` token
 //             whose PR the open list does not carry, and for each ticket's
 //             latest settled `impl-*=PR#<M>` PR the open list does not carry,
-//             that PR's state (`gh pr view`, once per PR): a review cannot
-//             be running against a finished PR, so its dangling token is not
-//             a review unit, and a PR CLOSED unmerged prints an ESCALATE line
-//             for its ticket. And, for each ticket holding the implementer
-//             row on a tier mismatch, owed a replacement, or whose keyed PR
-//             read CLOSED or unread, whether its issue is CLOSED (`gh issue
-//             view`): a closed ticket's mismatch holds nothing, its owed
+//             that PR's state (one `gh api graphql` read per hundred PRs): a
+//             review cannot be running against a finished PR, so its dangling
+//             token is not a review unit, and a PR CLOSED unmerged prints an
+//             ESCALATE line for its ticket. And, for each ticket holding the
+//             implementer row on a tier mismatch, owed a replacement, or whose
+//             keyed PR read CLOSED or unread, whether its issue is CLOSED (`gh
+//             issue view`): a closed ticket's mismatch holds nothing, its owed
 //             replacement is not in flight, and its PR prints no line.
 //   main      The main checkout against the run-start baseline
 //             `.fleet/main-checkout.sha`, through main-checkout.mjs.
@@ -958,7 +958,7 @@ export function foldLedger({ rows, dispatched }, open, { lenient = false } = {})
 export const pastPinDue = (st, head) => st !== undefined && st.pastPinHalt && !st.inFlight && st.reviewedHead !== null
   && !String(head).toLowerCase().startsWith(st.reviewedHead);
 
-// The states `gh pr view --json state` answers: anything else is no answer.
+// The states a PR-state probe answers: anything else is no answer.
 const PR_STATES = ["OPEN", "MERGED", "CLOSED"];
 
 export function deriveRun({ rows, dispatched, drain, retired = [] }, prs, closed = new Set(), prStates = new Map()) {
@@ -1007,7 +1007,7 @@ export function deriveRun({ rows, dispatched, drain, retired = [] }, prs, closed
   // A mismatch on the keyed member itself is no replacement of M and still
   // prints. A keyed PR the open list carries is normal flow; one it does not
   // is named in `prKeyed` for the caller's state probe, `prStates` its
-  // answers (null for a probe that could not answer, none by default).
+  // answers (none for a PR whose probe could not answer, as by default).
   // CLOSED escalates, an unanswered probe escalates as unchecked, OPEN and
   // MERGED say nothing, and a ticket whose issue the caller found CLOSED
   // (`closed`) says nothing either way.
@@ -1493,6 +1493,7 @@ import { isCLI } from "./is-cli.mjs";
 import { parseArgs } from "node:util";
 import { makeDie, isDigits } from "./arg.mjs";
 import { gitEnv } from "./git-env.mjs";
+import { ghAliasedRead } from "./gh-aliased-read.mjs";
 import { fleetFile, FleetDirUnresolvable, scratchRoot } from "./fleet-dir.mjs";
 import { statePath, readState, writeState, assessBeat, isStalled, isReported, stallReport, stallOwner } from "./fleet-state.mjs";
 import { checkMainCheckout, describe } from "./main-checkout.mjs";
@@ -1815,34 +1816,36 @@ function closedTickets(mismatched, owed, surfacing) {
   return closed;
 }
 
-// The state of each PR the tick asks gh about, one `gh pr view --json state`
-// per PR however many readings need it: `reviews`, the PRs whose review the
-// ledger reads as in flight yet the open list does not carry, and `keyed`,
-// each ticket's keyed PR the open list does not carry (deriveRun's
-// `prKeyed`). The answer is OPEN, MERGED or CLOSED, or null for a probe that
-// could not answer — a nonzero exit, a reply carrying no state, a state that
-// is none of the three — which is disclosed with what it leaves standing.
+// The state of each PR the tick asks gh about, one aliased `gh api graphql`
+// read per hundred PRs however many readings need them: `reviews`, the PRs
+// whose review the ledger reads as in flight yet the open list does not carry,
+// and `keyed`, each ticket's keyed PR the open list does not carry (deriveRun's
+// `prKeyed`). The answer is OPEN, MERGED or CLOSED. A probe that could not
+// answer — a failed call, an alias GitHub errored on or answered with nothing,
+// a node carrying no state, a state that is none of the three — leaves its PR
+// out of the map and is disclosed, per PR, with what it leaves standing; a
+// call killed at GH_TIMEOUT_MS is disclosed with that bound.
 function prStates(reviews, keyed) {
   const states = new Map();
   const reviewed = new Set(reviews);
   // Two tickets can be keyed on one PR: each is named, on its one probe.
   const ticketsOf = new Map();
   for (const k of keyed) ticketsOf.set(k.pr, [...(ticketsOf.get(k.pr) ?? []), k.n]);
-  for (const number of [...new Set([...reviews, ...ticketsOf.keys()])].sort((a, b) => a - b)) {
+  const numbers = [...new Set([...reviews, ...ticketsOf.keys()])].sort((a, b) => a - b);
+  const read = ghAliasedRead(numbers, { field: "pullRequest", selection: "{state}", timeoutMs: GH_TIMEOUT_MS });
+  for (const number of numbers) {
+    const r = read.get(number);
+    const st = r.node?.state;
+    if (PR_STATES.includes(st)) {
+      states.set(number, st);
+      continue;
+    }
     const unconfirmed = [
       ...(reviewed.has(number) ? [`review on PR#${number} unconfirmed finished, its unit stands`] : []),
       ...(ticketsOf.get(number) ?? []).map((n) => `#${n}'s PR#${number} unconfirmed closed, printed as pr-unchecked`),
     ].join("; ");
-    states.set(number, null);
-    const r = spawnSync("gh", ["pr", "view", String(number), "--json", "state"], { encoding: "utf8", timeout: GH_TIMEOUT_MS, env: gitEnv({ GH_REPO: "" }) });
-    if (r.error || r.status !== 0) {
-      console.error(`${NAME}: ${failure(r, `gh pr view ${number}`)} — ${unconfirmed}`);
-      continue;
-    }
-    let st = null;
-    try { st = JSON.parse(r.stdout).state; } catch { /* no state: disclosed below */ }
-    if (PR_STATES.includes(st)) states.set(number, st);
-    else console.error(`${NAME}: gh pr view ${number} printed no PR state — ${unconfirmed}`);
+    const why = r.unreachable === "ETIMEDOUT" ? TIMED_OUT : r.unreachable ?? (r.notFound ? "no such pull request" : "no PR state");
+    console.error(`${NAME}: gh api graphql gave no answer for PR#${number} (${why}) — ${unconfirmed}`);
   }
   return states;
 }

package/scripts/gh-aliased-read.mjs

@@ -0,0 +1,95 @@
+// One GraphQL read of the current repository for many numbers at once: each
+// number is an aliased `<field>(number:N){…}` of the one query, a hundred to a
+// call, so a caller that would ask `gh` about every number one `gh … view` at a
+// time asks once per hundred instead. The caller names the field
+// (`pullRequest`, `issueOrPullRequest`) and what to select on it; what an
+// answer means is the caller's.
+//
+// `gh api graphql` exits 1 when any one alias errors yet still prints the full
+// body, `data.repository` holding every alias GitHub answered and `errors[]`
+// naming each failed one by `path: ["repository", "<alias>"]`. So a body that
+// carries an object `data.repository` is read alias by alias at any exit
+// status, never as "the whole call failed".
+//
+// `-F owner={owner} -F name={repo}` is filled in from the environment gh sees:
+// an inherited GH_REPO outranks the repository the cwd is bound to, and a
+// GIT_DIR naming another repository moves it too. gitEnv({ GH_REPO: "" })
+// scrubs both, so the read is of the repository the cwd is in.
+
+import { spawnSync } from "node:child_process";
+import { gitEnv } from "./git-env.mjs";
+
+const BATCH = 100;
+const MAX_BUFFER = 64 * 1024 * 1024;
+
+/** A child that did not answer, as one short reason. */
+export function how(r) {
+  if (r.error) return r.error.code ?? r.error.message;
+  if (r.signal) return `killed by ${r.signal}`;
+  const said = String(r.stderr ?? "").trim().split("\n").at(-1);
+  return said ? `exit ${r.status}: ${said}` : `exit ${r.status}`;
+}
+
+/**
+ * What GitHub says of each of `numbers`, as a Map keyed by number:
+ *
+ *   `{ node }`         — the alias GitHub answered with an object, as parsed.
+ *   `{ notFound }`     — null with a NOT_FOUND error naming the alias at path
+ *                        length 2: GitHub's own "this number names nothing".
+ *   `{ unreachable }`  — no usable answer, with the reason. Any other error
+ *                        naming an alias, an error naming no alias (it may
+ *                        belong to any of the batch), a null no NOT_FOUND
+ *                        explains, a missing alias, and an unparseable or
+ *                        absent body all land here: a failed lookup is not an
+ *                        answer.
+ *
+ * `field` and `selection` build each alias, `n<N>:<field>(number:<N>)<selection>`;
+ * `timeoutMs` bounds each `gh` call.
+ */
+export function ghAliasedRead(numbers, { field, selection, timeoutMs }) {
+  const out = new Map();
+  for (let i = 0; i < numbers.length; i += BATCH) {
+    const batch = numbers.slice(i, i + BATCH);
+    const fields = batch.map((n) => `n${n}:${field}(number:${n})${selection}`).join(" ");
+    const r = spawnSync("gh", ["api", "graphql", "-F", "owner={owner}", "-F", "name={repo}",
+      "-f", `query=query($owner:String!,$name:String!){repository(owner:$owner,name:$name){${fields}}}`], {
+      encoding: "utf8", maxBuffer: MAX_BUFFER, timeout: timeoutMs, env: gitEnv({ GH_REPO: "" }),
+    });
+    let body;
+    let unparseable;
+    try {
+      body = JSON.parse(r.stdout);
+    } catch (e) {
+      if (r.status === 0) unparseable = e.message;
+    }
+    const repo = body?.data?.repository;
+    const errors = body?.errors ?? [];
+    const answered = repo !== null && typeof repo === "object" && !Array.isArray(repo) && Array.isArray(errors);
+    const nothing = new Set();
+    const refused = new Map();
+    let batchWide;
+    if (answered) {
+      for (const e of errors) {
+        const path = e?.path;
+        const alias = Array.isArray(path) && path[0] === "repository" && typeof path[1] === "string" ? path[1] : null;
+        const said = `${e?.type ?? "error"}${e?.message ? `: ${e.message}` : ""}`;
+        if (alias === null) batchWide ??= said;
+        else if (e.type === "NOT_FOUND" && path.length === 2) nothing.add(alias);
+        else refused.set(alias, said);
+      }
+    }
+    for (const n of batch) {
+      const alias = `n${n}`;
+      const gone = (why) => out.set(n, { unreachable: why });
+      if (!answered) gone(unparseable === undefined ? how(r) : `${how(r)}: unparseable body: ${unparseable}`);
+      else if (refused.has(alias)) gone(refused.get(alias));
+      else if (batchWide !== undefined) gone(batchWide);
+      else if (!Object.hasOwn(repo, alias)) gone(how(r));
+      else if (repo[alias] === null) {
+        if (nothing.has(alias)) out.set(n, { notFound: true });
+        else gone("null with no NOT_FOUND error");
+      } else out.set(n, { node: repo[alias] });
+    }
+  }
+  return out;
+}

package/scripts/reclaim-scratch.mjs

@@ -109,6 +109,7 @@ import { fileURLToPath } from "node:url";
 import { defineFlags, isDigits, makeDie, writeAll } from "./arg.mjs";
 import { fleetFile, FleetDirUnresolvable, SCRATCH_KEY_SHAPE, scratchRoot } from "./fleet-dir.mjs";
 import { gitEnv } from "./git-env.mjs";
+import { ghAliasedRead, how } from "./gh-aliased-read.mjs";
 import { isCLI } from "./is-cli.mjs";
 import { liveOnLedger, parseMember, REVIEWER } from "./ledger-grammar.mjs";
 
@@ -116,7 +117,6 @@ const NAME = "reclaim-scratch";
 const die = makeDie(NAME);
 const DAY_MS = 24 * 60 * 60 * 1000;
 export const RETENTION_MS = 7 * DAY_MS;
-const BATCH = 100;
 const GH_TIMEOUT_MS = 30_000;
 const MAX_BUFFER = 64 * 1024 * 1024;
 
@@ -151,13 +151,6 @@ const REPORT_PR_ENTRY = /^(?:fix-pr|finisher-pr|review-pr)-([1-9][0-9]*)(?:-[a-z
 const REPORT_IMPL_ENTRY = /^impl-([1-9][0-9]*)(?:-[a-z])?(?:\.check)?\.json$/;
 const RUN_ROOT = /^run-/;
 
-function how(r) {
-  if (r.error) return r.error.code ?? r.error.message;
-  if (r.signal) return `killed by ${r.signal}`;
-  const said = String(r.stderr ?? "").trim().split("\n").at(-1);
-  return said ? `exit ${r.status}: ${said}` : `exit ${r.status}`;
-}
-
 /** The path of something under `path` (itself included) modified at or after
  * `cutoff`, or null when everything is older. Symlinks are not followed. A
  * directory that cannot be listed counts its own mtime only, and so does one
@@ -302,59 +295,18 @@ function claimWorktree(listing, n) {
 
 // `{type, state}` per number GitHub answered (type "Issue" or "PullRequest",
 // or null for a number that names nothing), or `{unreachable}` for a number
-// that has no usable answer. GitHub resolves every alias it can and nulls the
-// rest, and gh exits 1 with the whole body, so a body carrying an object
-// `data.repository` is read alias by alias at any exit status. An alias is
-// answered by a node, or by null with a NOT_FOUND error naming it — GitHub's
-// own "this number names nothing". Any other error naming an alias, a null
-// no NOT_FOUND explains, and an error naming no alias (it may belong to any
-// of the batch) leave the number unreachable: a failed lookup is not an
-// answer.
+// that has no usable answer. What counts as an answer is gh-aliased-read.mjs's:
+// a number GitHub nulls with NOT_FOUND names nothing, and a failed lookup is
+// not an answer.
 function githubStates(numbers) {
   const out = new Map();
-  for (let i = 0; i < numbers.length; i += BATCH) {
-    const batch = numbers.slice(i, i + BATCH);
-    const fields = batch.map((n) => `n${n}:issueOrPullRequest(number:${n}){__typename ... on Issue{state} ... on PullRequest{state}}`).join(" ");
-    const r = spawnSync("gh", ["api", "graphql", "-F", "owner={owner}", "-F", "name={repo}",
-      "-f", `query=query($owner:String!,$name:String!){repository(owner:$owner,name:$name){${fields}}}`], {
-      encoding: "utf8", maxBuffer: MAX_BUFFER, timeout: GH_TIMEOUT_MS, env: gitEnv({ GH_REPO: "" }),
-    });
-    let body;
-    let unparseable;
-    try {
-      body = JSON.parse(r.stdout);
-    } catch (e) {
-      body = undefined;
-      if (r.status === 0) unparseable = e.message;
-    }
-    const repo = body?.data?.repository;
-    const errors = body?.errors ?? [];
-    const answered = repo !== null && typeof repo === "object" && !Array.isArray(repo) && Array.isArray(errors);
-    const nothing = new Set();
-    const refused = new Map();
-    let batchWide;
-    if (answered) {
-      for (const e of errors) {
-        const path = e?.path;
-        const alias = Array.isArray(path) && path[0] === "repository" && typeof path[1] === "string" ? path[1] : null;
-        const said = `${e?.type ?? "error"}${e?.message ? `: ${e.message}` : ""}`;
-        if (alias === null) batchWide ??= said;
-        else if (e.type === "NOT_FOUND" && path.length === 2) nothing.add(alias);
-        else refused.set(alias, said);
-      }
-    }
-    for (const n of batch) {
-      const alias = `n${n}`;
-      const gone = (why) => out.set(n, { unreachable: `gh api graphql gave no answer for #${n} (${why})` });
-      if (!answered) gone(unparseable === undefined ? how(r) : `${how(r)}: unparseable body: ${unparseable}`);
-      else if (refused.has(alias)) gone(refused.get(alias));
-      else if (batchWide !== undefined) gone(batchWide);
-      else if (!Object.hasOwn(repo, alias)) gone(how(r));
-      else if (repo[alias] === null) {
-        if (nothing.has(alias)) out.set(n, { type: null });
-        else gone("null with no NOT_FOUND error");
-      } else out.set(n, { type: repo[alias].__typename, state: String(repo[alias].state).toUpperCase() });
-    }
+  const read = ghAliasedRead(numbers, {
+    field: "issueOrPullRequest", selection: "{__typename ... on Issue{state} ... on PullRequest{state}}", timeoutMs: GH_TIMEOUT_MS,
+  });
+  for (const [n, r] of read) {
+    if (r.unreachable !== undefined) out.set(n, { unreachable: `gh api graphql gave no answer for #${n} (${r.unreachable})` });
+    else if (r.notFound) out.set(n, { type: null });
+    else out.set(n, { type: r.node.__typename, state: String(r.node.state).toUpperCase() });
   }
   return out;
 }

package/skills/run-team/references/tick-rows.md

@@ -95,8 +95,8 @@ The full text of each row `fleet-tick.mjs` prints and what it asks of the contro
   carried on at the right tier — and once that one settles, the line reads it
   the same way. A tier mismatch on the member that settled `PR#<M>` itself
   replaces nothing, so the line stands beside that hold.
-- `ESCALATE pr-unchecked #<N> PR#<M>` — the same ticket, but `gh pr view
-  <M>` could not answer, so whether M closed is unknown. The maintainer's on
+- `ESCALATE pr-unchecked #<N> PR#<M>` — the same ticket, but gh could not
+  answer for PR M, so whether M closed is unknown. The maintainer's on
   the same terms as `pr-closed`; the next tick probes again.
 - `HOLD (…)` — the row is held and says why: draining, a tier mismatch, an
   unchecked tier, the In-flight bound reached (`HOLD (in-flight <n>/<B>)` —