pi-gauntlet 5.20.0 → 5.22.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## v5.22.0 - 2026-09-26
+
+### Added
+
+- `gauntlet-spec-index` gains a `state` column after `shipped_at` (`superseded` for a `- fully` banner directly under the title, `live` otherwise) and a repeatable `--exclude <path>` flag. `/skill:brainstorming` runs a second predecessor query at spec self-review from the finished spec's title, goal, and H2 headings and lists new `live` candidates at the review gate; the scout composes its first query from the ticket title and body.
+
+### Changed
+
+- `gauntlet-spec-index` applies a confidence rule before `--limit`: only terms in fewer than half the specs count as evidence, a row needs two distinct evidence terms in title or goal, and rows under half the best live score are dropped, so queries with no real match return zero rows. Live rows sort before superseded rows. The cache schema is version 2 and rebuilds on first use.
+
+## v5.21.0 - 2026-09-26
+
+### Added
+
+- Council telemetry records chair activity and per-member severity/disposition counts in `derived.council`; `gauntlet-performance` groups council results by roster, reports chair summaries and contribution flags after five runs, and exposes the aggregates in JSON. The performance skill includes a council assessment in its reply.
+
+### Changed
+
+- `roasting-the-spec` audit lines and brainstorming's gate template carry `[<severity>]` and `raised-by: [...]` on every `Applied:`/`Deferred:`/`Rejected:` item, one item per line, `none` for an empty list. `gauntlet-performance` is split into section modules under `src/bins/performance/`; existing `runs` and `by version` output is unchanged.
+
 ## v5.20.0 - 2026-09-26
 
 ### Changed

package/README.md

@@ -69,7 +69,7 @@ Everything between gate 1 and gate 2 - task breakdown, implementation, both revi
 
 pi-gauntlet ships three kinds of pieces, layered on top of pi-cohort's dispatch:
 
-- **20 skills** - the workflow logic. Thirteen activate automatically when pi sees the matching kind of task, and each one gates the next: `brainstorming`, `writing-plans`, `roasting-the-spec`, `test-driven-development`, `subagent-driven-development`, `dispatching-parallel-agents`, `verification-before-completion`, `requesting-code-review`, `receiving-code-review`, `using-git-worktrees`, `finishing-a-development-branch`, `writing-skills`, `linear` (reads/searches/comments on/manages Linear tickets via the `linearis` CLI; owns all linearis mechanics and the `## Issue tracker` overrides schema; tracker-facing skills route to it). Seven more are explicit-invocation-only (`disable-model-invocation: true`): `shape-ticket` creates or repairs one tracker issue per run against a Context/Problem/Idea/Acceptance-Criteria template, gated by an AC integrity check, a cheap council roast, and a single human-confirmed write - run it with `/skill:shape-ticket`. `gatekeep-pr` is consent-gated pre-merge verification of a PR against its issue - read-only gathering, verification evidence resolved CI-first (green checks on the exact assessed head count as evidence; the project's verification command runs only as fallback), a rubric-based review, then a deterministic authorship-aware menu with stable finding IDs (P#/L#/C#/F#) and numbered pre-composed courses (fixes execute as a single parallel-safe wave: one gate run, one re-review, one push); nothing mutates (fixes, pushes, reviews, merges) until you pick a row - run it with `/skill:gatekeep-pr <pr>`. `check-delivery` is a post-merge detective control: proves an issue actually shipped (default-branch landing, delivery target, per-AC evidence) before its tracker status advances; it never writes a terminal status - run it with `/skill:check-delivery <ref>`. `chase-bug` is human-only bug triage: read-only root-cause discovery to an evidenced verdict menu (real bug -> ticket/brainstorm/hotfix/respond; five negative verdicts), then a gated response to the reporter for addressable origins (GitHub issue / tracker ticket) and a rendered verdict summary otherwise - it never fixes during triage; the hotfix row hands off to `skills/chase-bug/hotfix.md` after the menu - run it with `/skill:chase-bug`. `gauntlet-performance` reads the committed run telemetry (current repo by default, `--dir <path>` adds others) through the parse-only `gauntlet-performance` CLI and answers with one example-led recommendation, 3-5 cornerstone numbers, and a menu of at most three actions (render a report file, open the recommendation as a ticket via `shape-ticket`, drill into one run); it writes nothing unless you pick render - run it with `/skill:gauntlet-performance [--dir <path>]... [--since <version>]`. `gauntlet-handoff` ends a session whose flow a fresh session will continue: it invokes pi-cohort's `handoff` skill (`--out <path>` or `--key <name>`, default key = the run worktree's branch with `/` flattened to `-`, default file `<tmpdir>/pi-handoff/<key>.md`), then appends the gauntlet process-state section (phase/plan tracker status) per the shared contract `skills/gauntlet-resume/reference/brief-contract.md` - run it with `/skill:gauntlet-handoff [--out <path> | --key <name>]`. `gauntlet-resume` is the only way back into an interrupted flow from a fresh session: it takes a `gauntlet-handoff` brief (a file path, pasted text, or - with no arguments - a pick from the briefs under `<tmpdir>/pi-handoff/`), a bare worktree that already holds a spec, or a spec tracked on main under a configured spec dir (a spec seed: it creates or reuses the worktree through `using-git-worktrees` and pins the spec), restores phase/plan tracker state through the legal arming sequence (`start brainstorm`, `skip` with `resume:` reasons, `plan_check` before implement-or-later), and never infers approval from artifacts - run it with `/skill:gauntlet-resume [<brief-file> | <spec>.md | <worktree-name-or-path>]`.
+- **20 skills** - the workflow logic. Thirteen activate automatically when pi sees the matching kind of task, and each one gates the next: `brainstorming`, `writing-plans`, `roasting-the-spec`, `test-driven-development`, `subagent-driven-development`, `dispatching-parallel-agents`, `verification-before-completion`, `requesting-code-review`, `receiving-code-review`, `using-git-worktrees`, `finishing-a-development-branch`, `writing-skills`, `linear` (reads/searches/comments on/manages Linear tickets via the `linearis` CLI; owns all linearis mechanics and the `## Issue tracker` overrides schema; tracker-facing skills route to it). Seven more are explicit-invocation-only (`disable-model-invocation: true`): `shape-ticket` creates or repairs one tracker issue per run against a Context/Problem/Idea/Acceptance-Criteria template, gated by an AC integrity check, a cheap council roast, and a single human-confirmed write - run it with `/skill:shape-ticket`. `gatekeep-pr` is consent-gated pre-merge verification of a PR against its issue - read-only gathering, verification evidence resolved CI-first (green checks on the exact assessed head count as evidence; the project's verification command runs only as fallback), a rubric-based review, then a deterministic authorship-aware menu with stable finding IDs (P#/L#/C#/F#) and numbered pre-composed courses (fixes execute as a single parallel-safe wave: one gate run, one re-review, one push); nothing mutates (fixes, pushes, reviews, merges) until you pick a row - run it with `/skill:gatekeep-pr <pr>`. `check-delivery` is a post-merge detective control: proves an issue actually shipped (default-branch landing, delivery target, per-AC evidence) before its tracker status advances; it never writes a terminal status - run it with `/skill:check-delivery <ref>`. `chase-bug` is human-only bug triage: read-only root-cause discovery to an evidenced verdict menu (real bug -> ticket/brainstorm/hotfix/respond; five negative verdicts), then a gated response to the reporter for addressable origins (GitHub issue / tracker ticket) and a rendered verdict summary otherwise - it never fixes during triage; the hotfix row hands off to `skills/chase-bug/hotfix.md` after the menu - run it with `/skill:chase-bug`. `gauntlet-performance` reads the committed run telemetry (current repo by default, `--dir <path>` adds others) through the parse-only `gauntlet-performance` CLI and answers with one example-led recommendation, 3-5 cornerstone numbers, a council assessment when available, and a menu of at most three actions (render a report file, open the recommendation as a ticket via `shape-ticket`, drill into one run); it writes nothing unless you pick render - run it with `/skill:gauntlet-performance [--dir <path>]... [--since <version>]`. `gauntlet-handoff` ends a session whose flow a fresh session will continue: it invokes pi-cohort's `handoff` skill (`--out <path>` or `--key <name>`, default key = the run worktree's branch with `/` flattened to `-`, default file `<tmpdir>/pi-handoff/<key>.md`), then appends the gauntlet process-state section (phase/plan tracker status) per the shared contract `skills/gauntlet-resume/reference/brief-contract.md` - run it with `/skill:gauntlet-handoff [--out <path> | --key <name>]`. `gauntlet-resume` is the only way back into an interrupted flow from a fresh session: it takes a `gauntlet-handoff` brief (a file path, pasted text, or - with no arguments - a pick from the briefs under `<tmpdir>/pi-handoff/`), a bare worktree that already holds a spec, or a spec tracked on main under a configured spec dir (a spec seed: it creates or reuses the worktree through `using-git-worktrees` and pins the spec), restores phase/plan tracker state through the legal arming sequence (`start brainstorm`, `skip` with `resume:` reasons, `plan_check` before implement-or-later), and never infers approval from artifacts - run it with `/skill:gauntlet-resume [<brief-file> | <spec>.md | <worktree-name-or-path>]`.
 - **7 subagent personas** - the specialized child agents the skills dispatch via pi-cohort: `implementer`, `code-reviewer`, `spec-reviewer`, `conformance-reviewer`, `spec-summarizer`, `spec-council-member`, `spec-council-synthesizer`. See [doc/personas.md](./doc/personas.md) for what each one does and why its permissions are scoped the way they are.
 - **4 runtime extensions** - the enforcement layer. `plan-tracker` and `phase-tracker` are tools skills call to track progress (with a TUI widget); `verify-before-ship` is a hook that warns if you push or open a PR without a passing test run since your last edit; a phase-tracker flow guard reminds on implement-phase commits missing spec/code review. In a brainstorming-entered flow, phase-tracker rejects `implement` or `verify` completion while tracker tasks remain pending or in progress; see [its configuration reference](./doc/configuration.md#phase-tracker). phase-tracker also registers `plan_check`, which verifies a plan against its spec and against the grammar in [skills/writing-plans/reference/plan-contract.md](./skills/writing-plans/reference/plan-contract.md), including that each task's `Tests:` commands are selective and never the full suite; a pass stamps the plan for implementation. `telemetry` records one YAML record per gauntlet run (phase timing, models, personas, gate/fix rounds, diff at ship) that ships in the squash beside the spec - it is written only inside a brainstorming-entered flow, kept untracked and git-excluded until `finishing-a-development-branch` seals and commits it once with `gauntlet-telemetry-seal` - and blocks a brainstorm `write` into an already-shipped spec; see [its configuration reference](./doc/configuration.md#telemetry). See [doc/configuration.md](./doc/configuration.md) for the settings each one reads.
 
@@ -137,11 +137,11 @@ Pin an exact release with `npm:pi-gauntlet@X.Y.Z`. See [doc/install-internals.md
 
 ## Spec search index
 
-`gauntlet-spec-index` provides lexical search across `doc/specs/*.md` at the repository root and one service level down. From a repository worktree, run `node <pi-gauntlet-package>/bin/gauntlet-spec-index.mjs --query "<text>" [--limit N]`; it requires Node >=24.15.0, refreshes its FTS5 index on every query, and prints tab-separated `score`, `path`, `service`, `title`, `status`, `shipped_at`, `files`, and `snippet` columns. The `files` column is a `;`-separated list of repo-relative paths the spec's shipped change modified and that still exist in the repository, the literal `missing` when the spec's telemetry record has no `derived.modified_files` list, or blank when there is no readable record or no recorded path remains. The per-worktree cache lives at `.pi/gauntlet/index.sqlite`, and its first creation adds `/.pi/gauntlet/index.sqlite*` to Git's `info/exclude` so the database and SQLite sidecars stay out of `git status`.
+`gauntlet-spec-index` provides lexical search across `doc/specs/*.md` at the repository root and one service level down. From a repository worktree, run `node <pi-gauntlet-package>/bin/gauntlet-spec-index.mjs --query "<text>" [--limit N] [--exclude <repo-relative path>]...`; it requires Node >=24.15.0, refreshes its FTS5 index on every query, and prints tab-separated `score`, `path`, `service`, `title`, `status`, `shipped_at`, `state`, `files`, and `snippet` columns. Rows pass a confidence rule before `--limit` applies: a query term is evidence when it occurs in fewer than half the indexed specs (stem variants of one word count once); query tokens split on word boundaries, so `gauntlet-spec-index` searches as three words; a row is returned only when it matches at least two distinct evidence terms in its `title` or `goal`, and rows scoring below half the best live row's score are dropped. A query with no real match therefore prints the header only and exits 0, and a corpus of two or fewer specs never returns rows. `--exclude` (repeatable) removes a path before the rule runs, so the spec under review never sets the bar. `state` is `superseded` when a `> **Superseded by:** ... - fully` banner sits in the block directly under the title and `live` otherwise; named-section banners and consumer-defined banner syntaxes both read as `live`. Live rows sort before superseded rows, then by score. The `files` column is a `;`-separated list of repo-relative paths the spec's shipped change modified and that still exist in the repository, the literal `missing` when the spec's telemetry record has no `derived.modified_files` list, or blank when there is no readable record or no recorded path remains. The per-worktree cache lives at `.pi/gauntlet/index.sqlite`, and its first creation adds `/.pi/gauntlet/index.sqlite*` to Git's `info/exclude` so the database and SQLite sidecars stay out of `git status`. `/skill:brainstorming` queries the index twice: the scout at gather time from the request, and the main loop at spec-writing from the finished spec's title, goal, and headings, surfacing new `live` candidates at the review gate.
 
 ## Performance digest
 
-`gauntlet-performance` digests telemetry records without judging them: `node <pi-gauntlet-package>/bin/gauntlet-performance.mjs [--dir <repo root or telemetry dir>]... [--since <version>] [--json]` prints a `corpus:` line, one row per run (`run_id`, repo, spec, version, status - `shipped*` when the record has no ship phase - wall, per-phase minutes, tokens, cost, models, dispatches, `fix_round_grants`, reopens, conformance loops, reviewer findings, council dispatches), a `by version` block of p50/max over shipped, non-truncated runs, and `skipped:` lines for files it could not use. Default corpus is the current repo's telemetry dir; each `--dir` adds a repo root (its own `telemetry.dir` setting is honoured) or a bare telemetry dir. `--since` compares versions numerically. Exit 0 always except usage errors. `/skill:gauntlet-performance` is the reasoning layer on top.
+`gauntlet-performance` digests telemetry records without judging them: `node <pi-gauntlet-package>/bin/gauntlet-performance.mjs [--dir <repo root or telemetry dir>]... [--since <version>] [--json]` prints a `corpus:` line, one row per run (`run_id`, repo, spec, version, status - `shipped*` when the record has no ship phase - wall, per-phase minutes, tokens, cost, models, dispatches, `fix_round_grants`, reopens, conformance loops, reviewer findings, council dispatches), a `by version` block of p50/max over shipped, non-truncated runs, a `council` block grouped by member roster, and `skipped:` lines for files it could not use. Each council table shows member `total`, `unique`, `applied`, `uniq_appl`, `deferred`, `rejected` blocker/major/minor counts and `uniq_appl_nonminor/run`; `chair:` shows runs, average clusters and members reported, and retried runs. Roster flags (JSON `flags[].rule`: `low_unique_applied` - fewer than 0.2 unique-and-applied blocker/major findings per run; `high_rejection` - over 50% rejected while another member is below 25%) require five runs and print as `flag: <member> - <detail>`. Smaller groups print `not enough runs to assess (N of 5)`; absent council data prints `no council data in selected records`. JSON includes `council: [{ roster, runs, members, chairs, flags }]`. Default corpus is the current repo's telemetry dir; each `--dir` adds a repo root (its own `telemetry.dir` setting is honoured) or a bare telemetry dir. `--since` compares versions numerically. Exit 0 always except usage errors. `/skill:gauntlet-performance` is the reasoning layer on top.
 
 For local development against a checkout instead of npm:
 

package/bin/gauntlet-performance.mjs

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/bins/gauntlet-performance.mjs
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
@@ -43,20 +48,227 @@ function resolveTelemetry(g) {
   return { enabled, dir, buckets, warning: joinWarn(warnings) };
 }
 
-// src/bins/gauntlet-performance.mjs
+// src/bins/performance/shared.mjs
 var PHASES = ["brainstorm", "plan", "implement", "verify", "ship"];
 var TOKEN_KEYS = ["input", "output", "cache_read", "cache_write"];
-var RUN_HEADER = ["run_id", "repo", "spec", "version", "status", "wall", "b/p/i/v/s min", "tokens", "cost", "models", "disp", "grants", "reopens", "loops", "findings", "council"];
-var VERSION_HEADER = ["version", "n", "shipped", "truncated", "wall p50/max", "tokens p50/max", "cost p50/max", "disp p50", "grants p50/max", "reopens p50/max", "loops p50/max", "findings p50 b/M/m", "models"];
-var usage = () => {
-  process.stderr.write("usage: gauntlet-performance [--dir <repo root or telemetry dir>]... [--since <version>] [--json]\n");
-  process.exit(1);
-};
 var semver = (s) => {
   const m = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(typeof s === "string" ? s.trim() : "");
   return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : void 0;
 };
 var cmpSemver = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var str = (v) => typeof v === "string" ? v : null;
+var obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : null;
+var sumOrNull = (vals) => {
+  const xs = vals.filter((v) => v !== null);
+  return xs.length ? xs.reduce((a, b) => a + b, 0) : null;
+};
+var p50 = (xs) => {
+  const s = [...xs].sort((a, b) => a - b);
+  const m = s.length >> 1;
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+};
+var stat = (rows, pick) => {
+  const xs = rows.map(pick).filter((v) => v !== null && v !== void 0);
+  return xs.length ? { p50: p50(xs), max: Math.max(...xs) } : { p50: null, max: null };
+};
+var dash = (v) => v === null || v === void 0 ? "-" : String(v);
+var fmtMin = (s) => s === null ? "-" : `${Math.round(s / 60)}m`;
+var fmtCount = (n) => n === null ? "-" : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+var fmtCost = (c) => c === null ? "-" : c.toFixed(2);
+var pair = (s, f) => `${f(s.p50)}/${f(s.max)}`;
+var findingsCell = (f) => f === null ? "-" : `${dash(f.blocker)}/${dash(f.major)}/${dash(f.minor)}`;
+var table = (header, rows) => {
+  const w = header.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+  return [header, ...rows].map((r) => r.map((c, i) => c.padEnd(w[i])).join("  ").trimEnd()).join("\n");
+};
+
+// src/bins/performance/runs.mjs
+var runs_exports = {};
+__export(runs_exports, {
+  aggregate: () => aggregate,
+  key: () => key,
+  renderText: () => renderText
+});
+var key = "runs";
+var HEADER = ["run_id", "repo", "spec", "version", "status", "wall", "b/p/i/v/s min", "tokens", "cost", "models", "disp", "grants", "reopens", "loops", "findings", "council"];
+var runRow = (r) => [
+  r.run_id.slice(0, 8),
+  r.repo,
+  r.spec,
+  r.version,
+  `${dash(r.status)}${r.truncated ? "*" : ""}`,
+  fmtMin(r.wall_s),
+  PHASES.map((p) => r.phase_min[p] === null ? "-" : String(Math.round(r.phase_min[p]))).join("/"),
+  fmtCount(r.tokens),
+  fmtCost(r.cost),
+  r.models.join(",") || "-",
+  dash(r.dispatches),
+  dash(r.grants),
+  dash(r.reopens),
+  dash(r.loops),
+  findingsCell(r.findings),
+  dash(r.council)
+];
+var aggregate = (entries) => entries.map((e) => e.row);
+var renderText = (rows) => [`runs (${rows.length})`, table(HEADER, rows.map(runRow))].join("\n");
+
+// src/bins/performance/versions.mjs
+var versions_exports = {};
+__export(versions_exports, {
+  aggregate: () => aggregate2,
+  key: () => key2,
+  renderText: () => renderText2
+});
+var key2 = "by_version";
+var HEADER2 = ["version", "n", "shipped", "truncated", "wall p50/max", "tokens p50/max", "cost p50/max", "disp p50", "grants p50/max", "reopens p50/max", "loops p50/max", "findings p50 b/M/m", "models"];
+var versionOrder = (a, b) => {
+  const x = semver(a), y = semver(b);
+  return x && y ? cmpSemver(x, y) : x ? -1 : y ? 1 : 0;
+};
+function aggregate2(entries) {
+  const rows = entries.map((e) => e.row);
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (!groups.has(r.version)) groups.set(r.version, []);
+    groups.get(r.version).push(r);
+  }
+  return [...groups.entries()].sort(([a], [b]) => versionOrder(a, b)).map(([version, all]) => {
+    const shipped = all.filter((r) => r.status === "shipped" && !r.truncated);
+    const models = {};
+    for (const r of shipped) for (const m of r.models) models[m] = (models[m] ?? 0) + 1;
+    return {
+      version,
+      n: all.length,
+      shipped: shipped.length,
+      truncated: all.filter((r) => r.truncated).length,
+      wall_s: stat(shipped, (r) => r.wall_s),
+      tokens: stat(shipped, (r) => r.tokens),
+      cost: stat(shipped, (r) => r.cost),
+      dispatches: { p50: stat(shipped, (r) => r.dispatches).p50 },
+      grants: stat(shipped, (r) => r.grants),
+      reopens: stat(shipped, (r) => r.reopens),
+      loops: stat(shipped, (r) => r.loops),
+      findings: {
+        blocker: { p50: stat(shipped, (r) => r.findings?.blocker ?? null).p50 },
+        major: { p50: stat(shipped, (r) => r.findings?.major ?? null).p50 },
+        minor: { p50: stat(shipped, (r) => r.findings?.minor ?? null).p50 }
+      },
+      models
+    };
+  });
+}
+var versionRow = (g) => [
+  g.version,
+  String(g.n),
+  String(g.shipped),
+  String(g.truncated),
+  pair(g.wall_s, fmtMin),
+  pair(g.tokens, fmtCount),
+  pair(g.cost, fmtCost),
+  dash(g.dispatches.p50),
+  pair(g.grants, dash),
+  pair(g.reopens, dash),
+  pair(g.loops, dash),
+  `${dash(g.findings.blocker.p50)}/${dash(g.findings.major.p50)}/${dash(g.findings.minor.p50)}`,
+  Object.entries(g.models).map(([m, n]) => `${m}:${n}`).join(",") || "-"
+];
+var renderText2 = (agg) => ["by version", table(HEADER2, agg.map(versionRow))].join("\n");
+
+// src/bins/performance/council.mjs
+var council_exports = {};
+__export(council_exports, {
+  aggregate: () => aggregate3,
+  key: () => key3,
+  renderText: () => renderText3
+});
+var key3 = "council";
+var SEVERITIES = ["blocker", "major", "minor"];
+var COUNTERS = ["total", "unique", "applied", "unique_applied", "deferred", "rejected"];
+var MIN_RUNS = 5;
+var HEADER3 = ["member", "total", "unique", "applied", "uniq_appl", "deferred", "rejected", "uniq_appl_nonminor/run"];
+var zero = () => ({ blocker: 0, major: 0, minor: 0 });
+var addInto = (acc, src) => {
+  for (const s of SEVERITIES) acc[s] += num(obj(src)?.[s]) ?? 0;
+};
+var sum = (c) => c.blocker + c.major + c.minor;
+var cell = (c) => `${c.blocker}/${c.major}/${c.minor}`;
+var pct = (x) => `${Math.round(x * 100)}%`;
+function flagsFor(members, runs) {
+  const share = (m) => sum(m.total) === 0 ? null : sum(m.rejected) / sum(m.total);
+  const quiet = Object.entries(members).filter(([, m]) => share(m) !== null && share(m) < 0.25);
+  const out = [];
+  for (const [name, m] of Object.entries(members)) {
+    if (m.unique_applied_nonminor_per_run < 0.2) {
+      out.push({ member: name, rule: "low_unique_applied", detail: `${m.unique_applied_nonminor_per_run.toFixed(2)} unique-and-applied blocker/major per run in ${runs} runs (total ${cell(m.total)})` });
+    }
+    const s = share(m);
+    const other = quiet[0];
+    if (s !== null && s > 0.5 && other) {
+      out.push({ member: name, rule: "high_rejection", detail: `rejected ${pct(s)} vs ${other[0]} ${pct(share(other[1]))} (total ${cell(m.total)})` });
+    }
+  }
+  return out;
+}
+function aggregate3(entries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [i, e] of entries.entries()) {
+    const members = obj(obj(e.council)?.members);
+    if (!members) continue;
+    const roster = Object.keys(members).sort();
+    const k = roster.join(", ");
+    if (!groups.has(k)) groups.set(k, { roster, entries: [] });
+    groups.get(k).entries.push(e);
+    groups.get(k).last = i;
+  }
+  return [...groups.values()].sort((a, b) => b.last - a.last).map((g) => {
+    const runs = g.entries.length;
+    const members = {};
+    for (const m of g.roster) members[m] = { dispatches: 0, ...Object.fromEntries(COUNTERS.map((c) => [c, zero()])) };
+    const chairs = /* @__PURE__ */ new Map();
+    for (const e of g.entries) {
+      for (const m of g.roster) {
+        const src = obj(e.council.members[m]);
+        members[m].dispatches += num(src?.dispatches) ?? 0;
+        for (const c2 of COUNTERS) addInto(members[m][c2], src?.[c2]);
+      }
+      const ch = obj(e.council.chair);
+      const model = str(ch?.model) ?? "unknown";
+      const c = chairs.get(model) ?? { model, runs: 0, clusters: 0, reported: 0, retried_runs: 0 };
+      c.runs += 1;
+      c.clusters += num(ch?.clusters) ?? 0;
+      c.reported += num(ch?.members_reported) ?? 0;
+      if ((num(ch?.dispatches) ?? 1) > 1) c.retried_runs += 1;
+      chairs.set(model, c);
+    }
+    for (const m of g.roster) members[m].unique_applied_nonminor_per_run = (members[m].unique_applied.blocker + members[m].unique_applied.major) / runs;
+    const chairList = [...chairs.values()].sort((a, b) => b.runs - a.runs || a.model.localeCompare(b.model)).map((c) => ({ model: c.model, runs: c.runs, avg_clusters: c.clusters / c.runs, avg_members_reported: c.reported / c.runs, retried_runs: c.retried_runs }));
+    return { roster: g.roster, runs, members, chairs: chairList, flags: runs >= MIN_RUNS ? flagsFor(members, runs) : [] };
+  });
+}
+function renderText3(agg) {
+  if (!agg.length) return "council\nno council data in selected records";
+  const out = ["council", "severity is the chair's consolidated severity (highest any co-raiser assigned), not the member's own"];
+  for (const g of agg) {
+    out.push(`roster (${g.runs} runs): ${g.roster.join(", ")}`);
+    const rows = g.roster.map((m) => {
+      const x = g.members[m];
+      return [m, cell(x.total), cell(x.unique), cell(x.applied), cell(x.unique_applied), cell(x.deferred), cell(x.rejected), x.unique_applied_nonminor_per_run.toFixed(2)];
+    });
+    for (const line of table(HEADER3, rows).split("\n")) out.push(`  ${line}`);
+    for (const c of g.chairs) out.push(`  chair: ${c.model} - ${c.runs} runs, avg ${c.avg_clusters.toFixed(1)} clusters from ${c.avg_members_reported.toFixed(1)} members reported, retried in ${c.retried_runs}`);
+    if (g.runs < MIN_RUNS) out.push(`  not enough runs to assess (${g.runs} of ${MIN_RUNS})`);
+    for (const f of g.flags) out.push(`  flag: ${f.member} - ${f.detail}`);
+  }
+  return out.join("\n");
+}
+
+// src/bins/gauntlet-performance.mjs
+var SECTIONS = [runs_exports, versions_exports, council_exports];
+var usage = () => {
+  process.stderr.write("usage: gauntlet-performance [--dir <repo root or telemetry dir>]... [--since <version>] [--json]\n");
+  process.exit(1);
+};
 function parseArgs(argv) {
   const opts = { dirs: [], since: void 0, json: false };
   for (let i = 0; i < argv.length; i++) {
@@ -112,13 +324,6 @@ function* yamlFiles(dir) {
     else if (e.isFile() && e.name.endsWith(".yaml")) yield p;
   }
 }
-var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
-var str = (v) => typeof v === "string" ? v : null;
-var obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : null;
-var sumOrNull = (vals) => {
-  const xs = vals.filter((v) => v !== null);
-  return xs.length ? xs.reduce((a, b) => a + b, 0) : null;
-};
 function loadRecord(file, label) {
   let doc;
   try {
@@ -179,96 +384,10 @@ function loadRecord(file, label) {
       council: num(obj(personas["spec-council-member"])?.dispatches),
       ship_option: str(gates.ship_option),
       tests: str(obj(derived.tests)?.result)
-    }
+    },
+    council: derived.council ?? null
   };
 }
-var p50 = (xs) => {
-  const s = [...xs].sort((a, b) => a - b);
-  const m = s.length >> 1;
-  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
-};
-var stat = (rows, pick) => {
-  const xs = rows.map(pick).filter((v) => v !== null && v !== void 0);
-  return xs.length ? { p50: p50(xs), max: Math.max(...xs) } : { p50: null, max: null };
-};
-var versionOrder = (a, b) => {
-  const x = semver(a), y = semver(b);
-  return x && y ? cmpSemver(x, y) : x ? -1 : y ? 1 : 0;
-};
-function aggregate(rows) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const r of rows) {
-    if (!groups.has(r.version)) groups.set(r.version, []);
-    groups.get(r.version).push(r);
-  }
-  return [...groups.entries()].sort(([a], [b]) => versionOrder(a, b)).map(([version, all]) => {
-    const shipped = all.filter((r) => r.status === "shipped" && !r.truncated);
-    const models = {};
-    for (const r of shipped) for (const m of r.models) models[m] = (models[m] ?? 0) + 1;
-    return {
-      version,
-      n: all.length,
-      shipped: shipped.length,
-      truncated: all.filter((r) => r.truncated).length,
-      wall_s: stat(shipped, (r) => r.wall_s),
-      tokens: stat(shipped, (r) => r.tokens),
-      cost: stat(shipped, (r) => r.cost),
-      dispatches: { p50: stat(shipped, (r) => r.dispatches).p50 },
-      grants: stat(shipped, (r) => r.grants),
-      reopens: stat(shipped, (r) => r.reopens),
-      loops: stat(shipped, (r) => r.loops),
-      findings: {
-        blocker: { p50: stat(shipped, (r) => r.findings?.blocker ?? null).p50 },
-        major: { p50: stat(shipped, (r) => r.findings?.major ?? null).p50 },
-        minor: { p50: stat(shipped, (r) => r.findings?.minor ?? null).p50 }
-      },
-      models
-    };
-  });
-}
-var dash = (v) => v === null || v === void 0 ? "-" : String(v);
-var fmtMin = (s) => s === null ? "-" : `${Math.round(s / 60)}m`;
-var fmtCount = (n) => n === null ? "-" : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
-var fmtCost = (c) => c === null ? "-" : c.toFixed(2);
-var pair = (s, f) => `${f(s.p50)}/${f(s.max)}`;
-var findingsCell = (f) => f === null ? "-" : `${dash(f.blocker)}/${dash(f.major)}/${dash(f.minor)}`;
-var table = (header, rows) => {
-  const w = header.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
-  return [header, ...rows].map((r) => r.map((c, i) => c.padEnd(w[i])).join("  ").trimEnd()).join("\n");
-};
-var runRow = (r) => [
-  r.run_id.slice(0, 8),
-  r.repo,
-  r.spec,
-  r.version,
-  `${dash(r.status)}${r.truncated ? "*" : ""}`,
-  fmtMin(r.wall_s),
-  PHASES.map((p) => r.phase_min[p] === null ? "-" : String(Math.round(r.phase_min[p]))).join("/"),
-  fmtCount(r.tokens),
-  fmtCost(r.cost),
-  r.models.join(",") || "-",
-  dash(r.dispatches),
-  dash(r.grants),
-  dash(r.reopens),
-  dash(r.loops),
-  findingsCell(r.findings),
-  dash(r.council)
-];
-var versionRow = (g) => [
-  g.version,
-  String(g.n),
-  String(g.shipped),
-  String(g.truncated),
-  pair(g.wall_s, fmtMin),
-  pair(g.tokens, fmtCount),
-  pair(g.cost, fmtCost),
-  dash(g.dispatches.p50),
-  pair(g.grants, dash),
-  pair(g.reopens, dash),
-  pair(g.loops, dash),
-  `${dash(g.findings.blocker.p50)}/${dash(g.findings.major.p50)}/${dash(g.findings.minor.p50)}`,
-  Object.entries(g.models).map(([m, n]) => `${m}:${n}`).join(",") || "-"
-];
 function main() {
   const opts = parseArgs(process.argv.slice(2));
   const corpora = [];
@@ -285,7 +404,7 @@ function main() {
   const since = opts.since === void 0 ? void 0 : semver(opts.since);
   const seen = /* @__PURE__ */ new Set();
   const corpus = {};
-  const rows = [];
+  const entries = [];
   for (const c of corpora) {
     corpus[c.label] = corpus[c.label] ?? 0;
     for (const file of yamlFiles(c.dir)) {
@@ -302,26 +421,25 @@ function main() {
       const v = semver(res.row.version);
       if (since && (!v || cmpSemver(v, since) < 0)) continue;
       corpus[c.label]++;
-      rows.push(res.row);
+      entries.push(res);
     }
   }
-  rows.sort((a, b) => (a.created_at ?? "").localeCompare(b.created_at ?? "") || a.run_id.localeCompare(b.run_id));
-  const byVersion = rows.length ? aggregate(rows) : [];
+  entries.sort((a, b) => (a.row.created_at ?? "").localeCompare(b.row.created_at ?? "") || a.row.run_id.localeCompare(b.row.run_id));
+  const aggregates = SECTIONS.map((s) => [s, s.aggregate(entries)]);
   if (opts.json) {
-    console.log(JSON.stringify({ corpus, since: opts.since ?? null, runs: rows, by_version: byVersion, skipped }, null, 2));
+    const out = { corpus, since: opts.since ?? null };
+    for (const [s, agg] of aggregates) out[s.key] = agg;
+    out.skipped = skipped;
+    console.log(JSON.stringify(out, null, 2));
     return;
   }
   console.log(`corpus: ${Object.entries(corpus).map(([k, v]) => `${k}=${v}`).join(", ")}${opts.since === void 0 ? "" : `   since: ${opts.since}`}`);
-  if (rows.length === 0) {
+  if (entries.length === 0) {
     console.log(`no records found in ${corpora.map((c) => c.dir).join(", ") || process.cwd()}`);
   } else {
-    console.log(`runs (${rows.length})`);
-    console.log(table(RUN_HEADER, rows.map(runRow)));
-    console.log("");
-    console.log("by version");
-    console.log(table(VERSION_HEADER, byVersion.map(versionRow)));
+    console.log(aggregates.map(([s, agg]) => s.renderText(agg)).join("\n\n"));
   }
-  if (rows.length && skipped.length) console.log("");
-  if (rows.length) for (const s of skipped) console.log(`skipped: ${s.file}: ${s.reason}`);
+  if (entries.length && skipped.length) console.log("");
+  if (entries.length) for (const s of skipped) console.log(`skipped: ${s.file}: ${s.reason}`);
 }
 main();

package/bin/gauntlet-performance.test.mjs

@@ -348,3 +348,103 @@ test("usage error exits 1", (t) => {
   assert.equal(invoke(root, ["--since", "abc"]).status, 1);
   assert.equal(invoke(root, ["--since", "5.09.1"]).status, 1);
 });
+
+const sev = (b, M, m) => `{ blocker: ${b}, major: ${M}, minor: ${m} }`;
+const member = (dispatches, total, unique, applied, uniqApplied, deferred, rejected) =>
+  `{ dispatches: ${dispatches}, total: ${total}, unique: ${unique}, applied: ${applied}, unique_applied: ${uniqApplied}, deferred: ${deferred}, rejected: ${rejected} }`;
+const ALPHA = member(1, sev(1, 3, 1), sev(0, 1, 1), sev(1, 3, 0), sev(0, 1, 0), sev(0, 0, 0), sev(0, 0, 1));
+const BETA = member(1, sev(0, 2, 2), sev(0, 1, 0), sev(0, 1, 1), sev(0, 1, 0), sev(0, 1, 0), sev(0, 0, 1));
+const GAMMA = member(2, sev(0, 1, 4), sev(0, 0, 3), sev(0, 0, 1), sev(0, 0, 1), sev(0, 0, 0), sev(0, 1, 3));
+const councilRecord = (id, createdAt, version, chair, chairDispatches, members) => `schema: 1
+spec: doc/specs/c-${id}.md
+run_id: ${id}-0000-0000-0000-000000000000
+status: shipped
+created_at: ${createdAt}
+shipped_at: ${createdAt}
+versions: { pi-gauntlet: ${version} }
+derived:
+  duration_s: 60
+  phases:
+    ship: ${phase("model: m/alpha")}
+  personas: {}
+  conformance_loops: 0
+  gates: { spec_rounds: 1, plan_rounds: 1, fix_round_grants: 0, task_reopens: 0 }
+  council:
+    chair: { model: ${chair}, dispatches: ${chairDispatches}, clusters: 6, members_reported: 3 }
+    members:
+${Object.entries(members).map(([k, v]) => `      ${k}: ${v}`).join("\n")}
+  amendments: 0
+  spec_edits_after_ship: 0
+  spec_writes: {}
+  events_dropped: 0
+accumulators: {}
+events: []
+`;
+const ZERO = member(1, ...Array(6).fill(sev(0, 0, 0)));
+const BIG = { "p/alpha:xhigh": ALPHA, "p/beta:high": BETA, "p/gamma:high": GAMMA, "p/zero:high": ZERO };
+const SMALL = { "p/alpha:xhigh": ALPHA, "p/delta:high": BETA };
+const councilCorpus = (root) => {
+  for (let i = 0; i < 6; i++) write(root, `${TDIR}/big-${i}.yaml`, councilRecord(`c000000${i}`, `2026-09-1${i}T00:00:00Z`, "5.20.0", i < 4 ? "p/chair:medium" : "p/other:high", i === 2 ? 2 : 1, BIG));
+  for (let i = 0; i < 2; i++) write(root, `${TDIR}/small-${i}.yaml`, councilRecord(`d000000${i}`, `2026-09-2${i}T00:00:00Z`, "5.21.0", "p/chair:medium", 1, SMALL));
+  write(root, `${TDIR}/plain.yaml`, COMPLETE);
+  return root;
+};
+
+test("council section: rosters, sums, chairs and flags", (t) => {
+  const root = councilCorpus(gitRepo()); cleanup(t, root);
+  const d = json(root);
+  assert.equal(d.council.length, 2);
+  assert.deepEqual(d.council[0].roster, ["p/alpha:xhigh", "p/delta:high"]);
+  assert.equal(d.council[0].runs, 2);
+  assert.deepEqual(d.council[0].flags, []);
+  const big = d.council[1];
+  assert.deepEqual(big.roster, ["p/alpha:xhigh", "p/beta:high", "p/gamma:high", "p/zero:high"]);
+  assert.equal(big.runs, 6);
+  assert.deepEqual(big.members["p/alpha:xhigh"].total, { blocker: 6, major: 18, minor: 6 });
+  assert.equal(big.members["p/alpha:xhigh"].dispatches, 6);
+  assert.equal(big.members["p/gamma:high"].dispatches, 12);
+  assert.equal(big.members["p/alpha:xhigh"].unique_applied_nonminor_per_run, 1);
+  assert.equal(big.members["p/gamma:high"].unique_applied_nonminor_per_run, 0);
+  assert.deepEqual(big.chairs, [
+    { model: "p/chair:medium", runs: 4, avg_clusters: 6, avg_members_reported: 3, retried_runs: 1 },
+    { model: "p/other:high", runs: 2, avg_clusters: 6, avg_members_reported: 3, retried_runs: 0 },
+  ]);
+  assert.deepEqual(big.flags.map((f) => [f.member, f.rule]), [
+    ["p/gamma:high", "low_unique_applied"], ["p/gamma:high", "high_rejection"],
+    ["p/zero:high", "low_unique_applied"],
+  ]);
+  assert.equal(big.flags[0].detail, "0.00 unique-and-applied blocker/major per run in 6 runs (total 0/6/24)");
+  assert.equal(big.flags[1].detail, "rejected 80% vs p/alpha:xhigh 20% (total 0/6/24)");
+  assert.equal(big.flags[2].detail, "0.00 unique-and-applied blocker/major per run in 6 runs (total 0/0/0)");
+  const r = invoke(root);
+  assert.equal(r.status, 0, r.stderr);
+  const at = r.lines.indexOf("council");
+  assert.ok(at > 0);
+  assert.equal(r.lines[at + 1], "severity is the chair's consolidated severity (highest any co-raiser assigned), not the member's own");
+  assert.equal(r.lines[at + 2], "roster (2 runs): p/alpha:xhigh, p/delta:high");
+  assert.match(r.lines[at + 3], /^  member\s+total\s+unique\s+applied\s+uniq_appl\s+deferred\s+rejected\s+uniq_appl_nonminor\/run$/);
+  assert.ok(r.lines.includes("  not enough runs to assess (2 of 5)"));
+  assert.ok(r.lines.includes("roster (6 runs): p/alpha:xhigh, p/beta:high, p/gamma:high, p/zero:high"));
+  assert.match(r.lines.find((l) => /^  p\/alpha:xhigh\s+6\/18\/6\s/.test(l)), /^  p\/alpha:xhigh\s+6\/18\/6\s+0\/6\/6\s+6\/18\/0\s+0\/6\/0\s+0\/0\/0\s+0\/0\/6\s+1\.00$/);
+  assert.ok(r.lines.includes("  chair: p/chair:medium - 4 runs, avg 6.0 clusters from 3.0 members reported, retried in 1"));
+  assert.ok(r.lines.includes("  chair: p/other:high - 2 runs, avg 6.0 clusters from 3.0 members reported, retried in 0"));
+  assert.ok(r.lines.includes("  flag: p/gamma:high - 0.00 unique-and-applied blocker/major per run in 6 runs (total 0/6/24)"));
+  assert.ok(r.lines.includes("  flag: p/gamma:high - rejected 80% vs p/alpha:xhigh 20% (total 0/6/24)"));
+});
+
+test("council section: --since and no council data", (t) => {
+  const root = councilCorpus(gitRepo()); cleanup(t, root);
+  const d = json(root, ["--since", "5.21.0"]);
+  assert.equal(d.council.length, 1);
+  assert.deepEqual(d.council[0].roster, ["p/alpha:xhigh", "p/delta:high"]);
+  const plain = corpus(gitRepo()); cleanup(t, plain);
+  assert.deepEqual(json(plain).council, []);
+  const r = invoke(plain);
+  const at = r.lines.indexOf("council");
+  assert.ok(at > 0);
+  assert.equal(r.lines[at + 1], "no council data in selected records");
+  const empty = gitRepo(); cleanup(t, empty);
+  const none = invoke(empty);
+  assert.match(none.lines[1], /^no records found/);
+  assert.equal(none.lines.length, 2);
+});