@feigi/fleet-ctl 3.93.0 → 3.93.2

package/package.json

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

package/scripts/closing-refs.mjs

@@ -0,0 +1,37 @@
+// Which of a PR's closingIssuesReferences are in the PR's own repository.
+// GitHub lists a reference into another repository there too, under that
+// repository's issue number; read by number alone it stands in for this
+// repository's issue of the same number. Every reader of the field counts a
+// reference through this one rule.
+//
+// The PR's own repository is its url less `/pull/<pr>`; a url not ending so
+// cannot be read. A reference is in it when its url is that repository's
+// `/issues/<number>`, or, carrying no url, when its repository's
+// `<owner>/<name>` ends that repository's url. A reference with no integer
+// number, or with neither a url nor a repository to place it by, cannot be
+// read: it is never taken for the PR's own repository's.
+
+// The unique issue numbers, in GitHub's order, of the references in `refs`
+// that are in PR `pr`'s own repository, its url being `prUrl`. Throws an Error
+// whose message names what could not be read, phrased to follow the read's
+// own "answered": `url <prUrl>, not PR #<pr>'s`, `a reference with no issue
+// number`, `a reference to #<n> with neither a url nor a repository`.
+export function ownClosingIssues(pr, prUrl, refs) {
+  if (!Array.isArray(refs)) throw new Error("no closingIssuesReferences array");
+  const suffix = `/pull/${pr}`;
+  if (typeof prUrl !== "string" || !prUrl.endsWith(suffix)) throw new Error(`url ${prUrl}, not PR #${pr}'s`);
+  const own = prUrl.slice(0, -suffix.length);
+  const str = (v) => typeof v === "string" && v !== "";
+  const numbers = new Set();
+  for (const ref of refs) {
+    const n = ref?.number;
+    if (!Number.isInteger(n)) throw new Error("a reference with no issue number");
+    const repo = ref.repository;
+    let isOwn;
+    if (str(ref.url)) isOwn = ref.url === `${own}/issues/${n}`;
+    else if (str(repo?.name) && str(repo?.owner?.login)) isOwn = own.endsWith(`/${repo.owner.login}/${repo.name}`);
+    else throw new Error(`a reference to #${n} with neither a url nor a repository`);
+    if (isOwn) numbers.add(n);
+  }
+  return [...numbers];
+}

package/scripts/drop-merged-label.sh

@@ -19,6 +19,11 @@
 # both signals (see the commit-message scan below) so a real close is never
 # missed just because the keyword only ever lived in a commit message.
 #
+# Only a closing reference in the PR's own repository counts: the field also
+# lists another repository's issue, under that repository's number, and read
+# by number alone it would drop the label from this repository's issue of the
+# same number.
+#
 # Dry-run by default; --apply mutates the tracker. Exit 0 done (or dry run),
 # 1 one or more removals failed — REPORT THIS, never swallow it: a merged
 # ticket that keeps the label is a future invisible ticket, 2 could not even
@@ -47,9 +52,24 @@ if ! state=$(gh pr view "$pr" --json state --jq .state); then
 fi
 [ "$state" = "MERGED" ] || die "PR #$pr is not merged (state=$state) — refusing to touch its issues"
 
-echo "\$ gh pr view $pr --json closingIssuesReferences --jq '.closingIssuesReferences[].number'" >&2
-if ! issues=$(gh pr view "$pr" --json closingIssuesReferences --jq '.closingIssuesReferences[].number'); then
-  die "gh pr view $pr failed — cannot read which issues it closes"
+# The PR's own repository is its url less `/pull/<pr>`. A reference is in it
+# when its url is that repository's `/issues/<number>`, or, carrying no url,
+# when its repository's `<owner>/<name>` ends that repository's url; any other
+# is dropped here and never reaches the loop below. A url not ending
+# `/pull/<pr>`, a reference with no integer number, or one with neither a url
+# nor a repository to place it by cannot be read: the filter errors, gh exits
+# non-zero, and so does this, 2.
+own_closes='(.url | if type == "string" and endswith("/pull/'"$pr"'") then rtrimstr("/pull/'"$pr"'") else error("url \(tostring) does not end /pull/'"$pr"'") end) as $own
+  | .closingIssuesReferences | if type == "array" then .[] else error("no closingIssuesReferences array") end
+  | .number as $n | .repository as $r
+  | if ($n | type) == "number" and ($n | floor) == $n then . else error("a reference with no issue number") end
+  | if (.url | type) == "string" and .url != "" then select(.url == "\($own)/issues/\($n)")
+    elif ($r.name | type) == "string" and $r.name != "" and ($r.owner.login | type) == "string" and $r.owner.login != "" then select($own | endswith("/\($r.owner.login)/\($r.name)"))
+    else error("a reference to #\($n) with neither a url nor a repository") end
+  | $n'
+echo "\$ gh pr view $pr --json closingIssuesReferences,url --jq '$own_closes'" >&2
+if ! issues=$(gh pr view "$pr" --json closingIssuesReferences,url --jq "$own_closes"); then
+  die "gh pr view $pr failed — cannot read which issues it closes in its own repository"
 fi
 
 # The query above misses a commit-message-only close. Scan every

package/scripts/fleet-tick.mjs

@@ -1566,6 +1566,7 @@ import { checkMainCheckout, describe } from "./main-checkout.mjs";
 import { readRunReceipt, phase0Gate, IN_FLIGHT_DEFAULT } from "./phase0-receipt.mjs";
 import { judgeRecord, ProcUnreadable } from "./proc.mjs";
 import { reportFamily, readReport, reportPath, reportsDir } from "./report-files.mjs";
+import { ownClosingIssues } from "./closing-refs.mjs";
 
 const NAME = "fleet-tick";
 const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
@@ -1681,14 +1682,18 @@ function options() {
   };
 }
 
-// The open PRs, validated. A failed read is not an empty pipeline: backlog 0 +
-// merge-queue 0 is a plausible tick, so printing it off a failed query is the
-// silent stall this script exists to end.
+// The open PRs, validated, each with its closingIssuesReferences reduced to
+// `{number}` for every issue it closes in its own repository, by
+// ownClosingIssues()'s rule: another repository's reference, whatever its
+// number, closes none of this repository's tickets. A failed read is not an
+// empty pipeline: backlog 0 + merge-queue 0 is a plausible tick, so printing
+// it off a failed query is the silent stall this script exists to end.
+const PR_ROW_SHAPE = "{number,labels,closingIssuesReferences[{number,url|repository{name,owner{login}}}],headRefOid,mergeable,body,url} rows, url ending /pull/<number>, mergeable one of MERGEABLE, CONFLICTING, UNKNOWN";
 function openPrs() {
   let out;
   try {
     out = execFileSync("gh", ["pr", "list", "--state", "open", "--limit", String(PR_LIMIT),
-      "--json", "number,labels,closingIssuesReferences,headRefOid,mergeable,body"], { encoding: "utf8", maxBuffer: MAX_BUFFER, timeout: GH_TIMEOUT_MS });
+      "--json", "number,labels,closingIssuesReferences,headRefOid,mergeable,body,url"], { encoding: "utf8", maxBuffer: MAX_BUFFER, timeout: GH_TIMEOUT_MS });
   } catch (e) {
     // Never interpolates e.stderr or e.message: execFileSync already forwarded
     // the child's stderr to ours, and Node builds e.message out of it, so
@@ -1703,22 +1708,31 @@ function openPrs() {
   }
   // closingIssuesReferences is checked, not defaulted: absent, it would read as
   // an empty list and drop every open PR from review work — and from the
-  // In-flight count. Each reference must carry an integer `number`: the count
-  // matches a PR to the ticket it closes by it, and a reference without one
-  // would leave that ticket's implementer counted twice. headRefOid likewise
-  // — absent, a `halted:past-pin` PR would read as moved forever — and
-  // mergeable: absent or outside GitHub's MergeableState enum, no PR would ever
-  // read CONFLICTING. body too: absent, no park could ever be matched or lifted.
+  // In-flight count. Each reference must be readable by ownClosingIssues():
+  // the count matches a PR to the ticket it closes by its number, and a
+  // reference that cannot be placed would leave that ticket's implementer
+  // counted twice, or count another repository's issue as this one's. url is
+  // required too: the PR's own repository, which that rule places each
+  // reference against, is its url less /pull/<number>.
+  // headRefOid likewise — absent, a `halted:past-pin` PR would read as moved
+  // forever — and mergeable: absent or outside GitHub's MergeableState enum,
+  // no PR would ever read CONFLICTING. body too: absent, no park could ever be
+  // matched or lifted.
   if (!Array.isArray(prs) || prs.some((p) => !p || typeof p.number !== "number"
-    || !Array.isArray(p.labels) || !Array.isArray(p.closingIssuesReferences)
-    || !p.closingIssuesReferences.every((r) => r && Number.isInteger(r.number))
+    || !Array.isArray(p.labels) || !Array.isArray(p.closingIssuesReferences) || typeof p.url !== "string"
     || typeof p.headRefOid !== "string" || !MERGEABLE_STATES.includes(p.mergeable) || typeof p.body !== "string")) {
-    die("gh pr list did not return {number,labels,closingIssuesReferences[{number}],headRefOid,mergeable,body} rows, mergeable one of MERGEABLE, CONFLICTING, UNKNOWN");
+    die(`gh pr list did not return ${PR_ROW_SHAPE}`);
   }
   if (prs.length === PR_LIMIT) {
     die(`exactly ${PR_LIMIT} open PRs — the list is capped and may be truncated. Raise PR_LIMIT; a backlog that silently drops PRs is not a reconcile.`);
   }
-  return prs;
+  return prs.map((p) => {
+    try {
+      return { ...p, closingIssuesReferences: ownClosingIssues(p.number, p.url, p.closingIssuesReferences).map((number) => ({ number })) };
+    } catch (e) {
+      die(`gh pr list did not return ${PR_ROW_SHAPE}: PR #${p.number} answered ${e.message}`);
+    }
+  });
 }
 
 // A child that did not exit 0, named with the last line it printed. A gh

package/scripts/ledger.mjs

@@ -63,6 +63,7 @@ import { processSource, ancestry, controllerOf, judgeController, ProcUnreadable
 import { attemptLock, releaseLockFile, reapPathOf } from "./pid-lock.mjs";
 import { readCheckRecordIn, readReportIn, reportsDir, reportFamily, defaultScratch, reportPath } from "./report-files.mjs";
 import { mergeBotVerdicts } from "./report-schema.mjs";
+import { ownClosingIssues } from "./closing-refs.mjs";
 
 const NAME = "ledger";
 // The plugin's own agent definitions — the directory tier-check.mjs reads
@@ -2000,31 +2001,15 @@ function checkReaders(where) {
   };
   // PR `pr`'s prView() answer to `fields`, which name closingIssuesReferences
   // and url, as `view`, with the issue numbers, unique, of its closing
-  // references that are in the PR's own repository: its url less
-  // `/pull/<pr>`. A reference is in it when its url is that repository's
-  // `/issues/<number>`, or, carrying no url, when its repository's
-  // `<owner>/<name>` ends that repository's url. A reference with no integer
-  // number, or with neither a url nor a repository to place it by, could not
-  // look: it is never taken for the PR's own repository's.
+  // references that are in the PR's own repository, by ownClosingIssues()'s
+  // rule. A reference that rule cannot read could not look.
   const prViewClosing = (pr, fields) => {
     const view = prView(pr, fields);
-    const what = `gh pr view ${pr} --json ${fields}`;
-    const suffix = `/pull/${pr}`;
-    if (!view.url.endsWith(suffix)) die(`${where}: could not look — ${what} answered url ${view.url}, not PR #${pr}'s; nothing written`);
-    const own = view.url.slice(0, -suffix.length);
-    const str = (v) => typeof v === "string" && v !== "";
-    const numbers = new Set();
-    for (const ref of view.closingIssuesReferences) {
-      const n = ref?.number;
-      if (!Number.isInteger(n)) die(`${where}: could not look — ${what} answered a reference with no issue number; nothing written`);
-      const repo = ref.repository;
-      let isOwn;
-      if (str(ref.url)) isOwn = ref.url === `${own}/issues/${n}`;
-      else if (str(repo?.name) && str(repo?.owner?.login)) isOwn = own.endsWith(`/${repo.owner.login}/${repo.name}`);
-      else die(`${where}: could not look — ${what} answered a reference to #${n} with neither a url nor a repository; nothing written`);
-      if (isOwn) numbers.add(n);
+    try {
+      return { view, numbers: ownClosingIssues(pr, view.url, view.closingIssuesReferences) };
+    } catch (e) {
+      die(`${where}: could not look — gh pr view ${pr} --json ${fields} answered ${e.message}; nothing written`);
     }
-    return { view, numbers: [...numbers] };
   };
   // The title of issue `n`, as `gh issue view <n> --json title` answers it.
   const issueTitle = (n) => {

package/scripts/phase0.mjs

@@ -141,6 +141,7 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { makeDie, defineFlags, isDigits } from "./arg.mjs";
 import { alarmFile } from "./controller-alarm.mjs";
+import { ownClosingIssues } from "./closing-refs.mjs";
 import { FleetDirUnresolvable, fleetFile } from "./fleet-dir.mjs";
 import { readState, stateFileIn } from "./fleet-state.mjs";
 import { gitEnv } from "./git-env.mjs";
@@ -352,7 +353,7 @@ function ledgerRows(cwd) {
 const rowKey = (row) => row.split(/\s/)[0];
 
 function foldIn({ cwd }) {
-  const list = run("gh", ["pr", "list", "--state", "open", "--json", "number,closingIssuesReferences", "--limit", String(PR_LIMIT)], {
+  const list = run("gh", ["pr", "list", "--state", "open", "--json", "number,closingIssuesReferences,url", "--limit", String(PR_LIMIT)], {
     cwd, env: { GH_REPO: "" }, timeoutMs: NETWORK_TIMEOUT_MS,
   });
   if (list.status !== 0) return refusal("gh pr list failed:", list);
@@ -364,6 +365,18 @@ function foldIn({ cwd }) {
   }
   if (!Array.isArray(prs)) return failed("gh pr list did not print a JSON array");
   if (prs.length >= PR_LIMIT) return failed(`gh pr list came back at its cap of ${PR_LIMIT} — it may hold more PRs than it showed, so none is folded in`);
+  // The issues each PR closes in its own repository, by ownClosingIssues()'s
+  // rule — another repository's reference closes none of this one's — read
+  // for every PR before any row is written, so one that cannot be read folds
+  // nothing in.
+  const closing = new Map();
+  for (const pr of prs) {
+    try {
+      closing.set(pr, ownClosingIssues(pr?.number, pr?.url, pr?.closingIssuesReferences ?? []));
+    } catch (e) {
+      return failed(`gh pr list answered PR #${pr?.number} with ${e.message} — which issues it closes is unknown, so none is folded in`);
+    }
+  }
   const ledger = ledgerRows(cwd);
   if (ledger.error) return failed(`${ledger.error} — which PRs a carried row names is unknown`);
 
@@ -383,7 +396,7 @@ function foldIn({ cwd }) {
       carried += 1;
       continue;
     }
-    const issues = (pr.closingIssuesReferences ?? []).map((i) => i.number).filter(Number.isInteger);
+    const issues = closing.get(pr);
     if (issues.length === 0) {
       advice.push(`NEED review PR#${pr.number} (closes no issue)`);
       continue;

package/scripts/tier-outcomes.mjs

@@ -9,9 +9,9 @@
 //          --note <text> [--sizing light|heavy] [--profile <p>] [--loc <n>] [--files <n>]
 //          [--scratch <dir>]
 //     Fills `run_date` (today's UTC date, the ruling date), `pr`, `ticket` (the
-//     PR's one `gh pr view --json closingIssuesReferences` issue; when the PR
-//     closes zero or several, the N of its one settled `impl-<N>=PR#<pr>` token
-//     in the run ledger), `tier` and, unless
+//     PR's one `gh pr view --json closingIssuesReferences,url` issue in its own
+//     repository; when the PR closes zero or several there, the N of its one
+//     settled `impl-<N>=PR#<pr>` token in the run ledger), `tier` and, unless
 //     `--sizing` names it, `sizing` (see below). Idempotent by
 //     PR: a row already present is named and nothing is written, exit 0.
 //   check [--live]
@@ -84,6 +84,7 @@ import { parseMember, parseToken, memberTokens, rowPr } from "./ledger-grammar.m
 import { rowText } from "./tier-check.mjs";
 import { latestImplReport, readReport, reportsDir, defaultScratch } from "./report-files.mjs";
 import { FleetDirUnresolvable } from "./fleet-dir.mjs";
+import { ownClosingIssues } from "./closing-refs.mjs";
 
 const NAME = "tier-outcomes";
 const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
@@ -455,34 +456,35 @@ function readLedger(ledgerFile, requireFile) {
   }
 }
 
-// The unique issue numbers of a PR's closingIssuesReferences, in GitHub's
-// order, or an Error naming why they could not be read — a reference with no
-// integer issue number among the reasons. GH_REPO is blanked so an ambient one
-// naming another repository never decides which PR is read; the timeout keeps
-// a hung `gh` from stalling `append` or a close-out's `check --live`.
+// The unique issue numbers of a PR's closingIssuesReferences in its own
+// repository, by ownClosingIssues()'s rule, in GitHub's order — another
+// repository's reference is none of them — or an Error naming why they could
+// not be read, a reference that rule cannot read among the reasons. GH_REPO is
+// blanked so an ambient one naming another repository never decides which PR
+// is read; the timeout keeps a hung `gh` from stalling `append` or a
+// close-out's `check --live`.
 const GH_TIMEOUT_MS = 60_000;
 function closingIssueNumbers(pr) {
   let raw;
   try {
-    raw = execFileSync("gh", ["pr", "view", String(pr), "--json", "closingIssuesReferences"], {
+    raw = execFileSync("gh", ["pr", "view", String(pr), "--json", "closingIssuesReferences,url"], {
       encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, GH_REPO: "" }, timeout: GH_TIMEOUT_MS,
     });
   } catch (e) {
     throw new Error(`gh pr view ${pr} failed: ${e.stderr?.trim() || e.message}`);
   }
-  let refs;
+  let view;
   try {
-    refs = JSON.parse(raw).closingIssuesReferences;
+    view = JSON.parse(raw);
   } catch (e) {
     throw new Error(`gh pr view ${pr} returned unreadable JSON: ${e.message}`);
   }
-  if (!Array.isArray(refs)) throw new Error(`gh pr view ${pr} returned no closingIssuesReferences array`);
-  const numbers = [...new Set(refs.map((r) => r?.number))];
-  const unreadable = numbers.filter((n) => !Number.isInteger(n));
-  if (unreadable.length > 0) {
-    throw new Error(`gh pr view ${pr} returned a closing reference with no issue number (${unreadable.map((n) => JSON.stringify(n) ?? "undefined").join(", ")})`);
+  if (!Array.isArray(view?.closingIssuesReferences)) throw new Error(`gh pr view ${pr} returned no closingIssuesReferences array`);
+  try {
+    return ownClosingIssues(pr, view.url, view.closingIssuesReferences);
+  } catch (e) {
+    throw new Error(`gh pr view ${pr} answered ${e.message}`);
   }
-  return numbers;
 }
 
 function closingNumbers(pr) {