@feigi/fleet-ctl 3.98.2 → 3.99.0

package/package.json

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

package/scripts/metrics-refresh.mjs

@@ -14,6 +14,8 @@
 // `docs/metrics/ticket-features.tsv`, deduped on `session` + `agent`, and
 // deletes the pending file. A crash between the write and the delete leaves
 // rows the next drain finds already there, so a second run changes nothing.
+// A corpus written before a column the pending file carries — one the row
+// grammar names — gains that column, blank on every row it already holds.
 // A pending file that is empty, or blank lines only, is removed with its own
 // line: an append created it and never wrote.
 // The drain takes no lock by design: it assumes only the run's controller
@@ -59,6 +61,17 @@ const say = (line) => process.stdout.write(`${NAME}: ${line}\n`);
 const headerOf = (text) => String(text).split("\n").find((l) => l.trim() && !l.startsWith("#")).split("\t");
 const pullKey = (r) => `${r.session}\0${r.agent}`;
 
+// `text`, a features TSV, with `columns` appended: named on its header line, blank on each row.
+function widen(text, columns) {
+  let header = true;
+  return text.split("\n").map((l) => {
+    if (!l.trim() || l.startsWith("#")) return l;
+    const added = header ? columns : columns.map(() => "");
+    header = false;
+    return [l, ...added].join("\t");
+  }).join("\n");
+}
+
 function drain(repo) {
   const pending = join(repo, PENDING);
   if (!existsSync(pending)) return say(`drain: nothing pending in ${PENDING}`);
@@ -76,19 +89,22 @@ function drain(repo) {
   const target = join(repo, FEATURES);
   let text = existsSync(target) ? readFileSync(target, "utf8") : `${FEATURE_COLUMNS.join("\t")}\n`;
   const seen = new Set(parseFeatures(text).map(pullKey));
-  const header = headerOf(text);
-  const unknown = headerOf(pendingText).filter((c) => !header.includes(c));
+  const had = headerOf(text);
+  const newer = headerOf(pendingText).filter((c) => !had.includes(c));
+  const unknown = newer.filter((c) => !FEATURE_COLUMNS.includes(c));
   if (unknown.length) throw new Error(`${PENDING} carries ${unknown.join(", ")}, which ${FEATURES} has no column for`);
+  if (newer.length) text = widen(text, newer);
+  const header = [...had, ...newer];
   const added = [];
   for (const r of incoming) {
     if (seen.has(pullKey(r))) continue;
     seen.add(pullKey(r));
     added.push(header.map((c) => r[c] ?? "").join("\t"));
   }
-  if (added.length) {
+  if (added.length || newer.length) {
     if (!text.endsWith("\n")) text += "\n";
     mkdirSync(dirname(target), { recursive: true });
-    writeFileSync(`${target}.tmp`, `${text}${added.join("\n")}\n`);
+    writeFileSync(`${target}.tmp`, `${text}${added.map((l) => `${l}\n`).join("")}`);
     renameSync(`${target}.tmp`, target);
   }
   unlinkSync(pending);

package/scripts/phase0-receipt.mjs

@@ -1,7 +1,8 @@
 // The phase-0 receipt, read. `.fleet/phase0.json` is written by phase0.mjs
 // after every step (its header gives the shape); this module is its readers'
 // half: the tick's dispatch gate, the session directory tier-check.mjs
-// and ticket-router.mjs take when their own flag is omitted, and the In-flight
+// and ticket-router.mjs take when their own flag is omitted, the Objective
+// ticket-router.mjs takes likewise, with its default, and the In-flight
 // bound the drivers hand the tick, with its default. One reading of the file,
 // so the gate and the session readers cannot disagree about what a receipt is.
 //
@@ -145,6 +146,25 @@ export function sessionFromReceipt(opts) {
   throw new Error(`no session given and none in the phase-0 receipt ${path} (${why}) — give one, or run ${phase0Command(null)} first`);
 }
 
+// What a run asks the router to minimise, and the one it asks when nobody
+// names one. phase0.mjs records the run's in its receipt; a receipt written
+// before it recorded one is read as the default when phase 0 resumes it.
+export const OBJECTIVES = Object.freeze(["cost", "speed"]);
+export const OBJECTIVE_DEFAULT = "cost";
+
+/**
+ * The Objective the receipt records, for a reader whose own flag was omitted.
+ * Throws an Error naming the receipt when it has none to give.
+ */
+export function objectiveFromReceipt(opts) {
+  const { path, read } = readRunReceipt(opts);
+  if (read.state === "ok" && OBJECTIVES.includes(read.receipt.objective)) return read.receipt.objective;
+  const why = read.state === "missing" ? "no receipt"
+    : read.state === "unreadable" ? `unreadable: ${read.why}`
+    : "it records no objective";
+  throw new Error(`no objective given and none in the phase-0 receipt ${path} (${why}) — give one (${OBJECTIVES.join(" or ")}), or run ${phase0Command(null)} first`);
+}
+
 // The In-flight bound a run takes when nobody gives one: the most tickets
 // between Claim and merge at once. Its one definition — phase0.mjs and the
 // tick's own flag default both read it from here.

package/scripts/phase0.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 // Phase 0 as one command: the run's start sequence, in order, with a receipt.
 //
-//   phase0.mjs [--session <dir>] [--in-flight n] [--plugin-checkout <dir>]
-//              [--spend-dir <dir>]
+//   phase0.mjs [--session <dir>] [--in-flight n] [--objective cost|speed]
+//              [--plugin-checkout <dir>] [--spend-dir <dir>]
 //              [--workflow <name> | --declare-no-ci]
 //
 // The session directory is `--session`, else `PI_ARTIFACTS_DIR`, which omp
@@ -74,7 +74,7 @@
 // THE RECEIPT is `.fleet/phase0.json` (resolved through fleet-dir.mjs, so a
 // worktree and the main checkout name one file):
 //
-//   { run, session, scratch, inFlight,
+//   { run, session, scratch, inFlight, objective,
 //     steps: { <name>: { status, at, output } } }
 //
 // `status` is ok, pending, failed, drift or unanswered; `at` an ISO time;
@@ -85,6 +85,12 @@
 // run. `session` is the session directory, from `--session` or
 // `PI_ARTIFACTS_DIR`. `scratch` is what `scratch-root.mjs` prints. `inFlight`
 // is the In-flight bound this run used — `--in-flight`, or its default.
+// `objective` is the Objective the router routes this run's Pulls by:
+// `--objective`, or its default (OBJECTIVE_DEFAULT in phase0-receipt.mjs).
+// It is fixed for the run: a resumed receipt keeps the one it records — the
+// default when it records none — and a resume whose `--objective` names the
+// other one exits 2 naming both, leaving the receipt as it was. A resumed
+// receipt recording a value that is not an Objective exits 3 naming it.
 //
 // RESUMABLE. A re-run reads the receipt. It continues it — skipping every `ok`
 // step but `alarm` and re-running the rest — only when its `run` equals the
@@ -148,7 +154,7 @@ import { gitEnv } from "./git-env.mjs";
 import { isCLI } from "./is-cli.mjs";
 import { RECEIPT, RECEIPT_HELD, archiveStamp, receiptArchiveName, rowNums } from "./ledger-grammar.mjs";
 import { ancestry, controllerOf, processSource, ProcUnreadable } from "./proc.mjs";
-import { IN_FLIGHT_DEFAULT } from "./phase0-receipt.mjs";
+import { IN_FLIGHT_DEFAULT, OBJECTIVES, OBJECTIVE_DEFAULT } from "./phase0-receipt.mjs";
 
 const NAME = "phase0";
 const SCRIPTS = dirname(fileURLToPath(import.meta.url));
@@ -525,7 +531,7 @@ function main() {
   const die = makeDie(NAME);
   const F = defineFlags(die, {
     flags: {
-      session: "value", "in-flight": "value", "plugin-checkout": "value",
+      session: "value", "in-flight": "value", objective: "value", "plugin-checkout": "value",
       "spend-dir": "value", workflow: "value", "declare-no-ci": "bool",
     },
   });
@@ -563,6 +569,8 @@ function main() {
     return n;
   };
   const inFlight = positive("in-flight") ?? IN_FLIGHT_DEFAULT;
+  const named = F.arg("objective");
+  if (named !== null && !OBJECTIVES.includes(named)) die(`--objective needs ${OBJECTIVES.join(" or ")}, got ${named}`);
   if (F.has("declare-no-ci") && !absent("workflow")) die("--workflow and --declare-no-ci are alternatives, not a pair");
   const ci = F.has("declare-no-ci") ? "CI: declared absent (--declare-no-ci)" : absent("workflow") ? null : `CI: workflow ${F.arg("workflow")} (--workflow)`;
   const pathOf = (name) => (absent(name) ? null : resolve(F.arg(name)));
@@ -617,6 +625,19 @@ function main() {
   // the `at` it names and the session is the same.
   const rotated = previous !== null && (previous.run !== null || previous.steps.rotate?.status === "ok");
   const resumed = rotated && previous.run === (record?.at ?? null) && previous.session === session;
+  // The Objective is fixed for the run: a resumed receipt's stands, and one
+  // written before receipts recorded it resumes as the default. A receipt
+  // recording anything else is refused, never read as an Objective.
+  if (resumed && previous.objective !== undefined && !OBJECTIVES.includes(previous.objective)) {
+    process.stderr.write(`${NAME}: this run's receipt ${receiptPath} records the objective ${JSON.stringify(previous.objective)}, which is not ${OBJECTIVES.join(" or ")} — set it to the objective this run began with and re-run\n`);
+    process.exitCode = 3;
+    return;
+  }
+  const kept = resumed ? previous.objective ?? OBJECTIVE_DEFAULT : null;
+  if (kept !== null && named !== null && named !== kept) {
+    die(`--objective ${named}: this run's receipt ${receiptPath} records the objective ${kept}, fixed for the run — run phase 0 again without --objective, or with --objective ${kept}`);
+  }
+  const objective = kept ?? named ?? OBJECTIVE_DEFAULT;
   if (rotated && !resumed) {
     if (existsSync(held)) {
       process.stderr.write(`${NAME}: cannot hold the previous run's receipt for the rotation: ${held} already holds another\n`);
@@ -626,7 +647,7 @@ function main() {
     renameSync(receiptPath, held);
   }
 
-  const receipt = { run: resumed ? previous.run : null, session, scratch, inFlight, steps: {} };
+  const receipt = { run: resumed ? previous.run : null, session, scratch, inFlight, objective, steps: {} };
   for (const name of STEP_NAMES) {
     // `alarm` checks the omp running this invocation, so its `ok` is never carried.
     const was = resumed && name !== "alarm" ? previous.steps[name] : undefined;

package/scripts/pr-cost.mjs

@@ -102,7 +102,7 @@ export function trips(cell, base) {
 export function computeReport({ members, tiers, features, prs, routerTable = null, pricing = null, windowStart = WINDOW_START }) {
   const units = attribute({ features, members, tiers, prs, windowStart });
   const tallies = new Map(tally(units).map((t) => [t.cell, t]));
-  const bootUnits = (g) => g.pulls.map(bootUnit);
+  const bootUnits = (g) => g.pulls.map((u) => bootUnit(u));
   const meanUsd = (t) => (t.merged ? t.spend / t.merged : null);
   const base = tallies.get(BASELINE_CELL) ?? null;
   // One generation's figures. The interval is the newest generation's against
@@ -143,8 +143,9 @@ export function computeReport({ members, tiers, features, prs, routerTable = nul
     }
   }
   const verdict = baseline.n < MIN_N ? "none" : tripped.length ? "tripped" : "ok";
-  // Retire: every non-default stage-1 cell tripped before any stratum adopted one.
-  const adopted = Object.values(routerTable?.rows ?? {}).some((c) => c !== BASELINE_CELL);
+  // Retire: every non-default stage-1 cell tripped before any row of either
+  // objective's set adopted one.
+  const adopted = Object.values(routerTable?.rows ?? {}).some((set) => Object.values(set).some((c) => c !== BASELINE_CELL));
   const retire = !adopted && STAGE_1.filter((c) => c !== BASELINE_CELL).every((c) => tripped.includes(c));
 
   return {

package/scripts/pull-attribution.mjs

@@ -78,12 +78,14 @@ import { parseMemberName } from "./member-record.mjs";
 import { isImplementer } from "./member-outcomes.mjs";
 import { DATE, rulingFor, rulingsByTicket } from "./tier-outcomes.mjs";
 
-// The ticket-features row, one per Pull, in this order.
+// The ticket-features row, one per Pull, in this order. `objective` came last
+// and is optional on read: a file whose header lacks it reads it blank.
 export const FEATURE_COLUMNS = Object.freeze([
   "run_date", "session", "agent", "ticket", "policy_cell", "chosen_cell", "exploration_draw",
   "sizing_src", "sizing_pre", "router_usd", "brief_chars", "criteria", "comments", "age_days",
-  "paths", "test_paths", "xrefs", "kind",
+  "paths", "test_paths", "xrefs", "kind", "objective",
 ]);
+const OPTIONAL_COLUMNS = new Set(["objective"]);
 
 // The quality floor's margin, in points of fail rate.
 export const TRIP_POINTS = 15;
@@ -108,10 +110,12 @@ function mulberry32(seed) {
   };
 }
 
-// The bootstrap 95% range of (cell − base) $ per merged PR, its ends rounded
-// to cents. Each unit is one counted Pull: `{ usd, merged }`, merged 0 or 1.
-// $ per merged PR is Σusd / Σmerged. null when either side has no unit, or
-// when under half the resamples have a merged PR on both sides.
+// The bootstrap 95% range of (cell − base) per merged PR, its ends rounded to
+// two places. Each unit is one counted Pull, `bootUnit`'s shape:
+// `{ value, merged }`, `value` the measure `bootUnit` was asked for and
+// merged 0 or 1. The figure per merged PR is Σvalue / Σmerged. null when
+// either side has no unit, or when under half the resamples have a merged PR
+// on both sides.
 export function bootstrapDiffCI(cellUnits, baseUnits, { iterations = 2000, seed = 1 } = {}) {
   if (!cellUnits.length || !baseUnits.length) return null;
   const rand = mulberry32(seed);
@@ -119,7 +123,7 @@ export function bootstrapDiffCI(cellUnits, baseUnits, { iterations = 2000, seed
     let u = 0, m = 0;
     for (let i = 0; i < units.length; i++) {
       const x = units[Math.floor(rand() * units.length)];
-      u += x.usd; m += x.merged;
+      u += x.value; m += x.merged;
     }
     return m ? u / m : null;
   };
@@ -133,8 +137,11 @@ export function bootstrapDiffCI(cellUnits, baseUnits, { iterations = 2000, seed
   return [round2(diffs[Math.floor(0.025 * (diffs.length - 1))]), round2(diffs[Math.ceil(0.975 * (diffs.length - 1))])];
 }
 
-// A counted Pull as a bootstrap unit.
-export const bootUnit = (u) => ({ usd: u.spend, merged: u.merged ? 1 : 0 });
+// What a bootstrap unit measures: `usd`, its spend, or `minutes`, its work time.
+const METRIC = Object.freeze({ usd: (u) => u.spend, minutes: (u) => u.workS / 60 });
+
+// A counted Pull as a bootstrap unit, its `value` the Pull's `metric`.
+export const bootUnit = (u, metric = "usd") => ({ value: METRIC[metric](u), merged: u.merged ? 1 : 0 });
 
 // ticket-features.tsv: one bare header line naming the columns, then rows.
 // Read by header name; a row whose width differs from the header's is refused.
@@ -142,7 +149,7 @@ export function parseFeatures(text) {
   const lines = String(text ?? "").split("\n").filter((l) => l.trim() && !l.startsWith("#"));
   if (lines.length === 0) throw new Error("ticket-features.tsv has no header line");
   const header = lines[0].split("\t");
-  const missing = FEATURE_COLUMNS.filter((c) => !header.includes(c));
+  const missing = FEATURE_COLUMNS.filter((c) => !header.includes(c) && !OPTIONAL_COLUMNS.has(c));
   if (missing.length) throw new Error(`ticket-features.tsv header lacks ${missing.join(", ")}`);
   return lines.slice(1).map((l, i) => {
     const cells = l.split("\t");
@@ -150,6 +157,7 @@ export function parseFeatures(text) {
       throw new Error(`ticket-features.tsv row ${i + 1}: ${cells.length} fields, expected ${header.length} — ${l.slice(0, 60)}`);
     }
     const row = Object.fromEntries(header.map((c, j) => [c, cells[j]]));
+    for (const c of OPTIONAL_COLUMNS) row[c] ??= "";
     if (!isDigits(row.ticket)) throw new Error(`ticket-features.tsv row ${i + 1}: ticket ${JSON.stringify(row.ticket)} is not a number`);
     if (!CELL.test(row.chosen_cell)) throw new Error(`ticket-features.tsv row ${i + 1}: chosen_cell ${JSON.stringify(row.chosen_cell)} is not a cell`);
     return row;

package/scripts/pull.mjs

@@ -104,7 +104,8 @@
 //                 `behind-issue:#M`, or `paths <p>…`, which scans again and
 //                 asks again. An exclusion is a ledger row.
 //   6  claim      `claim-ticket.sh <N> impl-<N> implementer --apply`.
-//   7  route      `ticket-router.mjs route …`; a router that refuses releases
+//   7  route      `ticket-router.mjs route …`, which routes by the Objective
+//                 the phase-0 receipt records; a router that refuses releases
 //                 the claim, and a release that fails is exit 2 with the claim
 //                 still standing. `--chain-head` is given when a ledger row reads
 //                 `excluded · behind-issue:#<N>`: another open ticket
@@ -957,7 +958,7 @@ class Pull {
       "--impl-row", String(k), ...(head ? ["--chain-head"] : []), "--issue", this.p.issue, "--guard", this.p.guard,
     ];
     const r = this.script("route", "ticket-router.mjs", args);
-    const m = r.status === 0 ? /^POLICY=(\S+) CELL=(\S+) DRAW=(\S+) STRATUM=(\S+) REASON=(\S+)$/m.exec(r.stdout) : null;
+    const m = r.status === 0 ? /^POLICY=(\S+) CELL=(\S+) DRAW=(\S+) STRATUM=(\S+) OBJECTIVE=(\S+) REASON=(\S+)$/m.exec(r.stdout) : null;
     if (m === null) {
       const said = r.status === 0 ? `printed no routing line: ${r.stdout}` : withText(`refused (${r.how})`, r);
       const rel = this.script("release", "release-ticket.sh", [String(st.ticket), st.member, "implementer", "--apply"]);
@@ -969,7 +970,7 @@ class Pull {
       st.outcome = { exit: 2, reason: `router ${said}`, at: now() };
       return this.stop(`ticket-router.mjs ${said}\nits claim is released`);
     }
-    st.route = { line: m[0], cell: m[2], draw: m[3], reason: m[5], implRow: k, chainHead: head };
+    st.route = { line: m[0], cell: m[2], draw: m[3], reason: m[6], implRow: k, chainHead: head };
     st.stage = "row";
     return null;
   }

package/scripts/router-table.json

@@ -10,7 +10,12 @@
   ],
   "burn_in": true,
   "rows": {
-    "*": "slow-high"
+    "cost": {
+      "*": "slow-high"
+    },
+    "speed": {
+      "*": "slow-high"
+    }
   },
   "classifier": {
     "b": null,
@@ -18,11 +23,21 @@
   },
   "estimates": {},
   "reasons": {
-    "*": {
-      "cell": "slow-high",
-      "reason": "unjudged",
-      "cells": {},
-      "pairs": []
+    "cost": {
+      "*": {
+        "cell": "slow-high",
+        "reason": "unjudged",
+        "cells": {},
+        "pairs": []
+      }
+    },
+    "speed": {
+      "*": {
+        "cell": "slow-high",
+        "reason": "unjudged",
+        "cells": {},
+        "pairs": []
+      }
     }
   },
   "guard": {

package/scripts/ticket-router.mjs

@@ -3,26 +3,28 @@
 // for dispatch and for the offline fit, because the stratum rule is the one
 // function that must never read differently between the two.
 //
-//   route [--session <dir|id>] --ticket <N> --arm A|B --impl-row <k>
-//         --issue <issue.json> --guard <cost-guard.json>
+//   route [--session <dir|id>] [--objective cost|speed] --ticket <N> --arm A|B
+//         --impl-row <k> --issue <issue.json> --guard <cost-guard.json>
 //         [--sizing <sizing.json>] [--table <router-table.json>]
 //         [--chain-head] [--pending <tsv>]
 //     Prints one line, `POLICY=<cell> CELL=<cell> DRAW=<k/K|->
-//     STRATUM=<light|heavy|unknown> REASON=<reason>`, and appends the Pull's
+//     STRATUM=<light|heavy|unknown> OBJECTIVE=<cost|speed> REASON=<reason>`,
+//     routing by the objective's row set, and appends the Pull's
 //     ticket-features row to the pending TSV (by default
 //     `ticket-features.pending.tsv` beside `--guard`, in the run's `.fleet/`). Exit 0 on
 //     every data degradation — a missing or unreadable issue, sizing or guard
 //     file degrades the line, never the exit. Exit 2 only on a usage error or
 //     an unreadable/invalid table: the caller does not dispatch then. With no
 //     `--session`, the session is the one the phase-0 receipt
-//     `.fleet/phase0.json` records; a receipt that records none is exit 2.
+//     `.fleet/phase0.json` records, and with no `--objective` the objective
+//     is; a receipt that records none is exit 2.
 //   fit --table <json> --features <tsv> --members <tsv> --verdicts <tsv>
 //       --guard <cost-guard.json> --commit <rev> [--due]
 //     Re-fits the table from the three TSVs as committed at `--commit` (read
 //     with `git show`, never from the working tree) and the guard, and
 //     rewrites `--table`, recording the commit's sha as `fitted_commit`, then
-//     prints the fit and one line per row: its cell and the reason, then each
-//     candidate's verdict and range. The TSV flags name paths inside the
+//     prints the fit and one line per row of each objective's set: its cell
+//     and the reason, then each candidate's verdict and range. The TSV flags name paths inside the
 //     repository that holds them. With
 //     `--due`, writes nothing and prints `DUE=yes|no MERGED=<n>/<N>`: whether
 //     N merged PRs have landed since `fitted_commit`, counting the features
@@ -47,7 +49,7 @@ import { isCLI } from "./is-cli.mjs";
 import { gitEnv } from "./git-env.mjs";
 import { makeDie, defineFlags } from "./arg.mjs";
 import { CELL, POLICY_CELL, drawCell, parseMember } from "./ledger-grammar.mjs";
-import { sessionFromReceipt } from "./phase0-receipt.mjs";
+import { OBJECTIVES, objectiveFromReceipt, sessionFromReceipt } from "./phase0-receipt.mjs";
 import { parseTsv as parseMemberTsv } from "./member-outcomes.mjs";
 import {
   AttributionError, FEATURE_COLUMNS, TRIP_POINTS, attribute, bootUnit, bootstrapDiffCI, generations, parseFeatures, tally, underFloor,
@@ -181,15 +183,29 @@ export function ruleStratum({ brief_chars, criteria }) {
 /** A parsed table, or an Error saying why it is not one. */
 export function validateTable(t) {
   const bad = (why) => new Error(`router table: ${why}`);
-  if (t === null || typeof t !== "object" || Array.isArray(t)) return bad("not a JSON object");
+  const isObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+  if (!isObject(t)) return bad("not a JSON object");
   if (!Array.isArray(t.cells) || t.cells.length === 0) return bad("`cells` is not a non-empty array");
   for (const c of t.cells) if (typeof c !== "string" || !CELL.test(c)) return bad(`\`cells\` holds ${JSON.stringify(c)}, not a cell token`);
   if (new Set(t.cells).size !== t.cells.length) return bad("`cells` repeats a cell");
-  if (t.rows === null || typeof t.rows !== "object" || Array.isArray(t.rows)) return bad("`rows` is not an object");
-  if (!Object.hasOwn(t.rows, "*")) return bad("`rows` has no `*` row");
-  for (const [k, v] of Object.entries(t.rows)) {
-    if (k !== "*" && !STRATA.includes(k)) return bad(`\`rows\` key ${JSON.stringify(k)} is not \`*\` or a stratum`);
-    if (typeof v !== "string" || !CELL.test(v)) return bad(`\`rows.${k}\` is ${JSON.stringify(v)}, not a cell token`);
+  // `rows` and `reasons` are each keyed by objective, then by `*` or a stratum.
+  for (const field of ["rows", "reasons"]) {
+    if (!isObject(t[field])) return bad(`\`${field}\` is not an object`);
+    const stray = Object.keys(t[field]).find((o) => !OBJECTIVES.includes(o));
+    if (stray !== undefined) return bad(`\`${field}\` key ${JSON.stringify(stray)} is not an objective (${OBJECTIVES.join(", ")})`);
+    for (const o of OBJECTIVES) {
+      const set = t[field][o];
+      if (!isObject(set)) return bad(`\`${field}.${o}\` is not an object`);
+      for (const k of Object.keys(set)) {
+        if (k !== "*" && !STRATA.includes(k)) return bad(`\`${field}.${o}\` key ${JSON.stringify(k)} is not \`*\` or a stratum`);
+      }
+    }
+  }
+  for (const o of OBJECTIVES) {
+    if (!Object.hasOwn(t.rows[o], "*")) return bad(`\`rows.${o}\` has no \`*\` row`);
+    for (const [k, v] of Object.entries(t.rows[o])) {
+      if (typeof v !== "string" || !CELL.test(v)) return bad(`\`rows.${o}.${k}\` is ${JSON.stringify(v)}, not a cell token`);
+    }
   }
   if (typeof t.burn_in !== "boolean") return bad("`burn_in` is not a boolean");
   if (!Number.isInteger(t.stage) || t.stage < 1) return bad("`stage` is not a positive integer");
@@ -204,9 +220,13 @@ export function validateTable(t) {
   return t;
 }
 
-/** Arm B runs only once a classifier has passed its gate and some row is not the default. */
-export function bArmLive(table) {
-  return table.classifier.b !== null && Object.values(table.rows).some((c) => c !== POLICY_CELL);
+/**
+ * Arm B runs only once a classifier has passed its gate and some row of the
+ * run's own objective's set is not the default: it decides a paid classifier
+ * call for one Pull, which the other set's rows never route.
+ */
+export function bArmLive(table, objective) {
+  return table.classifier.b !== null && Object.values(table.rows[objective]).some((c) => c !== POLICY_CELL);
 }
 
 const rowFor = (rows, stratum) => rows[stratum] ?? rows["*"];
@@ -253,10 +273,14 @@ export function sessionDate(session) {
 }
 
 /**
- * One Pull's routing. Pure: every input is already read.
+ * One Pull's routing, by `objective`'s row set. Pure: every input is already
+ * read. The exploration draw ignores the objective: it leaves out the cell
+ * the `cost` set routes the Pull to — by the sizing when arm B is live for
+ * the `cost` set, whichever set routes the Pull — so a Pull draws the same
+ * cell under both.
  * @returns {{ line: string, row: Record<string,string> }}
  */
-export function route({ session, ticket, arm, implRow, chainHead = false, issue, sizing = null, guard, table, now = Date.now() }) {
+export function route({ session, ticket, arm, implRow, chainHead = false, issue, sizing = null, guard, table, objective, now = Date.now() }) {
   let reason = null;
   const degrade = (r) => { reason ??= r; };
 
@@ -270,9 +294,10 @@ export function route({ session, ticket, arm, implRow, chainHead = false, issue,
   let sizingSrc = "rule";
   let sizingPre = "";
   let routerUsd = "";
-  const b = arm === "B" && bArmLive(table);
+  const sized = arm === "B" ? readSizing(sizing, table.classifier) : null;
+  const b = arm === "B" && bArmLive(table, objective);
   if (b) {
-    const s = readSizing(sizing, table.classifier);
+    const s = sized;
     if (s === null) {
       degrade("no-sizing");
       stratum = "unknown";
@@ -282,8 +307,11 @@ export function route({ session, ticket, arm, implRow, chainHead = false, issue,
     }
   }
 
-  let policy = rowFor(table.rows, ruleS);
-  let base = b ? rowFor(table.rows, stratum) : policy;
+  const rows = table.rows[objective];
+  let policy = rowFor(rows, ruleS);
+  let base = b ? rowFor(rows, stratum) : policy;
+  const costB = arm === "B" && bArmLive(table, "cost");
+  let drawBase = rowFor(table.rows.cost, costB ? sized?.stratum ?? "unknown" : ruleS);
   let cell;
   let draw = "-";
   if (guard === null) {
@@ -298,10 +326,11 @@ export function route({ session, ticket, arm, implRow, chainHead = false, issue,
       if (tripped.has(policy)) policy = POLICY_CELL;
       if (tripped.has(base)) base = POLICY_CELL;
     }
+    if (tripped.has(drawBase)) drawBase = POLICY_CELL;
     cell = base;
     const exploring = table.burn_in || (implRow % EXPLORE_EVERY === 0 && !chainHead);
     if (exploring) {
-      const policyCell = table.burn_in ? null : base;
+      const policyCell = table.burn_in ? null : drawBase;
       if (table.cells.some((c) => c !== policyCell && tripped.has(c))) degrade("guard-tripped");
       const d = drawCell({ session, ticket, policyCell, cells: table.cells.filter((c) => !tripped.has(c)) });
       if (d.K > 0) {
@@ -315,9 +344,9 @@ export function route({ session, ticket, arm, implRow, chainHead = false, issue,
   const row = {
     run_date: sessionDate(session), session, agent: `impl-${ticket}`, ticket: String(ticket),
     policy_cell: policy, chosen_cell: cell, exploration_draw: draw === "-" ? "" : draw,
-    sizing_src: sizingSrc, sizing_pre: sizingPre, router_usd: routerUsd, ...m,
+    sizing_src: sizingSrc, sizing_pre: sizingPre, router_usd: routerUsd, ...m, objective,
   };
-  return { line: `POLICY=${policy} CELL=${cell} DRAW=${draw} STRATUM=${stratum} REASON=${reason}`, row };
+  return { line: `POLICY=${policy} CELL=${cell} DRAW=${draw} STRATUM=${stratum} OBJECTIVE=${objective} REASON=${reason}`, row };
 }
 
 export function formatFeatureRow(row) {
@@ -393,95 +422,140 @@ function estimate(units, order) {
   return { estimates, pulls };
 }
 
+// What each objective's judge reads and says: the figure per merged PR it
+// minimises (`estimate()`'s name and its bootstrap metric), its verdict for a
+// candidate past the margin and for one with no reliable difference, the key
+// a pair names its better side by, and its reasons for a winner every other
+// qualifier was reliably worse than and for one ahead on the figure.
+const JUDGE = Object.freeze({
+  cost: {
+    figure: "usd_per_merged", metric: "usd", over: "too-dear", unreliable: "not-reliably-cheaper",
+    better: "cheaper", reliably: "reliably-cheaper", ahead: "lower-usd",
+  },
+  speed: {
+    figure: "minutes_per_merged", metric: "minutes", over: "too-slow", unreliable: "not-reliably-faster",
+    better: "faster", reliably: "reliably-faster", ahead: "fewer-minutes",
+  },
+});
+
+// A row's record with no cell: a fresh object each time, since judge() fills
+// in `cells` and `pairs`.
+const unjudged = () => ({ cell: null, reason: "unjudged", cells: {}, pairs: [] });
+
 /**
- * One row's cell — the `*` row's or a stratum's — and why. The quality floor
- * is held twice: pooled by the guard, whose trip takes a cell out of every row
- * and out of the exploration draw, and per row by the fit, which refuses a
- * cell under the floor that row alone. Every figure read is the cell's newest
- * generation's, the default cell's included. `est` and `pulls` are the row's
- * `estimate()` figures and counted Pulls.
+ * One row's cell under one objective — the `*` row's or a stratum's — and
+ * why. The quality floor is held twice: pooled by the guard, whose trip takes
+ * a cell out of every row and out of the exploration draw, and per row by the
+ * fit, which refuses a cell under the floor that row alone. The floor is
+ * measured against the default cell under both objectives. Every figure read
+ * is the cell's newest generation's, the default cell's included. `est` and
+ * `pulls` are the row's `estimate()` figures and counted Pulls; `baseCell` is
+ * the cell the row holds unless a candidate qualifies: the default cell under
+ * `cost`, the `cost` row's cell under `speed`. The figure is $ per merged PR
+ * under `cost` and minutes of work time per merged PR under `speed`.
  *
- * A candidate is a cell of `cells` other than the default cell. Its `verdict`,
- * the first that applies: `tripped` by the guard; `too-few`, under MIN_N
- * merged PRs in the row; `under-floor` against the default cell there;
- * `too-dear`, above ADOPT_RATIO of the default cell's $ per merged PR;
- * `not-reliably-cheaper`, its `range` does not lie wholly below zero (its
- * upper end, as `bootstrapDiffCI` returns it, is not below zero) or there is
- * none; else it `qualifies`. A candidate past `too-few` records whether it is
- * `under_floor`, the floor's `bar` (the default cell's fail rate plus
- * TRIP_POINTS, rounded as a fail rate is, for reading only: the floor compares
- * counts) and its `range`, the bootstrap 95% range of (candidate − default
- * cell) $ per merged PR over those Pulls; the others record null for each.
+ * A candidate is a cell of `cells` other than the base. Its `verdict`, the
+ * first that applies: `tripped` by the guard; `too-few`, under MIN_N merged
+ * PRs in the row; `under-floor` against the default cell there; `too-dear`
+ * (`cost`) or `too-slow` (`speed`), above ADOPT_RATIO of the base's figure;
+ * `not-reliably-cheaper` or `not-reliably-faster`, its `range` does not lie
+ * wholly below zero (its upper end, as `bootstrapDiffCI` returns it, is not
+ * below zero) or there is none; else it `qualifies`. A candidate past
+ * `too-few` records whether it is `under_floor`, the floor's `bar` (the
+ * default cell's fail rate plus TRIP_POINTS, rounded as a fail rate is, for
+ * reading only: the floor compares counts) and its `range`, the bootstrap 95%
+ * range of (candidate − base) figure over those Pulls; the others record null
+ * for each.
  *
- * Several qualifiers: each pair records the range of (the cheaper by $ per
- * merged PR, else by name − the other) in `pairs`, and a qualifier another
- * is reliably cheaper than is dropped. Among the rest the lower fail rate,
- * compared in counts, wins, then the lower $ per merged PR, then the name.
+ * Several qualifiers: each pair records the range of (the better by the
+ * figure, else by name − the other) in `pairs`, naming the better side
+ * `cheaper` or `faster`, and a qualifier another is reliably better than is
+ * dropped. Among the rest the lower fail rate, compared in counts, wins, then
+ * the lower figure, then the name.
  *
- * `reason`, why the row holds `cell`: `unjudged` (the default cell, or every
- * untripped candidate, is under MIN_N merged PRs; `cell` is null and a
- * stratum follows `*`), `no-qualifier` (the default cell), or, for the
- * winner, `sole-qualifier`, `reliably-cheaper` (every other qualifier was
+ * `reason`, why the row holds `cell`: `unjudged` (the default cell or the
+ * base, or every untripped candidate, is under MIN_N merged PRs; `cell` is
+ * null), `no-qualifier` (the base), or, for the winner, `sole-qualifier`,
+ * `reliably-cheaper` or `reliably-faster` (every other qualifier was
  * dropped), or what put it ahead of the next of the rest: `lower-fail-rate`,
- * `lower-usd` or `name`.
+ * `lower-usd` or `fewer-minutes`, or `name`.
  */
-function judgeRow(est = {}, pulls, cells, tripped) {
-  const record = { cell: null, reason: "unjudged", cells: {}, pairs: [] };
-  const base = est[POLICY_CELL];
-  if (!base || base.merged < MIN_N) return record;
+function judge(objective, est = {}, pulls, cells, tripped, baseCell) {
+  const { figure, metric, over, unreliable, better, reliably, ahead } = JUDGE[objective];
+  const record = unjudged();
+  const floor = est[POLICY_CELL];
+  const base = est[baseCell];
+  if (!floor || floor.merged < MIN_N || !base || base.merged < MIN_N) return record;
   // JSON writes −0 as 0, so a recorded end is 0 either way; `--check` compares the two.
-  const range = (a, b) => bootstrapDiffCI(pulls[a].map(bootUnit), pulls[b].map(bootUnit))?.map((x) => x + 0) ?? null;
+  const units = (c) => pulls[c].map((u) => bootUnit(u, metric));
+  const range = (a, b) => bootstrapDiffCI(units(a), units(b))?.map((x) => x + 0) ?? null;
   const reliablyBelow = (r) => r !== null && r[1] < 0;
-  const bar = round4(base.failed / base.claims + TRIP_POINTS / 100);
+  const bar = round4(floor.failed / floor.claims + TRIP_POINTS / 100);
   const qualifiers = [];
   let judged = false;
   for (const c of cells) {
-    if (c === POLICY_CELL) continue;
+    if (c === baseCell) continue;
     const e = est[c];
     if (tripped.has(c) || !e || e.merged < MIN_N) {
       record.cells[c] = { verdict: tripped.has(c) ? "tripped" : "too-few", under_floor: null, bar: null, range: null };
       continue;
     }
     judged = true;
-    const under = underFloor(e, base);
-    const r = range(c, POLICY_CELL);
+    const under = underFloor(e, floor);
+    const r = range(c, baseCell);
     const verdict = under ? "under-floor"
-      : e.usd_per_merged > ADOPT_RATIO * base.usd_per_merged ? "too-dear"
-        : reliablyBelow(r) ? "qualifies" : "not-reliably-cheaper";
+      : e[figure] > ADOPT_RATIO * base[figure] ? over
+        : reliablyBelow(r) ? "qualifies" : unreliable;
     record.cells[c] = { verdict, under_floor: under, bar, range: r };
     if (verdict === "qualifies") qualifiers.push(c);
   }
   if (!judged) return record;
-  if (qualifiers.length === 0) return { ...record, cell: POLICY_CELL, reason: "no-qualifier" };
+  if (qualifiers.length === 0) return { ...record, cell: baseCell, reason: "no-qualifier" };
 
-  const usd = (c) => est[c].usd_per_merged;
+  const of = (c) => est[c][figure];
   const byName = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
   const failCmp = (a, b) => est[a].failed * est[b].claims - est[b].failed * est[a].claims;
   const named = [...qualifiers].sort(byName);
   const dropped = new Set();
   for (let i = 0; i < named.length; i++) {
     for (let j = i + 1; j < named.length; j++) {
-      const [cheaper, other] = usd(named[j]) < usd(named[i]) ? [named[j], named[i]] : [named[i], named[j]];
-      const r = range(cheaper, other);
-      record.pairs.push({ cheaper, other, range: r });
+      const [win, other] = of(named[j]) < of(named[i]) ? [named[j], named[i]] : [named[i], named[j]];
+      const r = range(win, other);
+      record.pairs.push({ [better]: win, other, range: r });
       if (reliablyBelow(r)) dropped.add(other);
     }
   }
-  // The cheapest qualifier, by $ then name, is never dropped, so the rest is never empty.
-  const [win, next] = named.filter((c) => !dropped.has(c)).sort((a, b) => failCmp(a, b) || usd(a) - usd(b) || byName(a, b));
+  // The best qualifier, by the figure then name, is never dropped, so the rest is never empty.
+  const [win, next] = named.filter((c) => !dropped.has(c)).sort((a, b) => failCmp(a, b) || of(a) - of(b) || byName(a, b));
   const reason = qualifiers.length === 1 ? "sole-qualifier"
-    : next === undefined ? "reliably-cheaper"
+    : next === undefined ? reliably
       : failCmp(win, next) !== 0 ? "lower-fail-rate"
-        : usd(win) !== usd(next) ? "lower-usd" : "name";
+        : of(win) !== of(next) ? ahead : "name";
   return { ...record, cell: win, reason };
 }
 
+/** A `cost` row: `judge()` from the default cell, by $ per merged PR. */
+function judgeRow(est, pulls, cells, tripped) {
+  return judge("cost", est, pulls, cells, tripped, POLICY_CELL);
+}
+
+/** A `speed` row: `judge()` from the `cost` row's cell, by minutes of work time per merged PR. */
+function judgeSpeedRow(est, pulls, cells, tripped, costCell) {
+  return judge("speed", est, pulls, cells, tripped, costCell);
+}
+
 /**
  * The re-fit table. `guard` is `{ tripped, n, window_start }` (readGuard's
  * shape); `commit` is the sha of the commit the inputs were read from, or null
- * for the empty corpus before any fit. `reasons` holds `judgeRow()`'s record
- * for `*` and for each stratum with Pulls; a stratum whose record has no cell
- * gets no row and follows `*`, and an unjudged `*` is the default cell.
+ * for the empty corpus before any fit. `rows` and `reasons` hold one set per
+ * objective. `reasons.cost` holds `judgeRow()`'s record for `*` and for each
+ * stratum with Pulls; a stratum whose record has no cell gets no `cost` row
+ * and follows `*`, and an unjudged `*` is the default cell. `reasons.speed`
+ * holds `judgeSpeedRow()`'s record for each row with a `cost` row, from that
+ * row's cell, and an `unjudged` record with no cell for each stratum with no
+ * `cost` row: a row with a `cost` row holds a `speed` row, the base when the
+ * record has no cell, and a stratum with no `cost` row has no `speed` row
+ * and follows `*`.
  */
 export function fitTable({ prior, features, members, verdicts, guard, commit = null }) {
   const window = guard.window_start ?? prior.window_start ?? null;
@@ -492,15 +566,26 @@ export function fitTable({ prior, features, members, verdicts, guard, commit = n
   let { stage, cells } = prior;
   cells = [...cells];
   const star = judgeRow(estimates["*"], pulls["*"], cells, tripped);
-  const rows = { "*": star.cell ?? POLICY_CELL };
-  const reasons = { "*": { ...star, cell: rows["*"] } };
+  const rows = { cost: { "*": star.cell ?? POLICY_CELL }, speed: {} };
+  const reasons = { cost: { "*": { ...star, cell: rows.cost["*"] } }, speed: {} };
   for (const s of STRATA) {
     if (!estimates[s]) continue;
-    reasons[s] = judgeRow(estimates[s], pulls[s], cells, tripped);
-    if (reasons[s].cell !== null) rows[s] = reasons[s].cell;
+    reasons.cost[s] = judgeRow(estimates[s], pulls[s], cells, tripped);
+    if (reasons.cost[s].cell !== null) rows.cost[s] = reasons.cost[s].cell;
+  }
+  for (const s of Object.keys(reasons.cost)) {
+    const costCell = rows.cost[s];
+    if (costCell === undefined) {
+      reasons.speed[s] = unjudged();
+      continue;
+    }
+    const record = judgeSpeedRow(estimates[s], pulls[s], cells, tripped, costCell);
+    rows.speed[s] = record.cell ?? costCell;
+    reasons.speed[s] = { ...record, cell: rows.speed[s] };
   }
   const atN = (c) => (guard.n[c] ?? 0) >= MIN_N;
-  if (stage === 1 && cells.every(atN) && (rows["*"] !== POLICY_CELL || cells.some((c) => tripped.has(c)))) {
+  const adopted = Object.values(rows).some((set) => set["*"] !== POLICY_CELL);
+  if (stage === 1 && cells.every(atN) && (adopted || cells.some((c) => tripped.has(c)))) {
     stage = 2;
     for (const { cell, survives } of STAGE2) {
       if (!cells.includes(cell) && cells.includes(survives) && !tripped.has(survives)) cells.push(cell);
@@ -546,14 +631,15 @@ function cellCounts(estimates) {
     .join(", ") || "none";
 }
 
-// One line per row the fit judged or skipped: its cell (`-` for a stratum
-// that follows `*`) and its reason, then each candidate's verdict and range.
+// One line per row the fit judged or skipped, per objective: its cell (`-`
+// for a stratum that follows `*`) and its reason, then each candidate's
+// verdict and range.
 function rowLines(reasons) {
   const range = (r) => (r === null ? "" : ` [${r.map((x) => x.toFixed(2)).join(", ")}]`);
-  return Object.entries(reasons).map(([s, r]) => {
+  return Object.entries(reasons).flatMap(([o, set]) => Object.entries(set).map(([s, r]) => {
     const cells = Object.entries(r.cells).map(([c, x]) => `${c} ${x.verdict}${range(x.range)}`).join(", ");
-    return `${NAME}: row ${s} ${r.cell ?? "-"} ${r.reason}${cells ? ` (${cells})` : ""}\n`;
-  }).join("");
+    return `${NAME}: row ${o} ${s} ${r.cell ?? "-"} ${r.reason}${cells ? ` (${cells})` : ""}\n`;
+  })).join("");
 }
 
 // ---------------------------------------------------------------------------
@@ -598,7 +684,7 @@ function main() {
   const die = makeDie(NAME);
   const F = defineFlags(die, {
     flags: {
-      session: "value", ticket: "value", arm: "value", "impl-row": "value", issue: "value",
+      session: "value", objective: "value", ticket: "value", arm: "value", "impl-row": "value", issue: "value",
       sizing: "value", guard: "value", table: "value", pending: "value", "chain-head": "bool",
       features: "value", members: "value", verdicts: "value", commit: "value", check: "bool", due: "bool",
     },
@@ -612,7 +698,7 @@ function main() {
     die("usage: ticket-router.mjs route … | fit … | --check … — exactly one mode");
   }
   const allowed = {
-    route: ["session", "ticket", "arm", "impl-row", "issue", "sizing", "guard", "table", "pending", "chain-head"],
+    route: ["session", "objective", "ticket", "arm", "impl-row", "issue", "sizing", "guard", "table", "pending", "chain-head"],
     fit: ["table", "features", "members", "verdicts", "guard", "commit", "due"],
     check: ["check", "table", "features", "members", "verdicts"],
   }[mode];
@@ -643,9 +729,16 @@ function main() {
       try { sessionArg = sessionFromReceipt(); } catch (e) { die(e.message); }
     }
     const session = basename(sessionArg.replace(/\/+$/, ""));
+    // `--objective` omitted is the one the receipt records, likewise.
+    let objective = F.arg("objective");
+    if (objective === null) {
+      try { objective = objectiveFromReceipt(); } catch (e) { die(e.message); }
+    } else if (!OBJECTIVES.includes(objective)) {
+      die(`--objective ${objective} is not ${OBJECTIVES.join(" or ")}`);
+    }
     const { line, row } = route({
       session, ticket: Number(ticket), arm, implRow: Number(implRowArg), chainHead: F.has("chain-head"),
-      issue: readJson(issuePath), sizing: readJson(F.arg("sizing")), guard: readGuard(readJson(guardPath)), table,
+      issue: readJson(issuePath), sizing: readJson(F.arg("sizing")), guard: readGuard(readJson(guardPath)), table, objective,
     });
     const pending = F.arg("pending") ?? join(dirname(guardPath), "ticket-features.pending.tsv");
     // The header decision and the append are not atomic and take no lock. That is

package/scripts/tier-roles.mjs

@@ -27,12 +27,12 @@
 //       definition never declared, and every row the definition ran would
 //       be inadmissible. The one exception is an implementer definition
 //       whose cell the router never selects (not in the router table's
-//       `cells`, in none of its `rows` values, and not the policy cell): a
-//       cell can be defined before the router may pick it, so its mismatch
-//       is a notice. The router table is `router-table.json` beside this
-//       script, or the file `--table <path>` names; one that cannot be read,
-//       or that lacks a `cells` array or a `rows` object of cell names,
-//       refuses. A target the catalog does not list cannot be checked, so it
+//       `cells`, in no row of either objective's `rows` set, and not the
+//       policy cell): a cell can be defined before the router may pick it,
+//       so its mismatch is a notice. The router table is `router-table.json`
+//       beside this script, or the file `--table <path>` names; one that
+//       cannot be read, or that lacks a `cells` array or a `rows` object of
+//       row sets of cell names, refuses. A target the catalog does not list cannot be checked, so it
 //       fails too;
 //   (e) `modelRoles.slow`/`modelRoles.task` resolving to the same model is
 //       flagged as a notice — legal, but every `slow-*` cell then measures
@@ -139,17 +139,20 @@ export function implementerCell(file) {
 }
 
 // The cells the router can select from a parsed router table: the pool it
-// explores (`cells`), the cell each stratum's row names (`rows` values) and the
-// policy cell, which every Pull falls back to whatever the table says. An
-// Error saying why when the table lacks a `cells` array of names or a `rows`
-// object of names — a table that cannot be read must refuse, never quietly
-// make every cell non-routable.
+// explores (`cells`), the cell each row of each objective's set names (`rows`
+// values) and the policy cell, which every Pull falls back to whatever the
+// table says. An Error saying why when the table lacks a `cells` array of
+// names or a `rows` object of row sets of names — a table that cannot be read
+// must refuse, never quietly make every cell non-routable.
 export function routableCells(table) {
   const bad = (why) => new Error(`router table: ${why}`);
   if (!isJsonObject(table)) return bad("not a JSON object");
   if (!Array.isArray(table.cells) || !table.cells.every((c) => typeof c === "string")) return bad("`cells` is not an array of cell names");
-  if (!isJsonObject(table.rows) || !Object.values(table.rows).every((c) => typeof c === "string")) return bad("`rows` is not an object of cell names");
-  return new Set([POLICY_CELL, ...table.cells, ...Object.values(table.rows)]);
+  const sets = isJsonObject(table.rows) ? Object.values(table.rows) : null;
+  if (sets === null || !sets.every((set) => isJsonObject(set) && Object.values(set).every((c) => typeof c === "string"))) {
+    return bad("`rows` is not an object of row sets of cell names");
+  }
+  return new Set([POLICY_CELL, ...table.cells, ...sets.flatMap((set) => Object.values(set))]);
 }
 
 // Tolerates a role value written without its provider prefix — omp's

package/skills/run-team/SKILL.md

@@ -1,15 +1,15 @@
 ---
 name: run-team
 description: Run an agent fleet — implementers, reviewers, one merge bot — over the ready-for-agent queue. Invoke-only; the fleet writes to a live repo and must never start unasked.
-argument-hint: "[in-flight]"
+argument-hint: "[in-flight] [cost|speed]"
 disable-model-invocation: true
 ---
 
 Run `next-ticket`, `review-and-fix`, `run-merge-bot` as one fleet. You are the
 **controller**, in the main thread, never a member.
 
-`$ARGUMENTS` = `[in-flight]`, optional, one positive integer, default 5: the
-In-flight bound, the most tickets between Claim and merge at once.
+`$ARGUMENTS` = `[in-flight] [cost|speed]`, both optional: the In-flight bound,
+a positive integer, default 5, and the Objective, default `cost`.
 Merge bot is at most one, not configurable.
 
 The war story behind a rule ending `See references/<file>` lives in that file; load
@@ -40,10 +40,10 @@ Nothing in this phase, or in any later one, asks the maintainer which tickets to
 0. **Once per run, before anything else.** Run phase 0 from a Python eval
    cell in this main checkout, without `--session`:
    `subprocess.run([os.path.expanduser("~/.fleet/bin/fleet-run"),
-   "phase0.mjs", …], stderr=subprocess.STDOUT)`. Add `--in-flight <n>` when
-   `$ARGUMENTS` gave one, `--plugin-checkout <dir>` when this workspace tracks
-   no `plugin/…` of its own, `--spend-dir <dir>` to name the directory the
-   cockpit's spend panel reads, and `--workflow <name>` or `--declare-no-ci`
+   "phase0.mjs", …], stderr=subprocess.STDOUT)`. Add `--in-flight <n>` and
+   `--objective <o>` as `$ARGUMENTS` gave them, `--plugin-checkout <dir>` when
+   this workspace tracks no `plugin/…` of its own, `--spend-dir <dir>` for the
+   spend panel, and `--workflow <name>` or `--declare-no-ci`
    when the repository has no workflow named CI. Its steps and receipt: See
    references/phase-0.md. Dispatch nothing before it exits 0. Exit 4 is a
    step that needs you: act on each `NEED` line below, then run it again. Once

package/skills/run-team/references/phase-0.md

@@ -14,6 +14,13 @@ it — `~/.omp/agent/sessions/<encoded-cwd>`, which holds every session of the
 checkout — names no session: phase 0 exits 2 naming the path and where it
 came from, and writes no receipt.
 
+`--objective cost|speed` is the run's Objective, which phase 0 records in its
+receipt, `cost` when it is not given; the router routes every Pull of the run
+by it. It is fixed for the run: a resumed receipt keeps the one it records —
+`cost` when it records none — and a resume whose `--objective` names the
+other exits 2 naming both, leaving the receipt as it was. A resumed receipt
+recording anything other than `cost` or `speed` exits 3 naming the value.
+
 Exit 3 is a step that failed: its line carries the refusal, so fix the cause
 and run it again.
 

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

@@ -249,7 +249,7 @@ terminating in exactly one dispatch or an empty shortlist:
 7. **Route, row, then dispatch** — `~/.fleet/bin/fleet-run ticket-router.mjs route
    --session <session> --ticket <N> --arm <A|B> --impl-row <k>[ --chain-head] --issue
    <scratch>/impl-<N>/issue.json --guard .fleet/cost-guard.json` prints
-   `POLICY=… CELL=… DRAW=… STRATUM=… REASON=…` (the router's arguments paragraph below the list
+   `POLICY=… CELL=… DRAW=… STRATUM=… OBJECTIVE=… REASON=…` (the router's arguments paragraph below the list
    says what each argument is); then `ledger.mjs row <N> "impl-<N>[ · tier=<CELL>][ · route=<REASON>]"`,
    `tier=<CELL>` exactly when `DRAW` is not `-`; then the dispatch at once: claim
    what you are about to dispatch; dispatch what you have just claimed. Router
@@ -263,7 +263,9 @@ row 5k and every row after it carry no `tier=`), that row's number;
 `--chain-head` marks a ticket another open ticket sequences after, which is
 what rolls it. `--arm` is `A` for an even ticket number and `B` for an odd
 one; a B Pull routes exactly as an A one until the table opens arm B.
-`--session` is this run's own session directory. The printed line is the
+`--session` is this run's own session directory. The router routes by the
+row set of the run's Objective, `OBJECTIVE`, which it reads off the phase-0
+receipt. The printed line is the
 whole routing decision — never re-derive `CELL` from the table, the guard or
 this paragraph. A missing or unreadable `.fleet/cost-guard.json` routes the
 default cell only (`REASON=guard-missing`), burn-in included, and `REASON`
@@ -429,7 +431,8 @@ controller's probe could not look.
 rows in `.fleet/ledger.md` at Pull time; the Pull that creates row 5, 10, 15 …
 is an Exploration Pull, and the router draws its cell: `k = 1 +
 (sha256("<session>\t<ticket>")[0:8] mod K)` over `router-table.json`'s
-`cells` minus the policy cell, in token order. While the table's `burn_in` is
+`cells` minus the policy cell, in token order. Under either Objective that
+policy cell is the `cost` row set's, so the draw is the same under both. While the table's `burn_in` is
 true every Pull draws, over every cell, the policy cell included. An
 Exploration Pull records `tier=<cell>` in the row, and a replacement inherits the row's tier —
 written at the Pull's row step, ahead of `ledger.mjs dispatch`, which reads it