pi-gauntlet 5.20.0 → 5.21.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 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.
 
@@ -141,7 +141,7 @@ Pin an exact release with `npm:pi-gauntlet@X.Y.Z`. See [doc/install-internals.md
 
 ## 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);
+});

package/bin/gauntlet-telemetry-seal.mjs

@@ -168,7 +168,7 @@ function derive(rec, now) {
   }
   for (const k of Object.keys(acc.phases)) phases[k] = compact({ ...phases[k] ?? {}, ...acc.phases[k] });
   const live = liveShipEvent(rec.events);
-  return compact({ duration_s: seconds(rec.created_at, rec.shipped_at ?? rec.abandoned_at ?? now), phases, personas: acc.personas, reviews: Object.keys(acc.reviews).length ? acc.reviews : void 0, conformance_loops: acc.conformance_loops, conformance_open_gaps: acc.conformance_open_gaps, gates: compact({ ...acc.gates, ship_option: live?.option }), plan: rec.derived.plan, tests: rec.derived.tests, amendments: acc.amendments, spec_edits_after_ship: acc.spec_edits_after_ship, diff: rec.derived.diff, modified_files: rec.derived.modified_files, spec_writes: acc.spec_writes, events_dropped: acc.events_dropped });
+  return compact({ duration_s: seconds(rec.created_at, rec.shipped_at ?? rec.abandoned_at ?? now), phases, personas: acc.personas, reviews: Object.keys(acc.reviews).length ? acc.reviews : void 0, conformance_loops: acc.conformance_loops, conformance_open_gaps: acc.conformance_open_gaps, gates: compact({ ...acc.gates, ship_option: live?.option }), plan: rec.derived.plan, tests: rec.derived.tests, amendments: acc.amendments, spec_edits_after_ship: acc.spec_edits_after_ship, diff: rec.derived.diff, modified_files: rec.derived.modified_files, council: rec.derived.council, spec_writes: acc.spec_writes, events_dropped: acc.events_dropped });
 }
 var stripUndefined = (v) => {
   if (Array.isArray(v)) return v.map(stripUndefined);
@@ -202,7 +202,11 @@ function serializeRecord(rec) {
   const body = stripUndefined({ ...head, derived, accumulators });
   const doc = new Document(body);
   const derivedNode = doc.get("derived", true);
-  if (isMap(derivedNode)) flowLeafChildren(derivedNode, /* @__PURE__ */ new Set(["modified_files"]));
+  if (isMap(derivedNode)) {
+    flowLeafChildren(derivedNode, /* @__PURE__ */ new Set(["modified_files", "council"]));
+    const council = derivedNode.get("council", true);
+    if (isMap(council)) flowLeafChildren(council);
+  }
   const accumulatorNode = doc.get("accumulators", true);
   if (isMap(accumulatorNode)) {
     for (const session of accumulatorNode.items) if (isMap(session.value)) flowLeafChildren(session.value);

package/bin/gauntlet-telemetry-seal.test.mjs

@@ -100,6 +100,16 @@ test("seals an untracked in_progress record: stamp, ship event, diff, re-derived
   assert.equal(porcelain(root), "");
 });
 
+test("seal preserves derived.council through the shipped stamp", (t) => {
+  const council = { chair: { model: "p/chair:medium", dispatches: 1, clusters: 0, members_reported: 0 }, members: {} };
+  const root = repo({ record: RECORD.replace("  spec_writes: {}", `  council: ${JSON.stringify(council)}\n  spec_writes: {}`) }); cleanup(t, root);
+  const r = run(root, ["--spec", SPEC]);
+  assert.equal(r.status, 0, r.stderr);
+  assert.equal(record(root).status, "shipped");
+  assert.deepEqual(record(root).derived.council, council);
+  assert.deepEqual(parseYaml(out(root, ["show", `HEAD:${REC}`])).derived.council, council);
+});
+
 test("--spec accepts an absolute path within the checkout", (t) => {
   const root = repo(); cleanup(t, root);
   const r = run(root, ["--spec", join(realpathSync(root), SPEC)]);

package/extensions/lib/telemetry-council.test.ts

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { buildCouncil, memberSlugOf, normalizeRaisedBy, parseAudit, parseChairReport, resolveMembers, slug } from "./telemetry-council.ts";
+
+const zero = { blocker: 0, major: 0, minor: 0 };
+test("slug and member filename normalization", () => {
+  assert.equal(slug("p/alpha:xhigh"), "p-alpha-xhigh");
+  assert.equal(memberSlugOf("/tmp/retry/member-2-p-beta-high.md"), "p-beta-high");
+  assert.equal(memberSlugOf("/tmp/member-0-p-alpha"), "p-alpha");
+  assert.equal(memberSlugOf(undefined), undefined);
+  assert.equal(memberSlugOf("chair.md"), undefined);
+  assert.equal(normalizeRaisedBy("member-0-p-alpha"), "p-alpha");
+  assert.equal(normalizeRaisedBy("p-alpha.md"), "p-alpha");
+  assert.equal(normalizeRaisedBy(" p/alpha:xhigh "), "p-alpha-xhigh");
+});
+const chairText = [
+  "consensus: needs-work",
+  "clusters:",
+  "- [blocker] issue — raised-by: [p-alpha] — fix",
+  "- [Major] issue - raised-by: [p-alpha, p-beta-high, p-alpha] - fix",
+  "- [minor] issue -- raised-by: [p-beta-high] -- cut",
+  "resolved:",
+  "- [blocker] ignored — raised-by: [nobody]",
+].join("\n");
+test("chair clusters parse only before resolved and require attributes", () => {
+  assert.deepEqual(parseChairReport(chairText), { clusters: [
+    { severity: "blocker", raisedBy: ["p-alpha"] },
+    { severity: "major", raisedBy: ["p-alpha", "p-beta-high"] },
+    { severity: "minor", raisedBy: ["p-beta-high"] },
+  ] });
+  assert.equal(parseChairReport("clusters:\n"), null);
+  assert.equal(parseChairReport("consensus: x\n"), null);
+  assert.deepEqual(parseChairReport("consensus: sound\nclusters:\nresolved:\n"), { clusters: [] });
+  assert.equal(parseChairReport("consensus: x\nclusters:\n- [major] no raiser"), null);
+});
+const auditText = [
+  "Applied: [blocker] issue — raised-by: [p-alpha] -> fix",
+  "- Applied: [major] over-spec — raised-by: [p-alpha, p-beta-high] -> cut",
+  "Applied: [minor] issue — raised-by: [p-beta-high] -> open question (missing)",
+  "Deferred: [major] x — raised-by: [p-alpha] -> later",
+  "Rejected: [minor] issue — raised-by: [p-beta-high] -> no",
+].join("\n");
+test("audit reads dispositions, none and cut/open question", () => {
+  assert.deepEqual(parseAudit(auditText), [
+    { disposition: "applied", severity: "blocker", raisedBy: ["p-alpha"] },
+    { disposition: "applied", severity: "major", raisedBy: ["p-alpha", "p-beta-high"] },
+    { disposition: "applied", severity: "minor", raisedBy: ["p-beta-high"] },
+    { disposition: "deferred", severity: "major", raisedBy: ["p-alpha"] },
+    { disposition: "rejected", severity: "minor", raisedBy: ["p-beta-high"] },
+  ]);
+  assert.equal(parseAudit("Applied: [major] x — raised-by: [p-alpha]\nDeferred: none"), null);
+  assert.equal(parseAudit("Applied: x — raised-by: [p-alpha]\nDeferred: none\nRejected: none"), null);
+  assert.equal(parseAudit("Applied: [major] x\nDeferred: none\nRejected: none"), null);
+  assert.deepEqual(parseAudit("Applied: none\nDeferred: none\nRejected: none"), []);
+});
+const results = [
+  { model: "p/alpha:xhigh", exitCode: 0, savedOutputPath: "/tmp/member-0-p-alpha.md" },
+  { model: "p/beta:high", exitCode: 1 },
+  { model: "p/beta:high", exitCode: 0, savedOutputPath: "/tmp/retry/member-1-p-beta-high.md" },
+];
+test("member retry counts dispatches and ambiguous slug fails", () => {
+  const members = resolveMembers(results)!;
+  assert.deepEqual([...members.dispatches], [["p/alpha:xhigh", 1], ["p/beta:high", 2]]);
+  assert.deepEqual([...members.slugToModel], [["p-alpha", "p/alpha:xhigh"], ["p-beta-high", "p/beta:high"]]);
+  assert.equal(resolveMembers([...results, { model: "p/other", exitCode: 0, savedOutputPath: "/tmp/member-3-p-alpha.md" }]), null);
+  assert.deepEqual([...resolveMembers([{ exitCode: 0, savedOutputPath: "/tmp/member-0-x.md" }])!.dispatches], []);
+});
+const clusters = [{ severity: "blocker" as const, raisedBy: ["p-alpha"] }, { severity: "major" as const, raisedBy: ["p-alpha", "p-beta-high"] }, { severity: "minor" as const, raisedBy: ["p-beta-high"] }];
+const audit = [{ disposition: "applied" as const, severity: "blocker" as const, raisedBy: ["p-alpha"] }, { disposition: "deferred" as const, severity: "major" as const, raisedBy: ["p-beta-high", "p-alpha"] }, { disposition: "rejected" as const, severity: "minor" as const, raisedBy: ["p-beta-high"] }];
+const input = () => ({ chair: { model: "p/chair:medium", dispatches: 2, clusters }, members: resolveMembers(results)!, audit });
+test("council joins multiset and counts each severity per member", () => {
+  const block = buildCouncil(input())!;
+  assert.deepEqual(block.chair, { model: "p/chair:medium", dispatches: 2, clusters: 3, members_reported: 2 });
+  assert.deepEqual(block.members["p/alpha:xhigh"], { dispatches: 1, total: { blocker: 1, major: 1, minor: 0 }, unique: { blocker: 1, major: 0, minor: 0 }, applied: { blocker: 1, major: 0, minor: 0 }, unique_applied: { blocker: 1, major: 0, minor: 0 }, deferred: { blocker: 0, major: 1, minor: 0 }, rejected: zero });
+  assert.deepEqual(block.members["p/beta:high"], { dispatches: 2, total: { blocker: 0, major: 1, minor: 1 }, unique: { blocker: 0, major: 0, minor: 1 }, applied: zero, unique_applied: zero, deferred: { blocker: 0, major: 1, minor: 0 }, rejected: { blocker: 0, major: 0, minor: 1 } });
+  for (const member of Object.values(block.members)) for (const severity of ["blocker", "major", "minor"] as const) assert.equal(member.total[severity], member.applied[severity] + member.deferred[severity] + member.rejected[severity]);
+});
+test("zero-member and zero-finding completeness", () => {
+  const members = resolveMembers([...results, { model: "p/gamma:high", exitCode: 0, savedOutputPath: "/tmp/member-2-p-gamma-high.md" }])!;
+  const block = buildCouncil({ ...input(), members })!;
+  assert.deepEqual(block.members["p/gamma:high"], { dispatches: 1, total: zero, unique: zero, applied: zero, unique_applied: zero, deferred: zero, rejected: zero });
+  assert.equal(block.chair.members_reported, 2);
+  assert.deepEqual(buildCouncil({ ...input(), chair: { model: "p/chair:medium", dispatches: 1, clusters: [] }, audit: [] })!.chair, { model: "p/chair:medium", dispatches: 1, clusters: 0, members_reported: 0 });
+});
+test("incomplete batches return null", () => {
+  assert.equal(buildCouncil({ ...input(), audit: [...audit, { disposition: "rejected", severity: "minor", raisedBy: ["p-nobody"] }] }), null);
+  assert.equal(buildCouncil({ ...input(), chair: { ...input().chair, clusters: [...clusters, { severity: "minor", raisedBy: ["p-nobody"] }] } }), null);
+  assert.equal(buildCouncil({ ...input(), audit: [...audit, { disposition: "rejected", severity: "minor", raisedBy: ["p-alpha"] }] }), null);
+  assert.equal(buildCouncil({ ...input(), audit: audit.slice(0, 2) }), null);
+  assert.equal(buildCouncil({ ...input(), audit: [{ ...audit[0], severity: "major" }, audit[1], audit[2]] }), null);
+});

package/extensions/lib/telemetry-council.ts

@@ -0,0 +1,121 @@
+export type Severity = "blocker" | "major" | "minor";
+export type Disposition = "applied" | "deferred" | "rejected";
+export type SeverityCounts = Record<Severity, number>;
+export interface Cluster { severity: Severity; raisedBy: string[] }
+export interface AuditItem extends Cluster { disposition: Disposition }
+export interface CouncilMember {
+  dispatches: number; total: SeverityCounts; unique: SeverityCounts; applied: SeverityCounts;
+  unique_applied: SeverityCounts; deferred: SeverityCounts; rejected: SeverityCounts;
+}
+export interface CouncilBlock {
+  chair: { model: string; dispatches: number; clusters: number; members_reported: number };
+  members: Record<string, CouncilMember>;
+}
+export interface MemberResult { model?: string; exitCode?: number; savedOutputPath?: string }
+export interface ResolvedMembers { dispatches: Map<string, number>; slugToModel: Map<string, string> }
+const zero = (): SeverityCounts => ({ blocker: 0, major: 0, minor: 0 });
+export const slug = (model: string): string => model.replace(/[^A-Za-z0-9]/g, "-");
+export function memberSlugOf(path: string | undefined): string | undefined {
+  if (!path) return undefined;
+  return /^member-\d+-(.+?)(\.md)?$/.exec(path.split(/[\\/]/).pop() ?? "")?.[1];
+}
+export const normalizeRaisedBy = (token: string): string => slug(token.trim().replace(/^member-\d+-/, "").replace(/\.md$/, ""));
+const attributes = (line: string): Cluster | undefined => {
+  const severity = /\[(blocker|major|minor)\]/i.exec(line);
+  const raisers = /raised-by:\s*\[([^\]]*)\]/i.exec(line);
+  if (!severity || !raisers) return undefined;
+  const raisedBy = [...new Set(raisers[1].split(",").map(normalizeRaisedBy).filter((x) => x && x !== "-"))];
+  return raisedBy.length ? { severity: severity[1].toLowerCase() as Severity, raisedBy } : undefined;
+};
+export function parseChairReport(text: string): { clusters: Cluster[] } | null {
+  if (!/^consensus:/m.test(text)) return null;
+  const lines = text.split("\n");
+  const start = lines.findIndex((line) => /^clusters:\s*$/.test(line));
+  if (start < 0) return null;
+  const clusters: Cluster[] = [];
+  for (const line of lines.slice(start + 1)) {
+    if (/^resolved:/.test(line)) break;
+    if (!/^\s*[-*]\s+/.test(line)) continue;
+    const item = attributes(line);
+    if (!item) return null;
+    clusters.push(item);
+  }
+  return { clusters };
+}
+export function parseAudit(text: string): AuditItem[] | null {
+  const seen = new Set<string>();
+  const items: AuditItem[] = [];
+  for (const line of text.split("\n")) {
+    const match = /^\s*(?:[-*]\s*)?(Applied|Deferred|Rejected):\s*(.*)$/.exec(line);
+    if (!match) continue;
+    const disposition = match[1].toLowerCase() as Disposition;
+    seen.add(disposition);
+    if (match[2].trim().toLowerCase() === "none") continue;
+    const item = attributes(match[2]);
+    if (!item) return null;
+    items.push({ disposition, ...item });
+  }
+  return seen.size === 3 ? items : null;
+}
+export function resolveMembers(results: MemberResult[]): ResolvedMembers | null {
+  const dispatches = new Map<string, number>();
+  const slugToModel = new Map<string, string>();
+  for (const result of results) {
+    if (typeof result.model !== "string") continue;
+    dispatches.set(result.model, (dispatches.get(result.model) ?? 0) + 1);
+    const memberSlug = result.exitCode === 0 ? memberSlugOf(result.savedOutputPath) : undefined;
+    if (!memberSlug) continue;
+    const previous = slugToModel.get(memberSlug);
+    if (previous !== undefined && previous !== result.model) return null;
+    slugToModel.set(memberSlug, result.model);
+  }
+  return { dispatches, slugToModel };
+}
+export interface CouncilInput {
+  chair: { model: string; dispatches: number; clusters: Cluster[] };
+  members: ResolvedMembers;
+  audit: AuditItem[];
+}
+export function buildCouncil(input: CouncilInput): CouncilBlock | null {
+  const resolve = (slugs: string[]): string[] | undefined => {
+    const models = new Set<string>();
+    for (const memberSlug of slugs) {
+      const model = input.members.slugToModel.get(memberSlug);
+      if (model === undefined) return undefined;
+      models.add(model);
+    }
+    return [...models].sort();
+  };
+  const key = (severity: Severity, models: string[]) => JSON.stringify([severity, models]);
+  const reported = new Set<string>();
+  const clusterKeys: string[] = [];
+  for (const cluster of input.chair.clusters) {
+    const models = resolve(cluster.raisedBy);
+    if (!models) return null;
+    for (const model of models) reported.add(model);
+    clusterKeys.push(key(cluster.severity, models));
+  }
+  const resolvedAudit: { item: AuditItem; models: string[] }[] = [];
+  for (const item of input.audit) {
+    const models = resolve(item.raisedBy);
+    if (!models) return null;
+    resolvedAudit.push({ item, models });
+  }
+  if (JSON.stringify(clusterKeys.sort()) !== JSON.stringify(resolvedAudit.map(({ item, models }) => key(item.severity, models)).sort())) return null;
+  const members: Record<string, CouncilMember> = {};
+  for (const [model, dispatches] of [...input.members.dispatches].sort(([a], [b]) => a.localeCompare(b))) {
+    members[model] = { dispatches, total: zero(), unique: zero(), applied: zero(), unique_applied: zero(), deferred: zero(), rejected: zero() };
+  }
+  for (const { item, models } of resolvedAudit) {
+    for (const model of models) {
+      const member = members[model];
+      member.total[item.severity]++;
+      member[item.disposition][item.severity]++;
+      if (models.length === 1) {
+        member.unique[item.severity]++;
+        if (item.disposition === "applied") member.unique_applied[item.severity]++;
+      }
+    }
+  }
+  return { chair: { model: input.chair.model, dispatches: input.chair.dispatches, clusters: input.chair.clusters.length, members_reported: reported.size }, members };
+}

package/extensions/lib/telemetry-record.test.ts

@@ -4,6 +4,7 @@ import {
   capEvents, derive, diffPhases, emptyAccumulators, emptyPhases, foldAccumulators, implementAutoCompletes,
   newRecord, parseRecord, serializeRecord, type Accumulators, type TelemetryEvent,
 } from "./telemetry-record.ts";
+import type { CouncilBlock } from "./telemetry-council.ts";
 
 const ev = (over: Partial<TelemetryEvent> & { kind: string }): TelemetryEvent =>
   ({ ts: "2026-09-17T10:00:00Z", session: "s1", phase: "unphased", ...over }) as TelemetryEvent;
@@ -165,3 +166,28 @@ test("parseRecord drops malformed accumulator blocks and fills missing fields",
   assert.equal(derive(parsed, "2026-09-17T10:01:00Z").amendments, 2);
 });
 
+const COUNCIL: CouncilBlock = {
+  chair: { model: "p/chair:medium", dispatches: 1, clusters: 2, members_reported: 2 },
+  members: {
+    "p/alpha:xhigh": { dispatches: 1, total: { blocker: 0, major: 1, minor: 1 }, unique: { blocker: 0, major: 1, minor: 0 }, applied: { blocker: 0, major: 1, minor: 0 }, unique_applied: { blocker: 0, major: 1, minor: 0 }, deferred: { blocker: 0, major: 0, minor: 0 }, rejected: { blocker: 0, major: 0, minor: 1 } },
+    "p/beta:high": { dispatches: 2, total: { blocker: 0, major: 0, minor: 1 }, unique: { blocker: 0, major: 0, minor: 0 }, applied: { blocker: 0, major: 0, minor: 0 }, unique_applied: { blocker: 0, major: 0, minor: 0 }, deferred: { blocker: 0, major: 0, minor: 0 }, rejected: { blocker: 0, major: 0, minor: 1 } },
+  },
+};
+
+test("derive carries derived.council through like tests/diff; absent stays absent", () => {
+  const rec = newRecord({ spec: "doc/specs/a.md", session: "s1", now: "2026-09-17T10:00:00Z", runId: "r1" });
+  assert.equal(derive(rec, "2026-09-17T10:01:00Z").council, undefined);
+  rec.derived.council = COUNCIL;
+  assert.deepEqual(derive(rec, "2026-09-17T10:01:00Z").council, COUNCIL);
+});
+
+test("serializeRecord writes council.chair and each member as flow maps under block keys; parseRecord round-trips", () => {
+  const rec = newRecord({ spec: "doc/specs/a.md", session: "s1", now: "2026-09-17T10:00:00Z", runId: "r1" });
+  rec.derived.council = COUNCIL;
+  const text = serializeRecord(rec);
+  assert.match(text, /^  council:\n    chair: \{ model: p\/chair:medium, dispatches: 1, clusters: 2, members_reported: 2 \}\n    members:\n      p\/alpha:xhigh: \{ dispatches: 1, total: \{ blocker: 0, major: 1, minor: 1 \}/m);
+  assert.match(text, /^      p\/beta:high: \{ dispatches: 2, /m);
+  assert.deepEqual(parseRecord(text)!.derived.council, COUNCIL);
+  const plain = newRecord({ spec: "doc/specs/a.md", session: "s1", now: "2026-09-17T10:00:00Z", runId: "r2" });
+  assert.equal(parseRecord(serializeRecord(plain))!.derived.council, undefined);
+});

package/extensions/lib/telemetry-record.ts

@@ -1,6 +1,7 @@
 // Telemetry record model (#33): phases, events, accumulators, derive, YAML.
 import { Document, isCollection, isMap, isSeq, parse as parseYaml, stringify as stringifyYaml, type YAMLMap } from "yaml";
 import type { BucketStat, ShipOption } from "./telemetry-paths.ts";
+import type { CouncilBlock } from "./telemetry-council.ts";
 
 export const PHASES = ["brainstorm", "plan", "implement", "verify", "ship"] as const;
 export type Phase = (typeof PHASES)[number];
@@ -91,7 +92,7 @@ export interface Derived {
   duration_s: number; phases: Partial<Record<PhaseKey, PhaseAcc & { started_at?: string; completed_at?: string; duration_s?: number; model?: string; thinking?: string }>>;
   personas: Record<string, PersonaAcc>; reviews?: Record<string, ReviewAcc>; conformance_loops: number; conformance_open_gaps?: number; gates: Gates & { ship_option?: string };
   plan?: { tasks: number; complete: number; failed: number; skipped: number }; tests?: { command: string; result: "pass" | "fail" }; amendments: number;
-  spec_edits_after_ship: number; diff?: DiffSummary; modified_files?: string[]; spec_writes: Accumulators["spec_writes"]; events_dropped: number;
+  spec_edits_after_ship: number; diff?: DiffSummary; modified_files?: string[]; council?: CouncilBlock; spec_writes: Accumulators["spec_writes"]; events_dropped: number;
 }
 export type RecordStatus = "in_progress" | "shipped" | "abandoned";
 export interface TelemetryRecord {
@@ -121,7 +122,7 @@ export function derive(rec: TelemetryRecord, now: string): Derived {
   }
   for (const k of Object.keys(acc.phases) as PhaseKey[]) phases[k] = compact({ ...(phases[k] ?? {}), ...acc.phases[k] });
   const live = liveShipEvent(rec.events);
-  return compact({ duration_s: seconds(rec.created_at, rec.shipped_at ?? rec.abandoned_at ?? now), phases, personas: acc.personas, reviews: Object.keys(acc.reviews).length ? acc.reviews : undefined, conformance_loops: acc.conformance_loops, conformance_open_gaps: acc.conformance_open_gaps, gates: compact({ ...acc.gates, ship_option: live?.option }), plan: rec.derived.plan, tests: rec.derived.tests, amendments: acc.amendments, spec_edits_after_ship: acc.spec_edits_after_ship, diff: rec.derived.diff, modified_files: rec.derived.modified_files, spec_writes: acc.spec_writes, events_dropped: acc.events_dropped }) as Derived;
+  return compact({ duration_s: seconds(rec.created_at, rec.shipped_at ?? rec.abandoned_at ?? now), phases, personas: acc.personas, reviews: Object.keys(acc.reviews).length ? acc.reviews : undefined, conformance_loops: acc.conformance_loops, conformance_open_gaps: acc.conformance_open_gaps, gates: compact({ ...acc.gates, ship_option: live?.option }), plan: rec.derived.plan, tests: rec.derived.tests, amendments: acc.amendments, spec_edits_after_ship: acc.spec_edits_after_ship, diff: rec.derived.diff, modified_files: rec.derived.modified_files, council: rec.derived.council, spec_writes: acc.spec_writes, events_dropped: acc.events_dropped }) as Derived;
 }
 
 const stripUndefined = (v: unknown): unknown => {
@@ -156,7 +157,11 @@ export function serializeRecord(rec: TelemetryRecord): string {
   const body = stripUndefined({ ...head, derived, accumulators }) as Record<string, unknown>;
   const doc = new Document(body);
   const derivedNode = doc.get("derived", true);
-  if (isMap(derivedNode)) flowLeafChildren(derivedNode, new Set(["modified_files"]));
+  if (isMap(derivedNode)) {
+    flowLeafChildren(derivedNode, new Set(["modified_files", "council"]));
+    const council = derivedNode.get("council", true);
+    if (isMap(council)) flowLeafChildren(council);
+  }
   const accumulatorNode = doc.get("accumulators", true);
   if (isMap(accumulatorNode)) {
     for (const session of accumulatorNode.items) if (isMap(session.value)) flowLeafChildren(session.value);

package/extensions/telemetry.test.ts

@@ -511,6 +511,96 @@
 
   const subagentResult = (results: unknown[], content = "") => ({ toolName: "subagent", toolCallId: "sa", input: {}, content: [{ type: "text", text: content }], isError: false, details: { results } });
 
+  async function boundInBrainstorm() {
+    const h = harness();
+    await h.phaseResult("start", P({ brainstorm: "in_progress" }));
+    await h.writeSpec("doc/specs/a.md");
+    return h;
+  }
+  const memberBatch = (isError = false) => ({ ...subagentResult([
+    { agent: "spec-council-member", exitCode: 0, model: "p/alpha:xhigh", savedOutputPath: "/tmp/c/member-0-p-alpha.md", usage: usage(1) },
+    { agent: "spec-council-member", exitCode: 1, model: "p/beta:high", usage: usage(1) },
+    { agent: "spec-council-member", exitCode: 0, model: "p/beta:high", savedOutputPath: "/tmp/c/retry/member-1-p-beta-high.md", usage: usage(1) },
+  ]), isError });
+  const CHAIR_TEXT = "consensus: needs-work\nclusters:\n- [major] a - raised-by: [p-alpha] - x\n- [minor] b - raised-by: [p-alpha, p-beta-high] - x\nresolved:\n";
+  const chairResult = (text = CHAIR_TEXT, exitCode = 0) => ({ ...subagentResult([{ agent: "spec-council-synthesizer", exitCode, model: "p/chair:medium", usage: usage(1) }], text), isError: exitCode !== 0 });
+  const AUDIT_TEXT = "Applied: [major] a - raised-by: [p-alpha] -> edit\nDeferred: none\nRejected: [minor] b - raised-by: [p-alpha, p-beta-high] -> reason";
+  const assistant = (text: string) => ({ type: "message_end", message: { role: "assistant", usage: usage(1), content: [{ type: "text", text }] } });
+  const counts = (major = 0, minor = 0) => ({ blocker: 0, major, minor });
+  const EXPECTED_COUNCIL = {
+    chair: { model: "p/chair:medium", dispatches: 1, clusters: 2, members_reported: 2 },
+    members: {
+      "p/alpha:xhigh": { dispatches: 1, total: counts(1, 1), unique: counts(1), applied: counts(1), unique_applied: counts(1), deferred: counts(), rejected: counts(0, 1) },
+      "p/beta:high": { dispatches: 2, total: counts(0, 1), unique: counts(), applied: counts(), unique_applied: counts(), deferred: counts(), rejected: counts(0, 1) },
+    },
+  };
+
+  test("council captures failed member batch, chair, audit and persists on later flush", async () => {
+    const h = await boundInBrainstorm();
+    await h.emit("tool_result", memberBatch(true));
+    await h.emit("tool_result", chairResult());
+    assert.equal(h.readRecord().derived.council, undefined);
+    await h.emit("message_end", assistant(AUDIT_TEXT));
+    assert.deepEqual(h.readRecord().derived.council, EXPECTED_COUNCIL);
+    await h.phaseResult("complete", P({ brainstorm: "complete" }));
+    assert.deepEqual(h.readRecord().derived.council, EXPECTED_COUNCIL);
+    assert.equal(h.readRecord().derived.personas["spec-council-member"], undefined);
+  });
+  test("council defaults missing chair model and survives unrelated result before audit", async () => {
+    const h = await boundInBrainstorm();
+    await h.emit("tool_result", memberBatch());
+    await h.emit("tool_result", subagentResult([{ agent: "spec-council-synthesizer", exitCode: 0, usage: usage(1) }], CHAIR_TEXT));
+    await h.emit("tool_result", subagentResult([{ agent: "spec-summarizer", exitCode: 0, model: "p/s", usage: usage(1) }]));
+    await h.emit("message_end", assistant(AUDIT_TEXT));
+    assert.deepEqual(h.readRecord().derived.council, { ...EXPECTED_COUNCIL, chair: { ...EXPECTED_COUNCIL.chair, model: "unknown" } });
+  });
+  test("council ignores plan phase", async () => {
+    const h = await boundInPlan();
+    await h.emit("tool_result", memberBatch());
+    await h.emit("tool_result", chairResult());
+    await h.emit("message_end", assistant(AUDIT_TEXT));
+    assert.equal(h.readRecord().derived.council, undefined);
+  });
+  test("council counts failed chair retries and retains last usable clusters", async () => {
+    const h = await boundInBrainstorm();
+    await h.emit("tool_result", memberBatch());
+    await h.emit("tool_result", chairResult("Failed", 1));
+    await h.emit("tool_result", chairResult());
+    await h.emit("tool_result", chairResult("no consensus here", 1));
+    await h.emit("message_end", assistant(AUDIT_TEXT));
+    assert.deepEqual(h.readRecord().derived.council!.chair, { ...EXPECTED_COUNCIL.chair, dispatches: 3 });
+  });
+  test("council retains pending on incomplete audit and ignores audit before chair", async () => {
+    const h = await boundInBrainstorm();
+    await h.emit("message_end", assistant(AUDIT_TEXT));
+    await h.emit("tool_result", memberBatch());
+    await h.emit("tool_result", chairResult());
+    await h.emit("message_end", assistant("Applied: [major] a - raised-by: [p-alpha] -> edit\nDeferred: none\nRejected: none"));
+    assert.equal(h.readRecord().derived.council, undefined);
+    await h.emit("message_end", assistant("Applied: a -> edit\nDeferred: none\nRejected: none"));
+    assert.equal(h.readRecord().derived.council, undefined);
+    await h.emit("message_end", assistant(AUDIT_TEXT));
+    assert.deepEqual(h.readRecord().derived.council, EXPECTED_COUNCIL);
+  });
+  test("council reset clears pending and new member batch supersedes held chair", async () => {
+    const h = await boundInBrainstorm();
+    await h.emit("tool_result", memberBatch());
+    await h.emit("tool_result", chairResult());
+    await h.phaseResult("reset", P());
+    await h.phaseResult("start", P({ brainstorm: "in_progress" }));
+    await h.writeSpec("doc/specs/a.md");
+    await h.emit("message_end", assistant(AUDIT_TEXT));
+    assert.equal(h.readRecord().derived.council, undefined);
+    await h.emit("tool_result", memberBatch());
+    await h.emit("tool_result", chairResult());
+    await h.emit("tool_result", memberBatch());
+    await h.emit("message_end", assistant(AUDIT_TEXT));
+    assert.equal(h.readRecord().derived.council, undefined);
+    await h.emit("tool_result", chairResult());
+    await h.emit("message_end", assistant(AUDIT_TEXT));
+    assert.deepEqual(h.readRecord().derived.council, EXPECTED_COUNCIL);
+  });
+
   test("subagent results: dispatch events, persona tokens, spec_rounds, reviews, conformance_loops; async results: [] contribute nothing", async () => {
     const h = await boundInPlan();
     await h.emit("tool_result", subagentResult([

package/extensions/telemetry.ts

@@ -24,6 +24,7 @@
   import { COUNTED_USER_PHASES, REVIEWER_AGENTS, countFindings, countOpenGaps, hasReopen, insertedText, planTotals, textOf, usageToTokens } from "./lib/telemetry-collect.ts";
   import { addTokens, capEvents, compact, currentPhase, derive, diffPhases, emptyAccumulators, emptyPhases, foldAccumulators, implementAutoCompletes, liveShipEvent, newRecord, parseRecord, serializeRecord, type Accumulators, type BaseEvent, type PhaseAcc, type PhaseKey, type PhaseMap, type TelemetryEvent, type TelemetryRecord, type Tokens } from "./lib/telemetry-record.ts";
   import { guardReason } from "./lib/telemetry-ship.ts";
+  import { buildCouncil, parseAudit, parseChairReport, resolveMembers, type Cluster, type MemberResult } from "./lib/telemetry-council.ts";
 
   // ---- deps seam -------------------------------------------------------------------
 
@@ -204,6 +205,7 @@
     let settingsWarned = false;
     let sessionId = "";
     let currentDir = "";
+    let councilPending: { memberResults: MemberResult[]; chair?: { model: string; dispatches: number; clusters?: Cluster[] } } | undefined;
 
     // Per-event settings read; undefined => this event is a no-op.
     const enabledSettings = (ctx: ExtensionContext): SettingsSnapshot | undefined => {
@@ -364,6 +366,7 @@
       record = undefined;
       recordRel = undefined;
       frozen = false;
+      councilPending = undefined;
     };
 
     const isSafeSpecLink = (link: string): boolean => {
@@ -432,6 +435,7 @@
               ? { kind: "phase", action: "reset" }
               : { kind: "phase", action: t.action, name: t.name },
         );
+        if (t.action === "start" && t.name === "brainstorm") councilPending = undefined;
         phases = details.phases;
         if (record && t.name === "brainstorm" && (t.action === "complete" || t.action === "skip")) record.approved_at ??= e.ts;
         if (record && t.name === "ship" && t.action === "complete" && checkoutVia === "jj") await onShipKeep(snap);
@@ -538,8 +542,9 @@
         }
         return onSpecInteraction(event.toolName, loc, event, snap);
       }
-      if (event.toolName === "subagent" && !event.isError) {
-        await onSubagentResult(event.details, event.content);
+      if (event.toolName === "subagent") {
+        if (phaseNow() === "brainstorm") onCouncilResults(event.details, event.content);
+        if (!event.isError) await onSubagentResult(event.details, event.content);
         return undefined;
       }
       if (event.toolName === "plan_tracker" && !event.isError) {
@@ -625,6 +630,42 @@
       acc.tokens = addTokens(acc.tokens, t);
     };
 
+    const onCouncilResults = (details: unknown, content: unknown) => {
+      const results = (details as { results?: unknown[] } | undefined)?.results;
+      if (!Array.isArray(results) || !results.length) return;
+      const typed = results.map((raw) => raw as { agent?: unknown; exitCode?: unknown; model?: unknown; savedOutputPath?: unknown });
+      if (councilPending?.chair && typed.some((r) => r.agent === "spec-council-member")) councilPending = undefined;
+      for (const r of typed) {
+        if (r.agent === "spec-council-member") {
+          (councilPending ??= { memberResults: [] }).memberResults.push({
+            model: typeof r.model === "string" ? r.model : undefined,
+            exitCode: typeof r.exitCode === "number" ? r.exitCode : undefined,
+            savedOutputPath: typeof r.savedOutputPath === "string" ? r.savedOutputPath : undefined,
+          });
+        } else if (r.agent === "spec-council-synthesizer") {
+          const chair = ((councilPending ??= { memberResults: [] }).chair ??= { model: "unknown", dispatches: 0 });
+          if (typeof r.model === "string") chair.model = r.model;
+          chair.dispatches += 1;
+          const parsed = parseChairReport(textOf(content));
+          if (parsed) chair.clusters = parsed.clusters;
+        }
+      }
+    };
+
+    const onCouncilAudit = (content: unknown) => {
+      const pending = councilPending;
+      const clusters = pending?.chair?.clusters;
+      if (!record || !pending?.chair || !clusters) return;
+      const audit = parseAudit(textOf(content));
+      if (!audit) return;
+      const members = resolveMembers(pending.memberResults);
+      const block = members && buildCouncil({ chair: { ...pending.chair, clusters }, members, audit });
+      if (!block) return;
+      record.derived.council = block;
+      councilPending = undefined;
+      flush();
+    };
+
     const onSubagentResult = async (details: unknown, content: unknown) => {
       const results = (details as { results?: unknown[] } | undefined)?.results;
       if (!Array.isArray(results) || results.length === 0) return;
@@ -723,9 +764,10 @@
     pi.on("message_end", async (event, ctx) => {
       lastCtx = ctx;
       if (!enabledSettings(ctx)) return;
-      const msg = event.message as { role?: string; usage?: unknown };
+      const msg = event.message as { role?: string; usage?: unknown; content?: unknown };
       if (msg.role !== "assistant") return;
       addPhaseTokens(usageToTokens(msg.usage));
+      if (phaseNow() === "brainstorm") onCouncilAudit(msg.content);
     });
 
     pi.on("turn_end", async (_event, ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-gauntlet",
-  "version": "5.20.0",
+  "version": "5.21.0",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",

package/skills/brainstorming/SKILL.md

@@ -238,10 +238,10 @@ Paste the summary verbatim, unedited in the template below; use adjacent lines f
 Spec written and committed to <project>/doc/specs/<filename>.md (worktree: <path>).
 
 Coverage: <N> of <M> members reported; <slug>: <reason> (line present only when coverage was partial)
-Applied: <cluster -> edit>, ...
-Deferred: <cluster -> where it belongs>, ...
-Rejected: <cluster -> one-line reason>, ...
-(omit the audit lines above when the worker path ran, not the council)
+Applied: [<severity>] <cluster> — raised-by: [<slugs>] -> <edit>
+Deferred: [<severity>] <cluster> — raised-by: [<slugs>] -> <where it belongs>
+Rejected: [<severity>] <cluster> — raised-by: [<slugs>] -> <one-line reason>
+(one line per item, exactly as returned by roasting-the-spec - `Applied: none` / `Deferred: none` / `Rejected: none` when a list is empty; omit the audit lines when the worker path ran, not the council)
 
 <unresolved ambiguities; every gap-footer entry from the summary>
 

package/skills/gauntlet-performance/SKILL.md

@@ -18,13 +18,14 @@ The CLI parses and aggregates; you reason. Never open a telemetry YAML record yo
 
 ## Read the digest
 
-`runs` has one row per record; `shipped*` marks a truncated run (no ship phase recorded - an older salvage stamped it at landing; its `wall` is `-` and it feeds no aggregate). `by version` groups by pi-gauntlet version: `n` counts every row, `shipped` counts the rows behind the p50/max columns. `grants` is `fix_round_grants` - the fix-round proxy (human-granted extra review rounds); schema 1 has no code-review round count.
+`runs` has one row per record; `shipped*` marks a truncated run (no ship phase recorded - an older salvage stamped it at landing; its `wall` is `-` and it feeds no aggregate). `by version` groups by pi-gauntlet version: `n` counts every row, `shipped` counts the rows behind the p50/max columns. `grants` is `fix_round_grants` - the fix-round proxy (human-granted extra review rounds); schema 1 has no code-review round count. Read `council` by roster: counts are blocker/major/minor, `uniq_appl_nonminor/run` counts unique-and-applied blocker/major findings per run, and `chair:` summarizes synthesis and retries. Read severity as the chair's consolidated severity (the highest any co-raiser assigned), not the member's own. A roster with fewer than five runs is not assessed, and older records can have no council data.
 
 ## Reply - exactly this, in this order
 
 1. **Recommendation** (2-4 sentences). One claim, led by the run that exemplifies it: quote its `spec` slug, `run_id`, and the 1-3 numbers that carry the claim. When `grants` is the evidence, call it the fix-round proxy. If no version group has `shipped >= 2`, the recommendation is "sample too small" with the `n`/`shipped` counts per version.
 2. **Cornerstones**: 3-5 bullets of aggregate facts from `by version` - corpus size, truncated count, the p50s and model tallies that moved between versions.
-3. **Menu**, numbered, at most 3 items, rendered exactly as:
+3. **Council assessment**: Render this block independently of the version sample gate, even when item 1 says "sample too small". If the digest prints `no council data in selected records`, render only `council: no data`. If the most recent roster has fewer than 5 runs, render only `council: <roster> - not enough runs to assess (N of 5)`. Otherwise render one line per `flag:` of the most recent roster as the roster-change recommendations; when an older roster exists, add one line comparing the two rosters' `uniq_appl_nonminor/run` and rejected share as groups. Compare rosters as groups, never a member across rosters.
+4. **Menu**, numbered, at most 3 items, rendered exactly as:
    - `1. render report` - ask for a target path; write markdown there: the digest verbatim, then the recommendation and cornerstones above. If the file exists, ask before overwriting. Write nothing unless this item is chosen.
    - `2. open recommendation as ticket` - hand the claim and its numbers to `/skill:shape-ticket`; never create a ticket directly.
    - `3. drill into <slug>` - re-run the CLI with `--json` and show that run's fields.

package/skills/roasting-the-spec/SKILL.md

@@ -126,7 +126,7 @@ For each cluster in the chair's report, decide one of:
 
 Also inline any `external-ref:` cluster you have context for (e.g. a ticket fetched during brainstorming) as part of the apply-set — this is your call, same as any other cluster.
 
-An `over-spec:` cluster decided **apply** is executed as deletion or shrink of the quoted clause **and** any acceptance-criteria or testing-approach line that exists only for it. Its audit line reads `Applied: over-spec: <clause> -> cut (was adds: M files / N tests / K ACs)` or `Applied: over-spec: <clause> -> shrunk to <replacement> (was adds: ...)`, so the gate shows what was removed. `defer`/`reject` are unchanged.
+An `over-spec:` cluster decided **apply** is executed as deletion or shrink of the quoted clause **and** any acceptance-criteria or testing-approach line that exists only for it. Its audit line reads `Applied: [<severity>] over-spec: <clause> — raised-by: [<slugs>] -> cut (was adds: M files / N tests / K ACs)` or `Applied: [<severity>] over-spec: <clause> — raised-by: [<slugs>] -> shrunk to <replacement> (was adds: ...)`, so the gate shows what was removed. `defer`/`reject` are unchanged.
 
 You are the advocate — decide on scope grounds — and, unlike a dispatched subagent, also the executor: you hold `edit`/`write` tools directly, so apply the edit yourself instead of proposing it for someone else to make. Do this **before** returning to brainstorming.
 
@@ -135,9 +135,9 @@ You are the advocate — decide on scope grounds — and, unlike a dispatched su
 Return a structured audit, gate-only (not a committed spec section) — a coverage line plus three labelled lists:
 
 - `Coverage:` — `N of M members reported; <slug>: <reason>` — present only when member coverage was partial; omitted at full coverage.
-- `Applied:` — one of `Applied: <cluster> -> <edit> (grounded: <member probe>)`, `Applied: <cluster> -> <edit> (probed: <check> - <result>)` for a confirmed hypothesis, `Applied: <cluster> -> open question (<not found | inconclusive: <check> | contradicted: <result>>)`. The probe rides on the audit line because member files are removed in section 5.
-- `Deferred:` — cluster -> where it belongs.
-- `Rejected:` — cluster -> one-line reason.
+- `Applied:` — one line per applied cluster: `Applied: [<severity>] <cluster> — raised-by: [<slugs>] -> <edit> (grounded: <member probe>)`, `... -> <edit> (probed: <check> - <result>)` for a confirmed hypothesis, or `... -> open question (<not found | inconclusive: <check> | contradicted: <result>>)`. Copy `[<severity>]` and `raised-by: [...]` verbatim from the cluster line - telemetry joins on them. No applied cluster -> the single line `Applied: none`. The probe rides on the audit line because member files are removed in section 5.
+- `Deferred:` — one line per deferred cluster, same `[<severity>] <cluster> — raised-by: [<slugs>]` prefix, then `-> <where it belongs>`. None -> `Deferred: none`.
+- `Rejected:` — one line per rejected cluster, same prefix, then `-> <one-line reason>`. None -> `Rejected: none`.
 
 Hand this audit to brainstorming along with the now-final spec. brainstorming writes it into the **spec commit message body** (git-native, readable pre-squash) so it survives for finish-time revert visibility, then shows it to the user alongside the final spec at its one review gate. The user can revert any applied edit there — that gate, not this skill, is where ratification happens.