@feigi/fleet-ctl 3.111.0 → 3.111.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@feigi/fleet-ctl",
3
- "version": "3.111.0",
3
+ "version": "3.111.1",
4
4
  "description": "Agent fleet: run-team controller, merge bot, PR reviewer, and the ticket pipeline they share",
5
5
  "license": "Apache-2.0",
6
6
  "repository": {
@@ -781,9 +781,10 @@ export function nextRetry(name, names) {
781
781
  export const CELL = /^(slow|task|smol)-(minimal|low|medium|high|xhigh|max)$/;
782
782
  export const CELL_DEF = new RegExp(`^fleet-implementer-${CELL.source.slice(1)}`);
783
783
 
784
- // The cell a row with no `tier=` runs at: `policy_cell`, `slow-high` on every
785
- // Pull until the router's table picks one per stratum. Exported so
786
- // ticket-router.mjs defaults to the same cell this file maps a bare row to.
784
+ // The cell a row with neither `tier=` nor `cell=` runs at: `policy_cell`,
785
+ // `slow-high` on every Pull until the router's table picks one per stratum.
786
+ // Exported so ticket-router.mjs defaults to the same cell this file maps a
787
+ // bare row to.
787
788
  export const POLICY_CELL = "slow-high";
788
789
 
789
790
  // The Exploration Pull's draw: uniform over every cell but
@@ -804,13 +805,18 @@ export function drawCell({ session, ticket, policyCell, cells }) {
804
805
  }
805
806
 
806
807
  // The definition an implementer is dispatched under, off its ticket
807
- // row's `tier=` token — none means `fleet-implementer-<POLICY_CELL>`,
808
- // `tier=<x>` means `fleet-implementer-<x>`. The value becomes a file
808
+ // row's cell token — none means `fleet-implementer-<POLICY_CELL>`,
809
+ // `tier=<x>` or `cell=<x>` means `fleet-implementer-<x>`. `tier=` is the
810
+ // cell a draw picked (a row carrying one is a drawn Pull, which `implRow`
811
+ // reads); `cell=` is the cell the router printed for a Pull it routed without
812
+ // a draw, and reads as no draw. When a row carries both, `tier=` decides: it
813
+ // is the replacement's cell `ledger.mjs token` writes. The value becomes a file
809
814
  // name under `agents/`, so it is held to `[a-z0-9]` words joined by `-`
810
- // rather than joined into a path as written, and two different `tier=`
811
- // values on one row name no single definition — refused, never resolved by
812
- // position. A value with no definition behind it (the retired `tier=alt`) is
813
- // `ledger.mjs dispatch`'s to refuse: it checks the file exists.
815
+ // rather than joined into a path as written, and two different values
816
+ // of the deciding token on one row name no single definition — refused,
817
+ // never resolved by position. A value with no definition behind it (the
818
+ // retired `tier=alt`) is `ledger.mjs dispatch`'s to refuse: it checks the file
819
+ // exists.
814
820
  //
815
821
  // Here, not in tier-check.mjs, because two readers must agree on it:
816
822
  // `ledger.mjs dispatch` prints the definition before the call and records
@@ -820,16 +826,36 @@ export function drawCell({ session, ticket, policyCell, cells }) {
820
826
  // definitions for one row and fail a dispatch made exactly as printed.
821
827
  const TIER_SUFFIX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
822
828
 
829
+ const tokenValues = (rowText, name) =>
830
+ String(rowText ?? "").split(/\s+/).filter((t) => t.startsWith(`${name}=`)).map((t) => t.slice(name.length + 1));
831
+
823
832
  /** Every `tier=` value a row's text carries, in order, duplicates kept. */
824
833
  export function tierValues(rowText) {
825
- return String(rowText ?? "").split(/\s+/).filter((t) => t.startsWith("tier=")).map((t) => t.slice("tier=".length));
834
+ return tokenValues(rowText, "tier");
835
+ }
836
+
837
+ /** Every `cell=` value a row's text carries, in order, duplicates kept. */
838
+ export function cellValues(rowText) {
839
+ return tokenValues(rowText, "cell");
840
+ }
841
+
842
+ /**
843
+ * The token that decides a row's cell, and its values: `tier=` when the row
844
+ * carries one, else `cell=`. Values are empty on a row with neither, and
845
+ * `name` then names no token the row carries.
846
+ * @returns {{name: "tier"|"cell", values: string[]}}
847
+ */
848
+ export function decidingCell(rowText) {
849
+ const tiers = tierValues(rowText);
850
+ return tiers.length > 0 ? { name: "tier", values: tiers } : { name: "cell", values: cellValues(rowText) };
826
851
  }
827
852
 
828
853
  export function expectedDefinition(rowText) {
829
- const values = [...new Set(tierValues(rowText))];
854
+ const { name, values: all } = decidingCell(rowText);
855
+ const values = [...new Set(all)];
830
856
  if (values.length === 0) return `fleet-implementer-${POLICY_CELL}`;
831
- if (values.length > 1) throw new Error(`row carries conflicting tier= tokens (${values.map((v) => `tier=${v}`).join(", ")}) — fix the row with \`ledger.mjs row\``);
832
- if (!TIER_SUFFIX.test(values[0])) throw new Error(`tier=${values[0]} is not a definition suffix — expected [a-z0-9] words joined by '-' — fix the row with \`ledger.mjs row\``);
857
+ if (values.length > 1) throw new Error(`row carries conflicting ${name}= tokens (${values.map((v) => `${name}=${v}`).join(", ")}) — fix the row with \`ledger.mjs row\``);
858
+ if (!TIER_SUFFIX.test(values[0])) throw new Error(`${name}=${values[0]} is not a definition suffix — expected [a-z0-9] words joined by '-' — fix the row with \`ledger.mjs row\``);
833
859
  return `fleet-implementer-${values[0]}`;
834
860
  }
835
861
 
@@ -58,7 +58,7 @@ import { fileURLToPath } from "node:url";
58
58
  import { spawnSync, execFileSync } from "node:child_process";
59
59
  import { makeDie, isFlagLike, hasEqualsForm, isDigits, writeAll } from "./arg.mjs";
60
60
  import { fleetFile, FleetDirUnresolvable } from "./fleet-dir.mjs";
61
- import { parseMember, parseToken, memberTokens, nextMergeBot, nextRetry, liveOnLedger, settledOnLedger, retiredOnLedger, retiredName, readRetired, agentDefinition, expectedDefinition, CELL, POLICY_CELL, tierValues, rowPr, rowWriteRefusal, isReviewToken, addedReviewToken, newSplitRow, splitRowClause, added, premisesOf, MEMBER_FAMILIES, HALT_CAUSES, ROWS, DISPATCHED, FILED, RULED, DRAIN, RETIRED, RECEIPT, archiveStamp, receiptArchiveName, CLOSEOUT_RECEIPT, closeoutArchiveName, BRIEFS, briefsArchiveName, memberRole, parseDispatchedEntry, dispatchedEntry, headerRe, escapeText, ledgerSection, nextReviewerName } from "./ledger-grammar.mjs";
61
+ import { parseMember, parseToken, memberTokens, nextMergeBot, nextRetry, liveOnLedger, settledOnLedger, retiredOnLedger, retiredName, readRetired, agentDefinition, expectedDefinition, CELL, POLICY_CELL, tierValues, cellValues, decidingCell, rowPr, rowWriteRefusal, isReviewToken, addedReviewToken, newSplitRow, splitRowClause, added, premisesOf, MEMBER_FAMILIES, HALT_CAUSES, ROWS, DISPATCHED, FILED, RULED, DRAIN, RETIRED, RECEIPT, archiveStamp, receiptArchiveName, CLOSEOUT_RECEIPT, closeoutArchiveName, BRIEFS, briefsArchiveName, memberRole, parseDispatchedEntry, dispatchedEntry, headerRe, escapeText, ledgerSection, nextReviewerName } from "./ledger-grammar.mjs";
62
62
  import { deriveRun, LedgerError, labelOffMember, HELD, CONFLICT_HOLD, PARKED } from "./fleet-tick.mjs";
63
63
  import { stateFileIn, readState, writeState, assessBeat, stallsAt } from "./fleet-state.mjs";
64
64
  import { processSource, ancestry, controllerOf, judgeController, ProcUnreadable } from "./proc.mjs";
@@ -748,11 +748,14 @@ if (cmd === "read") {
748
748
  // rewrite alike; a well-formed token, live or settled, still goes through.
749
749
  const malformed = memberTokens(line).find((t) => t.error !== null);
750
750
  if (malformed) die(`row ${key}: malformed member token '${malformed.name}=${malformed.outcome}' — ${malformed.error}`);
751
- // `tier=` names the implementer cell an exploration Pull dispatched, so its
752
- // value must be a cell token: a retired or misspelt tier written here would
753
- // only be refused later, by `dispatch`, after the claim.
754
- const badTier = tierValues(line).find((v) => !CELL.test(v));
755
- if (badTier !== undefined) die(`row ${key}: 'tier=${badTier}' is not tier=<cell> — a cell is <slow|task|smol>-<level>`);
751
+ // `tier=` names the implementer cell an exploration Pull dispatched, and
752
+ // `cell=` the cell a Pull the router routed without a draw did, so each value
753
+ // must be a cell token: a retired or misspelt one written here would only be
754
+ // refused later, by `dispatch`, after the claim.
755
+ for (const [name, values] of [["tier", tierValues(line)], ["cell", cellValues(line)]]) {
756
+ const bad = values.find((v) => !CELL.test(v));
757
+ if (bad !== undefined) die(`row ${key}: '${name}=${bad}' is not ${name}=<cell> — a cell is <slow|task|smol>-<level>`);
758
+ }
756
759
  // A Pull's cell binds its implementer until that member settles; see
757
760
  // cellChangeRefusal(). A new row binds nothing yet.
758
761
  const i = data.rows.findIndex((r) => r.split(/\s/)[0] === key);
@@ -2226,14 +2229,14 @@ async function runDispatch() {
2226
2229
 
2227
2230
  // The definition the `task` call names, printed so the controller reads it
2228
2231
  // off this output rather than recalling it from prose a compaction drops.
2229
- // An implementer's comes off its row's `tier=`, the same function
2230
- // tier-check.mjs falls back to for an entry with no record, and `dispatch`
2231
- // records what it prints on the member's `## Dispatched` entry, which
2232
- // tier-check judges the member against — so a row that names no single
2233
- // definition, or names one with no file under `agents/` (a well-formed
2234
- // `tier=` whose definition has not shipped: a `task` call naming it cannot
2235
- // resolve), is refused here, before the member is live, not discovered by
2236
- // the check after the call.
2232
+ // An implementer's comes off its row's `tier=`, else its `cell=`, the same
2233
+ // function tier-check.mjs falls back to for an entry with no record, and
2234
+ // `dispatch` records what it prints on the member's `## Dispatched` entry,
2235
+ // which tier-check judges the member against — so a row that names no
2236
+ // single definition, or names one with no file under `agents/` (a
2237
+ // well-formed `tier=` or `cell=` whose definition has not shipped: a `task`
2238
+ // call naming it cannot resolve), is refused here, before the member is
2239
+ // live, not discovered by the check after the call.
2237
2240
  //
2238
2241
  // A fix-applier is `fleet-fix-applier` for every kind of work — review,
2239
2242
  // conflict hold, dispositions retry — so its definition reads nothing off
@@ -2287,15 +2290,18 @@ async function runDispatch() {
2287
2290
  const failures = labelled === null ? closing.failures : [...closing.failures, labelled];
2288
2291
  if (failures.length > 0) die(`${member.name}: ${failures.join("; ")} — not dispatching ${member.name}`);
2289
2292
  }
2290
- // Every error caught here carries its own cause and remedy — a row's `tier=`
2293
+ // Every error caught here carries its own cause and remedy — a row's `tier=` or `cell=`
2291
2294
  // (fix it with `ledger.mjs row`) for an implementer, a family
2292
2295
  // ledger-grammar.mjs has no definition case for otherwise — so this
2293
2296
  // refusal's tail names neither.
2294
2297
  let agent;
2295
2298
  try {
2296
- agent = agentDefinition(member, i === -1 ? "" : data.rows[i]);
2299
+ const row = i === -1 ? "" : data.rows[i];
2300
+ agent = agentDefinition(member, row);
2297
2301
  if (member.family === "impl" && !existsSync(join(AGENTS_DIR, `${agent}.agent.md`))) {
2298
- throw new Error(`row #${member.number}'s tier= names ${agent}, which has no agents/${agent}.agent.md — fix the row with \`ledger.mjs row\``);
2302
+ const { name, values } = decidingCell(row);
2303
+ const cause = values.length === 0 ? `row #${member.number} has no tier= or cell=, so it runs the policy cell ${agent}` : `row #${member.number}'s ${name}= names ${agent}`;
2304
+ throw new Error(`${cause}, which has no agents/${agent}.agent.md — fix the row with \`ledger.mjs row\``);
2299
2305
  }
2300
2306
  } catch (e) {
2301
2307
  die(`${member.name}: ${e.message} — not dispatching ${member.name}`);
@@ -2925,10 +2931,11 @@ function badLabelOff(words) {
2925
2931
  });
2926
2932
  }
2927
2933
 
2928
- // The cell a row's implementer runs at — its `tier=`, or POLICY_CELL on a row
2929
- // with none — read the way `dispatch` reads it: null for a row whose `tier=`
2930
- // values conflict or name no agents/<definition>.agent.md, which `dispatch`
2931
- // refuses, so such a row has no draw to bind.
2934
+ // The cell a row's implementer runs at — its `tier=`, else its `cell=`, or
2935
+ // POLICY_CELL on a row with neither — read the way `dispatch` reads it: null
2936
+ // for a row whose deciding values conflict or name no
2937
+ // agents/<definition>.agent.md, which `dispatch` refuses, so such a row has no
2938
+ // draw to bind.
2932
2939
  function runnableCell(rowText) {
2933
2940
  let definition;
2934
2941
  try {
@@ -2937,7 +2944,7 @@ function runnableCell(rowText) {
2937
2944
  return null;
2938
2945
  }
2939
2946
  if (!existsSync(join(AGENTS_DIR, `${definition}.agent.md`))) return null;
2940
- return tierValues(rowText)[0] ?? POLICY_CELL;
2947
+ return definition.slice("fleet-implementer-".length);
2941
2948
  }
2942
2949
 
2943
2950
  // The member a row's cell binds, while it has not settled, else null: the
@@ -2966,7 +2973,7 @@ function cellChangeRefusal(oldLine, line) {
2966
2973
  if (oldLine === null) return null;
2967
2974
  const cell = runnableCell(oldLine);
2968
2975
  if (cell === null) return null;
2969
- const tiers = [...new Set(tierValues(line))];
2976
+ const tiers = [...new Set(decidingCell(line).values)];
2970
2977
  const to = tiers.length === 0 ? POLICY_CELL : tiers.join(" and ");
2971
2978
  if (to === cell) return null;
2972
2979
  const member = unsettledImplementer(oldLine);
@@ -2991,7 +2998,8 @@ function withTier(line, tok) {
2991
2998
  // then dedupe against), and the row's ` · ` separator are no token. A member
2992
2999
  // token is `dispatch`'s or `settle`'s, a review token `review`'s. A word
2993
3000
  // shaped like a member that the grammar cannot parse, a `tier=` that is not
2994
- // a cell, a `tier=` naming a second tier in one call, a `held-behind`,
3001
+ // a cell, a `tier=` naming a second tier in one call, any `cell=` (the row
3002
+ // step's, never a token), a `held-behind`,
2995
3003
  // `conflict-hold` or `parked` token the tick cannot read, and a lone `→` — an
2996
3004
  // arrow with no PR beside it points at nothing — are refused. Every other
2997
3005
  // word is a freeform token.
@@ -3026,6 +3034,9 @@ function tokenRefusal(tok, earlier) {
3026
3034
  return `names a second tier — this call already names tier=${other}, and a row names one`;
3027
3035
  }
3028
3036
  }
3037
+ if (tok.startsWith("cell=")) {
3038
+ return "is the cell the Pull's row step wrote for a Pull routed without a draw — a replacement's cell is `tier=<cell>`";
3039
+ }
3029
3040
  if (tok === "→") return "is the row's arrow, which is written with the PR it points at — ledger.mjs row writes the whole line";
3030
3041
  if (badLabelOff([tok]) !== undefined) return LABEL_OFF_UNKNOWN;
3031
3042
  return null;
package/scripts/pull.mjs CHANGED
@@ -135,7 +135,7 @@ import { isDigits, makeDie } from "./arg.mjs";
135
135
  import { FleetDirUnresolvable, fleetFile } from "./fleet-dir.mjs";
136
136
  import { gitEnv } from "./git-env.mjs";
137
137
  import { isCLI } from "./is-cli.mjs";
138
- import { EXCLUDED_REASON, memberTokens, premisesOf, pullEnded, tierValues } from "./ledger-grammar.mjs";
138
+ import { EXCLUDED_REASON, POLICY_CELL, memberTokens, premisesOf, pullEnded, tierValues } from "./ledger-grammar.mjs";
139
139
  import { sessionFromReceipt } from "./phase0-receipt.mjs";
140
140
  import { briefPaths, briefText, defang, outOfScope, strandedRuling, ticketText } from "./ticket-text.mjs";
141
141
 
@@ -217,7 +217,8 @@ const isImplRow = (row) => memberTokens(row).some((t) => t.family === "impl");
217
217
  /**
218
218
  * The `--impl-row` the router is given: the row count the Pull creates — or,
219
219
  * while an exploration assignment is rolling (the latest row 5k and every row
220
- * after it carry no `tier=`), that row's number.
220
+ * after it carry no `tier=`: a `cell=` is a routed Pull's cell, not a draw), that
221
+ * row's number.
221
222
  */
222
223
  export function implRow(rows) {
223
224
  const impl = rows.filter(isImplRow);
@@ -964,7 +965,10 @@ class Pull {
964
965
  stage_row() {
965
966
  const { st } = this;
966
967
  const { cell, draw, reason } = st.route;
967
- const text = `${st.member}${draw === "-" ? "" : ` · tier=${cell}`}${reason === "ok" ? "" : ` · route=${reason}`}`;
968
+ // `tier=` marks a draw; a Pull routed without one still dispatches at the
969
+ // cell the router printed, carried as `cell=` so the row reads as undrawn.
970
+ const carrier = draw !== "-" ? ` · tier=${cell}` : cell !== POLICY_CELL ? ` · cell=${cell}` : "";
971
+ const text = `${st.member}${carrier}${reason === "ok" ? "" : ` · route=${reason}`}`;
968
972
  const r = this.script("row", "ledger.mjs", ["row", String(st.ticket), text]);
969
973
  if (r.status !== 0) return this.stop(withText(`ledger.mjs row failed (${r.how})`, r));
970
974
  st.stage = "render";
@@ -58,7 +58,7 @@
58
58
  // ledger's terms, not the caller's: the definition it should have
59
59
  // run under is the one its `## Dispatched` entry recorded at dispatch
60
60
  // (`agent=`, read through `ledger.mjs read`), falling back for an entry
61
- // without one to its ticket row's `tier=` token (ledger-grammar.mjs's
61
+ // without one to its ticket row's `tier=` or `cell=` token (ledger-grammar.mjs's
62
62
  // `expectedDefinition` — the same function `ledger.mjs dispatch` prints the
63
63
  // definition from), the agent type
64
64
  // it was actually dispatched as is
@@ -481,7 +481,7 @@ function main() {
481
481
  die(`batch entry missing member/agentFile: ${JSON.stringify(raw)}`);
482
482
  }
483
483
  if (impl && raw.agentFile) {
484
- 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`);
484
+ 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, or cell= when it has none, names`);
485
485
  }
486
486
  const hasJobRecord = raw.resolvedModel && raw.resolvedThinkingLevel;
487
487
  let frontmatter = null, transcriptText = null, ticket = null, definition = null;
@@ -72,13 +72,15 @@ One line per ticket, rewritten in place (`ledger.mjs row <ticket> <text>`; `ledg
72
72
  #<t5> excluded · behind-issue:#<t3>
73
73
  ```
74
74
 
75
+ A row's cell is its `tier=` (the cell a draw picked), else its `cell=` (the cell the router printed for a Pull it routed without a draw, like `#<t6> impl-<t6> · cell=task-high`; `row` writes it, `token` refuses it), else the policy cell, `slow-high`.
76
+
75
77
  ## Writing before dispatch
76
78
 
77
79
  A member that dies between spawn and write is invisible — and members die in batches.
78
80
 
79
81
  `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.
80
82
 
81
- `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.
83
+ `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=` (else `cell=`) 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.
82
84
 
83
85
  ## filed and ruled
84
86
 
@@ -110,4 +112,4 @@ The ledger half reports its own readability as its own field, `ledger.ok`, the p
110
112
 
111
113
  ## Adding a token
112
114
 
113
- Token additions go through `ledger.mjs token`. `ledger.mjs token <key> <token>…` adds a token and keeps every token already on the row. A `tier=` replaces the row's `tier=` instead and keeps every other token; while the row's implementer has not settled, `token` and `row` both refuse a write that changes the row's cell. Re-typing the row with `row` replaces the whole line, so it drops the tokens you do not restate.
115
+ Token additions go through `ledger.mjs token`. `ledger.mjs token <key> <token>…` adds a token and keeps every token already on the row. A `tier=` replaces the row's `tier=` instead and keeps every other token, a `cell=` beside it included, which the `tier=` then overrides; while the row's implementer has not settled, `token` and `row` both refuse a write that changes the row's cell. Re-typing the row with `row` replaces the whole line, so it drops the tokens you do not restate.
@@ -149,7 +149,7 @@ Each member's outcome arrives as its own job status. Settle (CONTEXT.md § Coord
149
149
 
150
150
  ## The implementer's tier is the definition's
151
151
 
152
- The tier lives in that definition's frontmatter (`agents/fleet-implementer-<cell>.agent.md`; `slow-high`, the policy cell, for a row with no `tier=`), which is what an omitted `model` takes first — the session's tier applies only when the definition names none, and a member dispatched with `model` set does not get the declared tier back. Omitting `model` is therefore still the mechanism; what changed is that the tier it resolves to is now declared and pinned rather than inherited by accident. Keep `name: impl-<N>`: the name is what makes a member, and both the spend classifier and `member-outcomes.mjs` read it.
152
+ The tier lives in that definition's frontmatter (`agents/fleet-implementer-<cell>.agent.md`; `slow-high`, the policy cell, for a row with no `tier=` or `cell=`), which is what an omitted `model` takes first — the session's tier applies only when the definition names none, and a member dispatched with `model` set does not get the declared tier back. Omitting `model` is therefore still the mechanism; what changed is that the tier it resolves to is now declared and pinned rather than inherited by accident. Keep `name: impl-<N>`: the name is what makes a member, and both the spend classifier and `member-outcomes.mjs` read it.
153
153
 
154
154
  ## The merge bot's tier buys nothing its backstop does not cover
155
155
 
@@ -252,7 +252,9 @@ terminating in exactly one dispatch or an empty shortlist:
252
252
  `POLICY=… CELL=… DRAW=… STRATUM=… OBJECTIVE=… REASON=…` (the router's arguments paragraph below the list
253
253
  says what each argument is); then `ledger.mjs row <N> "impl-<N>[ · tier=<CELL>][ · route=<REASON>]"`,
254
254
  `tier=<CELL>` exactly when `DRAW` is not `-`; then the dispatch at once: claim
255
- what you are about to dispatch; dispatch what you have just claimed. Router
255
+ what you are about to dispatch; dispatch what you have just claimed. A Pull
256
+ routed without a draw writes `cell=<CELL>` instead, unless `CELL` is the policy
257
+ cell, `slow-high`, which a row with neither runs. Router
256
258
  exit 2 → no row and no dispatch: release the claim (`release-ticket.sh`, SKILL.md's
257
259
  Failure handling row for a claim abandoned mid-run) and emit an event, a probe that could not look — a table the router
258
260
  refuses refuses every Pull.
@@ -261,7 +263,8 @@ terminating in exactly one dispatch or an empty shortlist:
261
263
  row count the Pull creates — or, while an assignment is rolling (the latest
262
264
  row 5k and every row after it carry no `tier=`), that row's number;
263
265
  `--chain-head` marks a ticket another open ticket sequences after, which is
264
- what rolls it. `--arm` is `A` for an even ticket number and `B` for an odd
266
+ what rolls it. A `cell=` is no draw: a row carrying one and no `tier=` still
267
+ rolls. `--arm` is `A` for an even ticket number and `B` for an odd
265
268
  one; a B Pull routes exactly as an A one until the table opens arm B.
266
269
  `--session` is this run's own session directory. The router routes by the
267
270
  row set of the run's Objective, `OBJECTIVE`, which it reads off the phase-0
@@ -399,7 +402,8 @@ the `render` command to run first, and refuses once the
399
402
  run is draining: drain stops supply. It also refuses a row whose `tier=`
400
403
  names no single definition — two different values, or one that is not a
401
404
  definition suffix — or names one with no `agents/<definition>.agent.md`,
402
- before the member is live; fix the row with `row` first. Once every refusal
405
+ before the member is live; fix the row with `row` first. A row with no `tier=`
406
+ is held to the same through its `cell=`. Once every refusal
403
407
  has passed, `dispatch` deletes the member's prior report,
404
408
  `<scratch>/reports/<member>.json`, when its brief's sidecar names an absolute
405
409
  `scratch`, so a prior run's report cannot settle this one. A sidecar naming
@@ -436,8 +440,12 @@ policy cell is the `cost` row set's, so the draw is the same under both. While t
436
440
  true every Pull draws, over every cell, the policy cell included. An
437
441
  Exploration Pull records `tier=<cell>` in the row, and a replacement inherits the row's tier —
438
442
  written at the Pull's row step, ahead of `ledger.mjs dispatch`, which reads it
439
- and prints `fleet-implementer-<cell>` as the `agent` to dispatch; a row with
440
- no `tier=` runs the policy cell. The Pull's cell binds the row's implementer
443
+ and prints `fleet-implementer-<cell>` as the `agent` to dispatch. A Pull the
444
+ router routes without a draw records the cell it printed as `cell=<cell>`
445
+ instead, and dispatches there the same way; `cell=` is no draw, so a row
446
+ carrying it and no `tier=` still reads as "the draw has not happened yet",
447
+ and a draw skipped on a chain head still passes to the next Pull. A `tier=` on the row decides over a
448
+ `cell=`. A row with neither runs the policy cell. The Pull's cell binds the row's implementer
441
449
  (its newest, on a resumed or re-Pulled row):
442
450
  `ledger.mjs row` and `ledger.mjs token` refuse a write that changes it until that implementer has
443
451
  settled. Once it has, a replacement may run at another cell, set with