@feigi/fleet-ctl 3.102.4 → 3.102.5

package/package.json

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

package/scripts/ledger-grammar.mjs

@@ -120,34 +120,42 @@ export function memberRole(family) {
 // the first 8 hex of the sha256 the brief's sidecar carries. A merge bot's
 // entry then carries `queued=<pr>,<pr>…` — `queued=none` for an empty queue —
 // the open `ready-to-merge` PRs `dispatch` read when it dispatched the bot,
-// which its report is judged against at `settle --from-report`. `settle`
-// rewrites the token and keeps the words beside it.
-const DISPATCHED_ENTRY = /^([^ ]*) brief=([0-9a-f]{8})(?: queued=(none|[1-9][0-9]*(?:,[1-9][0-9]*)*))?$/;
+// which its report is judged against at `settle --from-report`. An
+// implementer's entry ends with `agent=<definition>`, the definition
+// `dispatch` printed for it, which tier-check judges it against. The value
+// becomes a file name under `agents/`, so it is held to `[a-z0-9]` words
+// joined by `-`, the shape of a `tier=` value. `settle` rewrites the token
+// and keeps the words beside it.
+const DISPATCHED_ENTRY = /^([^ ]*) brief=([0-9a-f]{8})(?: queued=(none|[1-9][0-9]*(?:,[1-9][0-9]*)*))?(?: agent=([a-z0-9]+(?:-[a-z0-9]+)*))?$/;
 
 /**
- * `{token, brief, queued}` for one `## Dispatched` entry: the member token,
- * the brief's hash or null, and the PR numbers of its `queued=` word or null
- * for an entry without one. An entry that is not a member token plus a
+ * `{token, brief, queued, agent}` for one `## Dispatched` entry: the member
+ * token, the brief's hash or null, the PR numbers of its `queued=` word or
+ * null for an entry without one, and the definition of its `agent=` word or
+ * null for an entry without one. An entry that is not a member token plus a
  * well-formed `brief=` word, optionally followed by a well-formed `queued=`
- * word, is returned whole as `token`, so a reader parsing it with
- * parseToken() refuses it exactly as it refuses any other entry this grammar
- * cannot parse.
+ * word and a well-formed `agent=` word, is returned whole as `token`, so a
+ * reader parsing it with parseToken() refuses it exactly as it refuses any
+ * other entry this grammar cannot parse.
  */
 export function parseDispatchedEntry(entry) {
   const m = DISPATCHED_ENTRY.exec(entry);
-  if (m === null || parseToken(m[1]) === null) return { token: entry, brief: null, queued: null };
+  if (m === null || parseToken(m[1]) === null) return { token: entry, brief: null, queued: null, agent: null };
   const queued = m[3] === undefined ? null : m[3] === "none" ? [] : m[3].split(",").map(Number);
-  return { token: m[1], brief: m[2], queued };
+  return { token: m[1], brief: m[2], queued, agent: m[4] ?? null };
 }
 
 /**
  * The `## Dispatched` entry for `token`, with `brief=<brief>` unless brief is
- * null and, after it, `queued=…` unless queued is null.
+ * null and, after it, `queued=…` unless queued is null and `agent=<agent>`
+ * unless agent is null.
  */
-export function dispatchedEntry(token, brief, queued = null) {
+export function dispatchedEntry(token, brief, queued = null, agent = null) {
   if (brief === null) return token;
-  const entry = `${token} brief=${brief}`;
-  return queued === null ? entry : `${entry} queued=${queued.join(",") || "none"}`;
+  let entry = `${token} brief=${brief}`;
+  if (queued !== null) entry += ` queued=${queued.join(",") || "none"}`;
+  if (agent !== null) entry += ` agent=${agent}`;
+  return entry;
 }
 
 // `PR#<n>` as a word of a row's text, `PR #<n>` too.
@@ -794,7 +802,7 @@ export function drawCell({ session, ticket, policyCell, cells }) {
   return { cell: E[k - 1], k, K };
 }
 
-// The definition an implementer should run under, off its ticket
+// The definition an implementer is dispatched under, off its ticket
 // row's `tier=` token — none means `fleet-implementer-<POLICY_CELL>`,
 // `tier=<x>` means `fleet-implementer-<x>`. The value becomes a file
 // name under `agents/`, so it is held to `[a-z0-9]` words joined by `-`
@@ -804,10 +812,11 @@ export function drawCell({ session, ticket, policyCell, cells }) {
 // `ledger.mjs dispatch`'s to refuse: it checks the file exists.
 //
 // Here, not in tier-check.mjs, because two readers must agree on it:
-// `ledger.mjs dispatch` prints the definition before the call, and
-// tier-check.mjs judges the member against it after. Two copies could name
-// different definitions for one row and fail a dispatch made exactly as
-// printed.
+// `ledger.mjs dispatch` prints the definition before the call and records
+// it on the member's `## Dispatched` entry, and tier-check.mjs judges the
+// member against that record — against this function's answer for the row
+// only for an entry that holds none. Two copies could name different
+// definitions for one row and fail a dispatch made exactly as printed.
 const TIER_SUFFIX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 
 /** Every `tier=` value a row's text carries, in order, duplicates kept. */

package/scripts/ledger.mjs

@@ -14,9 +14,11 @@
 // every liveness count from this file alone, rather than from row text a
 // controller typed by hand: `dispatch` writes a member's live token onto its
 // row and appends it to `## Dispatched` with `brief=<hash>`, the brief it
-// refuses to dispatch without — and, for a merge bot, `queued=<pr>,…`, the
+// refuses to dispatch without — for a merge bot, `queued=<pr>,…`, the
 // open `ready-to-merge` PRs gh lists at dispatch, which its report must give
-// a verdict each; when that brief's sidecar names an absolute
+// a verdict each, and for an implementer, `agent=<definition>`, the
+// definition it prints, which tier-check judges the implementer against —
+// when that brief's sidecar names an absolute
 // scratch, it also clears the member's report file there, so a prior run's
 // report is not read as this run's; `settle` rewrites that token to
 // `<member>=<outcome>` in both places (an implementer's settle to `PR#M` also
@@ -487,7 +489,7 @@ function refuseStrayInId(value, what) {
 let ledgerParsed = false;
 
 function load() {
-  if (!existsSync(file)) return { rows: [], filed: [], ruled: [], dispatched: [], briefs: {}, queued: {}, drain: null, retired: [] };
+  if (!existsSync(file)) return { rows: [], filed: [], ruled: [], ...dispatchedOf([]), drain: null, retired: [] };
   let text;
   try {
     text = readFileSync(file, "utf8");
@@ -519,14 +521,15 @@ function load() {
 }
 
 // `## Dispatched` held as its tokens, which is what every reader of `read`
-// parses, `briefs`, each member's `brief=` hash by name, and `queued`, each
-// merge bot's `queued=` PR numbers by name: one token per member name for
-// the session, so a settle that rewrites the token keeps the name its brief
-// and its queue are filed under. save() joins them back.
+// parses, `briefs`, each member's `brief=` hash by name, `queued`, each
+// merge bot's `queued=` PR numbers by name, and `agents`, each implementer's
+// `agent=` definition by name: one token per member name for
+// the session, so a settle that rewrites the token keeps the name its brief,
+// its queue and its definition are filed under. save() joins them back.
 function dispatchedOf(entries) {
   const parsed = entries.map(parseDispatchedEntry);
   const byName = (field) => Object.fromEntries(parsed.filter((p) => p[field] !== null).map((p) => [parseToken(p.token).name, p[field]]));
-  return { dispatched: parsed.map((p) => p.token), briefs: byName("brief"), queued: byName("queued") };
+  return { dispatched: parsed.map((p) => p.token), briefs: byName("brief"), queued: byName("queued"), agents: byName("agent") };
 }
 
 // `## Drain` is written only once there is a marker to hold: an empty section
@@ -541,7 +544,7 @@ function save(d) {
     `# Fleet run ledger\n\n${ROWS}\n\n` + list(d.rows) +
     `\n\n${DISPATCHED}\n\n` + list(d.dispatched.map((t) => {
       const name = parseToken(t)?.name;
-      return dispatchedEntry(t, d.briefs[name] ?? null, d.queued[name] ?? null);
+      return dispatchedEntry(t, d.briefs[name] ?? null, d.queued[name] ?? null, d.agents[name] ?? null);
     })) +
     `\n\n${FILED}\n\n` + list(d.filed) +
     `\n\n${RULED}\n\n` + list(d.ruled) +
@@ -1632,7 +1635,7 @@ function runRotate() {
   }
   // Read before anything moves: a ledger whose live tokens cannot be read is
   // refused with nothing moved, never archived with those tokens dropped.
-  let carry = { rows: [], dispatched: [], briefs: {}, queued: {}, retired: [], skipped: [] };
+  let carry = { rows: [], dispatched: [], retired: [], skipped: [] };
   if (prior === "ancestor" && exists) {
     let text;
     try {
@@ -1753,11 +1756,12 @@ function carryOf(text) {
       return false;
     }
   });
-  // An entry's `brief=` and `queued=` travel with it: save() writes them only
-  // beside the token it writes, so a carried member's record still names the
-  // brief it was dispatched with — and a carried merge bot the queue it is
-  // judged against — and a dropped member's does not.
-  const { dispatched: allDispatched, briefs: allBriefs, queued: allQueued } = dispatchedOf(ledgerSection(text, DISPATCHED));
+  // An entry's `brief=`, `queued=` and `agent=` travel with it: save() writes
+  // them only beside the token it writes, so a carried member's record still
+  // names the brief it was dispatched with — a carried merge bot the queue it
+  // is judged against, a carried implementer the definition it is judged
+  // against — and a dropped member's does not.
+  const { dispatched: allDispatched, briefs: allBriefs, queued: allQueued, agents: allAgents } = dispatchedOf(ledgerSection(text, DISPATCHED));
   const dispatched = allDispatched.filter((e) => {
     const t = parseToken(e);
     if (t !== null && t.error === null) return true;
@@ -1780,7 +1784,7 @@ function carryOf(text) {
   const live = liveOnLedger(rows, dispatched);
   const carried = { rows: live.rows.map((i) => rows[i]), dispatched: live.dispatched };
   const retired = retiredOnLedger([...rows, ...skippedRows], allDispatched, archivedRetired, carried);
-  return { ...carried, briefs: allBriefs, queued: allQueued, retired, skipped };
+  return { ...carried, briefs: allBriefs, queued: allQueued, agents: allAgents, retired, skipped };
 }
 
 // ── dispatch / settle ────────────────────────────────────────────────────────
@@ -2220,11 +2224,13 @@ async function runDispatch() {
   // The definition the `task` call names, printed so the controller reads it
   // off this output rather than recalling it from prose a compaction drops.
   // An implementer's comes off its row's `tier=`, the same function
-  // tier-check.mjs judges it by — so a row that names no single definition,
-  // or names one with no file under `agents/` (a well-formed `tier=` whose
-  // definition has not shipped: a `task` call naming it cannot resolve), is
-  // refused here, before the member is live, not discovered by the check
-  // after the call.
+  // tier-check.mjs falls back to for an entry with no record, and `dispatch`
+  // records what it prints on the member's `## Dispatched` entry, which
+  // tier-check judges the member against — so a row that names no single
+  // definition, or names one with no file under `agents/` (a well-formed
+  // `tier=` whose definition has not shipped: a `task` call naming it cannot
+  // resolve), is refused here, before the member is live, not discovered by
+  // the check after the call.
   //
   // A fix-applier is `fleet-fix-applier` for every kind of work — review,
   // conflict hold, dispositions retry — so its definition reads nothing off
@@ -2319,6 +2325,10 @@ async function runDispatch() {
   // A merge bot's queue is recorded here, beside its brief, where nothing in
   // its report can reach: `settle --from-report` judges the report against it.
   if (QUEUED !== null) data.queued[member.name] = QUEUED;
+  // An implementer's definition is recorded here too: tier-check judges the
+  // member against it, and a `tier=` replaced after the member settled does
+  // not change what it was dispatched under.
+  if (member.family === "impl") data.agents[member.name] = agent;
   save(data);
   console.error(`    dispatched ${member.name}`);
   console.log(JSON.stringify({

package/scripts/tier-check.mjs

@@ -56,9 +56,11 @@
 //
 // An implementer (`impl-<N>`, ledger-grammar.mjs's name) is judged on the
 // ledger's terms, not the caller's: the definition it should have
-// run under is derived from its ticket row's `tier=` token
-// (ledger-grammar.mjs's `expectedDefinition` — the same function
-// `ledger.mjs dispatch` prints the definition from), the agent type
+// run under is the one its `## Dispatched` entry recorded at dispatch
+// (`agent=`, read through `ledger.mjs read`), falling back for an entry
+// without one to its ticket row's `tier=` token (ledger-grammar.mjs's
+// `expectedDefinition` — the same function `ledger.mjs dispatch` prints the
+// definition from), the agent type
 // it was actually dispatched as is
 // read off its own transcript and must BE that definition — a generic `task`
 // dispatch fails even when its model happens to match — and the verdict
@@ -468,8 +470,8 @@ function main() {
   }
 
   // The ledger is read at most once for evaluation: every implementer's
-  // expected definition comes off its row, and nothing this loop does
-  // writes a `tier=` token.
+  // expected definition comes off its `## Dispatched` entry or its row, and
+  // nothing this loop does writes either.
   let ledgerData = null;
   let receiptSession;
   const results = entries.map((raw) => {
@@ -479,7 +481,7 @@ function main() {
       die(`batch entry missing member/agentFile: ${JSON.stringify(raw)}`);
     }
     if (impl && raw.agentFile) {
-      die(`${raw.member}: an impl- entry carries no agentFile — its definition is derived from the ledger row's tier= token`);
+      die(`${raw.member}: an impl- entry carries no agentFile — its definition is the one its ## Dispatched entry recorded at dispatch, else the one its ledger row's tier= token names`);
     }
     const hasJobRecord = raw.resolvedModel && raw.resolvedThinkingLevel;
     let frontmatter = null, transcriptText = null, ticket = null, definition = null;
@@ -487,7 +489,13 @@ function main() {
       if (impl) {
         ticket = parsed.number;
         ledgerData ??= readLedger(ledgerFile);
-        definition = expectedDefinition(rowText(ledgerData, ticket));
+        // A `## Dispatched` entry for this member that the grammar cannot
+        // read, a malformed `agent=` among them, refuses: the definition it
+        // recorded is unreadable, and the row's `tier=` may have been
+        // replaced since.
+        const malformed = (ledgerData.dispatched ?? []).find((t) => t.split(/[\s=]/)[0] === raw.member && parseToken(t)?.error !== null);
+        if (malformed !== undefined) throw new Error(`## Dispatched entry '${malformed}' is malformed, so the definition it recorded cannot be read`);
+        definition = ledgerData.agents?.[raw.member] ?? expectedDefinition(rowText(ledgerData, ticket));
         const definitionFile = join(repoRoot, "agents", `${definition}.agent.md`);
         if (existsSync(definitionFile)) frontmatter = parseFrontmatter(readFileSync(definitionFile, "utf8"));
       } else {

package/skills/run-team/references/ledger.md

@@ -78,6 +78,8 @@ A member that dies between spawn and write is invisible — and members die in b
 
 `dispatch merge-bot` also records the queue the bot is dispatched against: its `## Dispatched` entry carries `queued=<pr>,<pr>…` (`queued=none` for an empty queue), the open `ready-to-merge` PRs gh lists at that moment. A gh that cannot answer refuses the dispatch, nothing written. `settle merge-bot-<n> --from-report` judges the bot's report against that queue, not against anything the report names: a PR from it that is still open and carries the label, with no verdict in `merged`, `held`, `conflictHold` or `refused`, fails the settle at exit 3, naming the PR, and an entry without `queued=` cannot be judged (exit 2) — settle that bot by hand.
 
+`dispatch impl-<N>` also records the definition it prints: the implementer's `## Dispatched` entry ends with `agent=<definition>` (`agent=fleet-implementer-<cell>`), and `ledger.mjs read` prints it under `agents`, by member name. tier-check judges the implementer against that record, falling back to the row's `tier=` for an entry without one, so a `tier=` replaced after the implementer settled does not change what it is judged against. `settle` and `rotate` keep the word with its entry. A value that is not `[a-z0-9]` words joined by `-` makes the entry malformed, and the ledger is refused.
+
 ## filed and ruled
 
 `filed` is checked with `ledger.mjs check <subject>` before every `gh issue create`, so a finding already recorded this run is not filed twice. That is not a guarantee against duplicates at large; the tracker query, described under `check`'s exits and its `verdict` above, is what covers those.