@feigi/fleet-ctl 3.88.6 → 3.88.7

package/package.json

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

package/scripts/tier-outcomes.mjs

@@ -8,8 +8,10 @@
 //   append <pr> --closed-own-ticket yes|no --minted-false-claim yes|no
 //          --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` (off
-//     `gh pr view --json closingIssuesReferences`), `tier` and, unless
+//     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
 //     `--sizing` names it, `sizing` (see below). Idempotent by
 //     PR: a row already present is named and nothing is written, exit 0.
 //   check [--live]
@@ -20,12 +22,14 @@
 //     lack a member row (nothing from that run was checked). `--live`
 //     (a run in progress; CI never passes it) adds a WARNING, never a
 //     failure, per PR whose run-ledger row carries `reviewed=` but which has
-//     no row here, except a PR that closes no issue: `append` keys a row on
-//     exactly one ticket and refuses it, so it is named in a `note` line and
-//     never warned about. A read of that PR that does not answer keeps the
-//     warning, after a line naming why the read failed. Both reads of a PR's
-//     closing references ignore an ambient GH_REPO and give `gh` 60s.
-//     `--ledger <path>` names another ledger than the run's own.
+//     no row here. A PR whose closing references are not exactly one, and that
+//     no settled `impl-` token names, is named in a `note` line and never
+//     warned about: `append` has no ticket to key a row on. Where such tokens
+//     do name it but `append` would still refuse it, its WARNING says why. A
+//     read of that PR that does not answer keeps the warning, after a line
+//     naming why the read failed. Both reads of a PR's closing references
+//     ignore an ambient GH_REPO and give `gh` 60s. `--ledger <path>` names
+//     another ledger than the run's own.
 //
 // `tier` resolution, in order (never tie-broken by `run_date`: the two files'
 // `run_date`s mean different things — this file's header measures 92 of 267
@@ -451,12 +455,13 @@ function readLedger(ledgerFile, requireFile) {
   }
 }
 
-// A PR's closingIssuesReferences array, or an Error naming why it could not be
-// read. 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 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`.
 const GH_TIMEOUT_MS = 60_000;
-function closingRefs(pr) {
+function closingIssueNumbers(pr) {
   let raw;
   try {
     raw = execFileSync("gh", ["pr", "view", String(pr), "--json", "closingIssuesReferences"], {
@@ -472,21 +477,56 @@ function closingRefs(pr) {
     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`);
-  return refs;
+  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(", ")})`);
+  }
+  return numbers;
 }
 
-function closingTicket(pr) {
-  let refs;
+function closingNumbers(pr) {
   try {
-    refs = closingRefs(pr);
+    return closingIssueNumbers(pr);
   } catch (e) {
     die(e.message);
   }
-  const numbers = [...new Set(refs.map((r) => r?.number))];
-  if (numbers.length !== 1 || !Number.isInteger(numbers[0])) {
-    die(`PR #${pr} closes ${numbers.length === 0 ? "no issue" : `${numbers.length} issues (${numbers.map((n) => `#${n}`).join(", ")})`} per GitHub's closingIssuesReferences — a tier-outcomes row keys on exactly one ticket`);
+}
+
+// Every settled `impl-<N>=PR#<pr>` token in the run ledger's rows, each with the
+// row that carries it and its ticket N. The dispatched list is not read.
+function implementerClaims(ledger, pr) {
+  const claims = [];
+  for (const text of ledger?.rows ?? []) {
+    const key = text.split(/\s/)[0];
+    for (const t of memberTokens(text)) {
+      if (t.family === "impl" && t.error === null && t.outcome === `PR#${pr}`) claims.push({ key, ticket: t.number });
+    }
+  }
+  return claims;
+}
+
+// The ticket a PR's row keys on: its one closing issue, else the N of its one
+// settled impl token. Otherwise `refusal` says why there is none, and `claims`
+// counts the settled impl tokens naming the PR — none is a PR no implementer
+// names. Refused: no such token, several, or several closing issues that do not
+// include the token's N.
+function ticketFor(pr, numbers, ledger) {
+  if (numbers.length === 1) return { ticket: String(numbers[0]) };
+  const claims = implementerClaims(ledger, pr);
+  const closes = numbers.length === 0 ? "closes no issue" : `closes ${numbers.length} issues (${numbers.map((n) => `#${n}`).join(", ")})`;
+  const refused = (why) => ({ claims: claims.length, refusal: `PR #${pr} ${closes} per GitHub's closingIssuesReferences, and ${why}` });
+  if (claims.length === 0) {
+    return refused(`no run-ledger row carries a settled impl-N=PR#${pr} token to name its ticket — a tier-outcomes row keys on exactly one ticket`);
+  }
+  if (claims.length > 1) {
+    return refused(`${claims.length} run-ledger rows carry a settled impl-N=PR#${pr} token (${claims.map((c) => c.key).join(", ")}) — a tier-outcomes row keys on exactly one ticket`);
+  }
+  const [{ key, ticket }] = claims;
+  if (numbers.length > 1 && !numbers.includes(ticket)) {
+    return refused(`its settled impl-${ticket}=PR#${pr} token in ${key} names #${ticket}, which is not among them`);
   }
-  return String(numbers[0]);
+  return { ticket: String(ticket) };
 }
 
 // The UTC date, the convention of a session id's date and so of every Pull's
@@ -525,8 +565,9 @@ function append(pr, paths) {
     return;
   }
 
-  const ticket = closingTicket(pr);
   const ledger = readLedger(paths.ledger, false);
+  const { ticket, refusal } = ticketFor(pr, closingNumbers(pr), ledger);
+  if (refusal) die(refusal);
   const memberRows = readMemberRows(paths.members);
   const resolved = resolveTier({ ledger, memberRows, ticket, pr });
   if (resolved.warning) console.error(`${NAME}: WARNING tier left blank for PR #${pr} (ticket #${ticket}): ${resolved.warning}`);
@@ -557,17 +598,15 @@ function append(pr, paths) {
   console.log(line);
 }
 
-// True only when `gh` answered and the PR's closingIssuesReferences is an empty
-// array. Any other outcome (gh failing, unreadable JSON, a non-array) is false
-// after a line naming why: a PR whose closing references cannot be read keeps
-// its warning. That line never reads `WARNING PR #`, which closeout.mjs turns
-// into a NEED.
-function closesNoIssue(pr) {
+// A PR's closing issue numbers, or null after a line naming why they could not
+// be read. That line never reads `WARNING PR #`, which closeout.mjs turns into
+// a NEED; a PR whose read failed keeps its warning.
+function closingNumbersOrNull(pr) {
   try {
-    return closingRefs(pr).length === 0;
+    return closingIssueNumbers(pr);
   } catch (e) {
     console.error(`${NAME}: could not read the closing references of PR #${pr}: ${e.message}`);
-    return false;
+    return null;
   }
 }
 
@@ -583,11 +622,15 @@ function check(paths) {
   if (has("live")) {
     const ledger = readLedger(paths.ledger, true);
     for (const pr of unrecordedReviewedPrs(ledger, rows)) {
-      if (closesNoIssue(pr)) {
-        console.error(`${NAME}: note PR #${pr} carries reviewed= on the ledger and closes no issue, so it takes no row in ${paths.file}`);
+      const numbers = closingNumbersOrNull(pr);
+      const { refusal, claims } = numbers === null ? {} : ticketFor(pr, numbers, ledger);
+      if (refusal && claims === 0) {
+        const closes = numbers.length === 0 ? "closes no issue" : `closes ${numbers.length} issues`;
+        console.error(`${NAME}: note PR #${pr} carries reviewed= on the ledger and ${closes}, and no settled impl token names it, so it takes no row in ${paths.file}`);
         continue;
       }
-      console.error(`${NAME}: WARNING PR #${pr} carries reviewed= on the ledger but has no row in ${paths.file} — run \`tier-outcomes.mjs append ${pr}\` if it is an implementer PR`);
+      const next = refusal ? `\`tier-outcomes.mjs append ${pr}\` refuses it: ${refusal}` : `run \`tier-outcomes.mjs append ${pr}\` if it is an implementer PR`;
+      console.error(`${NAME}: WARNING PR #${pr} carries reviewed= on the ledger but has no row in ${paths.file} — ${next}`);
     }
   }
 

package/skills/run-team/SKILL.md

@@ -211,7 +211,7 @@ owes beyond its call:
      a recorded stop as the end of the run. A `NEED tier-outcomes append
      <pr>` is a PR the ledger marks reviewed with no verdict row: append it with
      the verdict you rule (**Guard: accumulate per PR**) and run `finish` again.
-     A reviewed PR that closes no issue takes no row and is never a NEED.
+     A PR closing none or several: a row only if an impl token names it.
      A step it fails is explained in references/close-out.md. Exit 0 is the run
      closed.
   Drain only when a documented trigger fired, and name the trigger in `--reason`.

package/skills/run-team/references/close-out.md

@@ -25,8 +25,12 @@
      stop as the end of the run. A `NEED tier-outcomes append <pr>` is a PR
      the ledger marks reviewed with no verdict row: append it with the verdict
      you rule (**Guard: accumulate per PR**) and run `finish` again. A reviewed
-     PR that closes no issue, a `Refs`-only step for instance, takes no row: the
-     check names it in a `note` line and never asks for one. A step it fails is
+     PR that closes no issue, or several, with no settled `impl-<N>=PR#<pr>`
+     token naming it takes no row: the check names it in a `note` line and
+     never asks for one. With such a token it is a NEED: `append` takes the
+     ticket from the token when exactly one row carries it and, for several
+     closing issues, it is among them; otherwise the WARNING behind the NEED
+     says why `append` refuses it. A step it fails is
      explained in references/close-out.md. Exit 0 is the run closed.
   Drain only when a documented trigger fired, and name the trigger in `--reason`.
   **Undrain** only when the maintainer asks, never a drain that budget or
@@ -86,9 +90,11 @@ run's member rows if they are missing, or blank each named row's `tier` and say
 why in `note`.
 Each WARNING names a PR this run's ledger marks `reviewed=` that has no row yet
 — append it before committing if it is an implementer PR. A reviewed PR that
-closes no issue is named in a `note` line instead: it takes no row. A line
-saying the PR's closing references could not be read comes before that PR's
-WARNING and says why.
+closes no issue, or several, and that no settled `impl-<N>=PR#<pr>` token
+names, is named in a `note` line instead: it takes no row. A WARNING for a PR
+that such tokens name but that `append` would refuse says why. A line
+saying the PR's closing references could not be read — a reference with no
+issue number among the reasons — comes before that PR's WARNING and says why.
 
 ## Drain the pending ticket-features rows and refresh the cost guard