@cleocode/skills 2026.4.161 → 2026.5.1

package/skills/ct-council/references/peer-review.md

@@ -0,0 +1,125 @@
+# Shuffled Peer Review — Gate-Based Protocol
+
+The peer review is where frames collide productively. An advisor reviewing another advisor's output does NOT play neutral judge — they evaluate from their own locked frame, which is exactly what makes the shuffle informative. The Contrarian reviewing First Principles means: "Zero-based analysis sounds clean, but here's the failure mode you introduced by stripping context."
+
+This protocol replaces numeric scoring with **gate-based evaluation**. Each gate is pass/fail with required evidence. The reviewer must produce a quote or concrete citation to justify each gate decision. Theater ("4/5 — good") is structurally impossible.
+
+## The rotation (fixed, do not deviate)
+
+```
+Contrarian       → reviews → First Principles
+First Principles → reviews → Expansionist
+Expansionist     → reviews → Outsider
+Outsider         → reviews → Executor
+Executor         → reviews → Contrarian
+```
+
+**Properties:**
+- No self-review.
+- Every advisor reviews exactly once and is reviewed exactly once.
+- Single 5-cycle, not pairs — information flows around the full ring.
+
+**Why this specific rotation:**
+- *Contrarian → First Principles*: stress-tests whether atomic truths survive adversarial conditions.
+- *First Principles → Expansionist*: grounds ambitious upside against what's actually true.
+- *Expansionist → Outsider*: checks whether the cold-read missed an opportunity hiding in plain sight.
+- *Outsider → Executor*: the stranger asks "why *that* action?" — if it only makes sense with backstory, the Executor picked wrong.
+- *Executor → Contrarian*: forces risk analysis to cash out. Pure doom with no actionable mitigation is cheap.
+
+## The four gates
+
+Each gate is **strictly PASS or FAIL** — no middle states. The reviewer MUST provide the evidence the gate requires. A gate with no cited evidence is itself a validation failure.
+
+**No PARTIAL / MIXED / CONDITIONAL / "PARTIAL PASS" / hedged values are allowed.** The validator rejects any gate line not matching `- G<N> <dimension>: PASS — <evidence>` or `- G<N> <dimension>: FAIL — <evidence>`.
+
+If your judgment feels genuinely mixed — "the shape is right but the target is wrong", "it passes in spirit but not in letter", "mostly good except for one thing" — **pick FAIL** and express the nuance in the `Gap from <reviewer>'s frame` and `What I would add` fields. Those are exactly the fields the Chairman reads for texture. A FAIL with a rich gap note is more informative than a PARTIAL with thin justification, and it forces the reviewer to actually decide.
+
+The test: would you act on this advisor's verdict as-written, unconditionally? If yes → PASS. If no, no matter why → FAIL, then explain the condition in the gap note.
+
+### G1 — Rigor gate
+
+**PASS** if every finding in the reviewee's "Findings" list has a named subject, predicate, and (where the frame requires it) trigger condition. The reviewer MUST quote the strongest-rigor finding and, if any finding fails, the weakest.
+
+**FAIL** if any finding is hedged ("might", "could", "may" without concrete anchor), vague ("there are scalability concerns"), or missing the frame's required specifics (Contrarian without trigger condition; Executor without expected outcome; First Principles without atoms; Expansionist without asymmetry; Outsider without artifact citation).
+
+### G2 — Evidence-grounding gate
+
+**PASS** if every finding cites at least one item from the shared evidence pack, and every cited item actually exists in the pack. The reviewer MUST list all cited items.
+
+**FAIL** if any finding is free-floating (no citation), cites an item not in the pack, or cites something that does not support the finding. The reviewer MUST list ungrounded or misgrounded findings.
+
+### G3 — Frame-integrity gate
+
+**PASS** if no finding belongs to another advisor's lane. The reviewer MUST read the reviewee's persona file's "Your lane vs. other advisors' lanes" section and confirm.
+
+**FAIL** if any finding is something a different advisor would produce. The reviewer MUST name which frame the violating finding belongs to and quote the violating line.
+
+### G4 — Actionability gate
+
+**PASS** if the reviewee's verdict cashes out to a decision, a test, a change, or a concrete line of inquiry. The reviewer MUST quote the actionable part.
+
+**FAIL** if the verdict is "interesting" but leaves the owner nowhere to go. "Further analysis is warranted" fails. "Reject the plan unless X is added" passes.
+
+## Peer review output template
+
+**Destination:** when invoked as a Phase 2 subagent, save your full peer-review output below to `<run-dir>/peer-<reviewer-slug>-on-<reviewee-slug>.md` via the `Write` tool, then return only a one-line confirmation including the gate-pass count and disposition (e.g. `Wrote peer-contrarian-on-first-principles.md — 4/4 PASS, Disposition: Accept`). Do not include the full peer-review text in your reply — the orchestrator reads it back from the file.
+
+The gate-line format is **load-bearing** — `scripts/validate.py` parses these lines with a regex anchored to the canonical names below. Use them VERBATIM.
+
+| Gate | Canonical line prefix | Common mistakes (rejected) |
+|---|---|---|
+| G1 | `- G1 Rigor: PASS \| FAIL — ...` | `G1 Rigor gate:`, `G1: Rigor:`, `G1 - Rigor:` |
+| G2 | `- G2 Evidence grounding: PASS \| FAIL — ...` | `G2 Evidence-grounding gate:`, `G2: Evidence:` |
+| G3 | `- G3 Frame integrity: PASS \| FAIL — ...` | `G3 Frame-integrity gate:`, `G3: Frame:` |
+| G4 | `- G4 Actionability: PASS \| FAIL — ...` | `G4 Actionability gate:`, `G4: Actionability:` |
+
+The section headers below ("G1 — Rigor gate") use "gate" as a label *for the section*; the *gate verdict line* never does. The validator rejects gate verdict lines with the "gate" suffix because they break the canonical regex.
+
+```
+### <reviewer> reviewing <reviewee>
+
+**Gate results:**
+- G1 Rigor: PASS | FAIL — <quote of strongest finding; if FAIL, quote weakest and explain>
+- G2 Evidence grounding: PASS | FAIL — <list cited items; if FAIL, list ungrounded/misgrounded findings>
+- G3 Frame integrity: PASS | FAIL — <confirm lane; if FAIL, name the violating frame and quote the violating line>
+- G4 Actionability: PASS | FAIL — <quote the actionable part; if FAIL, explain what's missing>
+
+**Strongest finding (from reviewee):**
+<quote or close paraphrase of the one finding the reviewer thinks lands hardest, even from an opposing frame>
+
+**Gap from <reviewer>'s frame:**
+<the specific thing the reviewee missed that the reviewer's frame would have caught. Concrete — no "could have gone deeper".>
+
+**What I would add:**
+<one sentence from the reviewer's frame that sharpens or corrects the reviewee's analysis. Single value-add.>
+
+**Disposition:** Accept | Modify | Reject — <one sentence why>
+```
+
+## Hard rules
+
+- Reviewer MUST stay in their own frame. A Contrarian reviewing First Principles still looks for what breaks.
+- Reviewer MUST NOT produce a second copy of their own analysis. They evaluate the reviewee *through* their lens; they do not redo the work.
+- Agreement with the reviewee is allowed if it adds a cross-frame dimension ("the Contrarian confirms the atomic truth holds under adversarial pressure"). Pure agreement with no added dimension is a Frame-integrity violation — the reviewer did not do their job.
+- Every gate must have its required evidence. A naked "PASS" with no quote is itself a protocol violation caught by the validator.
+- **Disposition** forces a call: Accept, Modify, or Reject. No fence-sitting.
+
+## Convergence check (Phase 2.5, before the Chairman)
+
+After all five peer reviews complete, run the **convergence detector** before Phase 3:
+
+1. Extract the "Single sharpest point" from each of the 5 advisors.
+2. Pairwise-compare them. Are 3 or more semantically the same finding (same subject, same predicate)?
+3. If yes → **convergence flag**. The advisor(s) with the lowest gate-pass count are suspected of frame drift. Rerun those advisors with explicit frame-reinforcement (re-read persona file, emphasize the "Your lane vs. other advisors' lanes" section) before proceeding to Chairman.
+4. If no → proceed to Chairman.
+
+**Why this exists:** in single-Claude mode, the same model produces all 5 advisor outputs in one response and they tend to rhyme. The convergence detector is the structural antibody.
+
+**What "semantically the same" means:** if you can describe two findings with the same sentence and lose no essential content, they are convergent. "Retry storms are dangerous" and "the retry wrapper will cascade under load" are convergent. "Retry storms are dangerous" and "the plan omits idempotency classification" are not.
+
+## What the Chairman extracts from peer reviews
+
+- **Gate-pass count per advisor** (0–4). Advisors with 4/4 pass carry full weight. Advisors with gate failures are weighted proportionally down.
+- **Disposition distribution**: how many Accept / Modify / Reject across the 5 reviews. A review ring that's all Accept signals either genuinely strong work or insufficient friction (check G3 Frame-integrity results).
+- **Cross-frame additions**: the "What I would add" sentences — these often contain the material that makes the final verdict sharper than any single advisor.
+- **Convergence flag** (if raised): triggers a rerun; do not synthesize until resolved.

package/skills/ct-council/scripts/analyze_runs.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""
+analyze_runs.py — read council-runs.jsonl, surface where to harden next.
+
+Reports:
+  * gate-failure hotspots (which advisor fails which gate most),
+  * peer-review reject frequency (per reviewer + per reviewee),
+  * convergence-flag rate,
+  * Chairman confidence distribution + low-confidence question shapes,
+  * token / wall-clock distribution per scope tier (if metrics present),
+  * exit-criteria scorecard from the plan.
+
+Usage:
+  python3 analyze_runs.py                              # default log
+  python3 analyze_runs.py --log path/to/runs.jsonl
+  python3 analyze_runs.py --json
+  python3 analyze_runs.py --since 2026-04-24           # filter by timestamp prefix
+  python3 analyze_runs.py --tail 8                     # last N runs only
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import statistics
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+
+DEFAULT_LOG_PATH = Path(".cleo/council-runs.jsonl")
+ADVISORS = ["Contrarian", "First Principles", "Expansionist", "Outsider", "Executor"]
+GATES = ["G1", "G2", "G3", "G4"]
+
+
+def load_runs(path: Path, since: str | None = None, tail: int | None = None) -> list[dict]:
+    if not path.exists():
+        return []
+    runs: list[dict] = []
+    with path.open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rec = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if since and rec.get("timestamp", "") < since:
+                continue
+            runs.append(rec)
+    if tail:
+        runs = runs[-tail:]
+    return runs
+
+
+def gate_hotspots(runs: list[dict]) -> dict:
+    """Per (advisor, gate) FAIL count + rate."""
+    fail = Counter()
+    seen = Counter()
+    for r in runs:
+        for advisor, body in (r.get("advisors") or {}).items():
+            for gate in GATES:
+                verdict = (body.get("gates") or {}).get(gate)
+                if verdict in ("PASS", "FAIL"):
+                    seen[(advisor, gate)] += 1
+                    if verdict == "FAIL":
+                        fail[(advisor, gate)] += 1
+    rows = []
+    for key, total in seen.items():
+        f = fail[key]
+        rows.append({
+            "advisor": key[0],
+            "gate": key[1],
+            "fail": f,
+            "n": total,
+            "fail_rate": round(f / total, 3) if total else 0.0,
+        })
+    rows.sort(key=lambda x: (-x["fail_rate"], -x["fail"], x["advisor"], x["gate"]))
+    return rows
+
+
+def disposition_distribution(runs: list[dict]) -> dict:
+    by_reviewer = defaultdict(Counter)
+    by_reviewee = defaultdict(Counter)
+    overall = Counter()
+    for r in runs:
+        for pr in r.get("peer_reviews", []):
+            disp = pr.get("disposition") or "Unknown"
+            overall[disp] += 1
+            by_reviewer[pr["reviewer"]][disp] += 1
+            by_reviewee[pr["reviewee"]][disp] += 1
+    return {
+        "overall": dict(overall),
+        "by_reviewer": {k: dict(v) for k, v in by_reviewer.items()},
+        "by_reviewee": {k: dict(v) for k, v in by_reviewee.items()},
+    }
+
+
+def convergence_rate(runs: list[dict]) -> dict:
+    raised = sum(1 for r in runs if (r.get("convergence") or {}).get("flag") is True)
+    cleared = sum(1 for r in runs if (r.get("convergence") or {}).get("flag") is False)
+    unknown = sum(1 for r in runs if (r.get("convergence") or {}).get("flag") is None)
+    return {
+        "raised": raised,
+        "cleared": cleared,
+        "unknown": unknown,
+        "rate": round(raised / len(runs), 3) if runs else 0.0,
+    }
+
+
+def confidence_distribution(runs: list[dict]) -> dict:
+    counts = Counter()
+    low_conf_questions: list[str] = []
+    for r in runs:
+        conf = (r.get("chairman") or {}).get("confidence")
+        counts[conf or "missing"] += 1
+        if conf in ("low", "medium-low"):
+            low_conf_questions.append(r.get("question", ""))
+    return {
+        "counts": dict(counts),
+        "low_confidence_questions": low_conf_questions,
+    }
+
+
+def cost_distribution(runs: list[dict]) -> dict:
+    tokens = [r.get("metrics", {}).get("tokens") for r in runs if (r.get("metrics") or {}).get("tokens")]
+    walls = [r.get("metrics", {}).get("wall_clock_seconds") for r in runs if (r.get("metrics") or {}).get("wall_clock_seconds")]
+
+    def _summary(xs):
+        if not xs:
+            return None
+        return {
+            "n": len(xs),
+            "min": min(xs),
+            "max": max(xs),
+            "mean": round(statistics.mean(xs), 1),
+            "stdev": round(statistics.stdev(xs), 1) if len(xs) > 1 else 0.0,
+            "spread_pct": round(((max(xs) - min(xs)) / statistics.mean(xs)) * 100, 1) if statistics.mean(xs) else 0.0,
+        }
+
+    return {"tokens": _summary(tokens), "wall_clock_seconds": _summary(walls)}
+
+
+def exit_criteria(runs: list[dict]) -> dict:
+    """Scorecard against the plan's exit criteria."""
+    n = len(runs)
+
+    # 1. All shakedowns validate (here we don't know which run = which scenario,
+    #    but we report the structural-validity rate as a proxy).
+    valid_runs = sum(1 for r in runs if (r.get("validation") or {}).get("valid"))
+
+    # 2. Every advisor ≥3/4 average gate pass.
+    sums = defaultdict(list)
+    for r in runs:
+        for advisor, body in (r.get("advisors") or {}).items():
+            sums[advisor].append(body.get("gate_pass_count", 0))
+    advisor_avg = {a: round(statistics.mean(v), 2) for a, v in sums.items() if v}
+
+    # 3. Convergence flag fires at most once across the campaign.
+    convergence_raised = convergence_rate(runs)["raised"]
+
+    # 4. Chairman confidence ≥ medium-high on ≥6/8 runs.
+    high_or_above = sum(
+        1 for r in runs
+        if (r.get("chairman") or {}).get("confidence") in ("high", "medium-high")
+    )
+
+    # 5. Token cost stable within 20% per scope tier — proxy on overall spread.
+    tokens = [r.get("metrics", {}).get("tokens") for r in runs if (r.get("metrics") or {}).get("tokens")]
+    token_spread_ok = None
+    if tokens and len(tokens) > 1 and statistics.mean(tokens):
+        spread_pct = ((max(tokens) - min(tokens)) / statistics.mean(tokens)) * 100
+        token_spread_ok = spread_pct <= 20.0
+
+    return {
+        "n_runs": n,
+        "validate_pass_rate": round(valid_runs / n, 3) if n else 0.0,
+        "advisor_gate_avg": advisor_avg,
+        "advisor_gate_avg_min": min(advisor_avg.values()) if advisor_avg else None,
+        "convergence_raised": convergence_raised,
+        "high_or_above_confidence_runs": high_or_above,
+        "token_spread_within_20pct": token_spread_ok,
+        "checklist": {
+            "all_validate": valid_runs == n if n else False,
+            "every_advisor_avg_ge_3": all(v >= 3.0 for v in advisor_avg.values()) if advisor_avg else False,
+            "convergence_at_most_once": convergence_raised <= 1,
+            "high_or_above_ge_6_of_8": high_or_above >= 6 if n >= 8 else None,
+            "token_spread_ok": token_spread_ok,
+        },
+    }
+
+
+def render_report(report: dict) -> str:
+    lines = []
+    lines.append(f"# Council telemetry — {report['n_runs']} run(s)")
+    lines.append("")
+
+    lines.append("## Exit-criteria scorecard")
+    cl = report["exit_criteria"]
+    lines.append(f"- Validate pass rate: {cl['validate_pass_rate']*100:.0f}%")
+    lines.append(f"- Advisor avg gate-pass (≥3.0 target): {cl['advisor_gate_avg']}")
+    lines.append(f"- Convergence flags raised: {cl['convergence_raised']} (target ≤1)")
+    lines.append(f"- High/medium-high confidence: {cl['high_or_above_confidence_runs']}/{report['n_runs']} (target ≥6/8)")
+    spread = cl["token_spread_within_20pct"]
+    lines.append(f"- Token spread within 20%: {'yes' if spread else 'no' if spread is False else 'n/a (insufficient runs with token metrics)'}")
+    lines.append("")
+
+    lines.append("## Gate-failure hotspots (top 5)")
+    if not report["gate_hotspots"]:
+        lines.append("- No gate-fail data yet.")
+    else:
+        for row in report["gate_hotspots"][:5]:
+            if row["fail"] == 0:
+                continue
+            lines.append(
+                f"- {row['advisor']:<16} {row['gate']}  "
+                f"fail {row['fail']}/{row['n']}  ({row['fail_rate']*100:.0f}%)"
+            )
+        if all(r["fail"] == 0 for r in report["gate_hotspots"]):
+            lines.append("- 0 gate failures across all runs (suspicious — check whether reviewers are too lenient).")
+    lines.append("")
+
+    lines.append("## Peer-review disposition distribution")
+    disp = report["dispositions"]
+    lines.append(f"- Overall: {disp['overall']}")
+    lines.append("")
+
+    lines.append("## Convergence")
+    cv = report["convergence"]
+    lines.append(f"- Raised: {cv['raised']} | Cleared: {cv['cleared']} | Unknown: {cv['unknown']} (rate {cv['rate']*100:.0f}%)")
+    lines.append("")
+
+    lines.append("## Chairman confidence")
+    conf = report["confidence"]
+    lines.append(f"- Distribution: {conf['counts']}")
+    if conf["low_confidence_questions"]:
+        lines.append("- Low-confidence questions (candidates for documenting as 'not a good council fit'):")
+        for q in conf["low_confidence_questions"]:
+            lines.append(f"  - {q}")
+    lines.append("")
+
+    lines.append("## Cost (token + wall-clock summary)")
+    cost = report["cost"]
+    if cost["tokens"]:
+        t = cost["tokens"]
+        lines.append(f"- Tokens: n={t['n']} mean={t['mean']:.0f} stdev={t['stdev']:.0f} spread={t['spread_pct']}%")
+    else:
+        lines.append("- Tokens: no metrics recorded (pass --tokens to telemetry.py).")
+    if cost["wall_clock_seconds"]:
+        w = cost["wall_clock_seconds"]
+        lines.append(f"- Wall-clock: n={w['n']} mean={w['mean']}s stdev={w['stdev']}s")
+    else:
+        lines.append("- Wall-clock: no metrics recorded.")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def build_report(runs: list[dict]) -> dict:
+    return {
+        "n_runs": len(runs),
+        "gate_hotspots": gate_hotspots(runs),
+        "dispositions": disposition_distribution(runs),
+        "convergence": convergence_rate(runs),
+        "confidence": confidence_distribution(runs),
+        "cost": cost_distribution(runs),
+        "exit_criteria": exit_criteria(runs),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Analyze council-runs.jsonl telemetry.")
+    parser.add_argument("--log", default=str(DEFAULT_LOG_PATH), help=f"JSONL log path (default: {DEFAULT_LOG_PATH}).")
+    parser.add_argument("--json", action="store_true", help="Emit JSON report.")
+    parser.add_argument("--since", default=None, help="Only include runs with ISO timestamps ≥ this prefix.")
+    parser.add_argument("--tail", type=int, default=None, help="Only the last N runs.")
+    args = parser.parse_args()
+
+    runs = load_runs(Path(args.log), since=args.since, tail=args.tail)
+    report = build_report(runs)
+
+    if not runs:
+        print(f"⚠️  No runs found at {args.log}.", file=sys.stderr)
+        sys.exit(0)
+
+    if args.json:
+        print(json.dumps(report, indent=2, default=str))
+    else:
+        print(render_report(report))
+
+
+if __name__ == "__main__":
+    main()

package/skills/ct-council/scripts/fixtures/executor_multi.md

@@ -0,0 +1,198 @@
+# The Council — Should we add a retry-on-timeout wrapper to outbound HTTP calls?
+
+## Evidence pack
+
+1. `packages/core/src/http.ts:L12-L58` — current httpGet/httpPost.
+2. `packages/core/src/circuit-breaker.ts` — exists with zero callers.
+3. commit `a1b2c3d "drop retries from http client"` — retries removed 18 months ago.
+
+## Phase 1 — Advisor analyses
+
+### Advisor: Contrarian
+
+**Frame:** Assume the plan is wrong.
+
+**Evidence anchored:**
+- commit `a1b2c3d` — retries were pulled for a documented reason.
+- `packages/core/src/http.ts` — zero per-caller rate limits.
+
+**Verdict from this lens:** Plan re-introduces known incident class.
+
+**Single sharpest point:** Retry wrapper without breaker reproduces old bug.
+
+### Advisor: First Principles
+
+**Frame:** Ignore everything.
+
+**Evidence anchored:**
+- RFC 7231.
+- `packages/core/src/http.ts:L12-L58`.
+
+**Verdict from this lens:** Plan incomplete.
+
+**Single sharpest point:** Non-idempotent requests cannot be blindly retried.
+
+### Advisor: Expansionist
+
+**Frame:** Forget the constraints.
+
+**Evidence anchored:**
+- `packages/core/src/circuit-breaker.ts`.
+- `MEMORY.md`.
+
+**Verdict from this lens:** Owner thinking too small.
+
+**Single sharpest point:** Wire the circuit breaker.
+
+### Advisor: Outsider
+
+**Frame:** You have no context.
+
+**Evidence anchored:**
+- `packages/core/src/circuit-breaker.ts` — zero callers.
+- `docs/adr/ADR-021-http-client.md`.
+
+**What the artifact claims vs. shows:** Claims await breaker; shows breaker has landed.
+
+**Verdict from this lens:** Project prepared but didn't close the loop.
+
+**Single sharpest point:** ADR says do this when breaker lands; it has landed.
+
+### Advisor: Executor
+
+**Frame:** Don't analyze.
+
+**Evidence anchored:**
+- `packages/core/test/http.test.ts`.
+- `packages/core/src/circuit-breaker.ts`.
+
+**The action (one):**
+1. Write a failing test.
+2. Implement the retry wrapper.
+3. Add circuit breaker wiring.
+
+**Expected outcome (60 minutes from now):**
+Many things happen.
+
+**What this unblocks:**
+All subsequent work.
+
+**Verdict from this lens:** Lots to do.
+
+**Single sharpest point:** Do three things simultaneously.
+
+## Phase 2 — Shuffled peer reviews
+
+### Contrarian reviewing First Principles
+
+**Gate results:**
+- G1 Rigor: PASS — specific.
+- G2 Evidence grounding: PASS — cited.
+- G3 Frame integrity: PASS — in lane.
+- G4 Actionability: PASS — decidable.
+
+**Strongest finding (from reviewee):** Idempotency.
+
+**Gap from Contrarian's frame:** None.
+
+**What I would add:** Nothing.
+
+**Disposition:** Accept — holds.
+
+### First Principles reviewing Expansionist
+
+**Gate results:**
+- G1 Rigor: PASS — specific.
+- G2 Evidence grounding: PASS — cited.
+- G3 Frame integrity: PASS — in lane.
+- G4 Actionability: PASS — decidable.
+
+**Strongest finding (from reviewee):** Asset wiring.
+
+**Gap from First Principles' frame:** None.
+
+**What I would add:** Nothing.
+
+**Disposition:** Accept — holds.
+
+### Expansionist reviewing Outsider
+
+**Gate results:**
+- G1 Rigor: PASS — specific.
+- G2 Evidence grounding: PASS — cited.
+- G3 Frame integrity: PASS — in lane.
+- G4 Actionability: PASS — decidable.
+
+**Strongest finding (from reviewee):** ADR gap.
+
+**Gap from Expansionist's frame:** None.
+
+**What I would add:** Nothing.
+
+**Disposition:** Accept — holds.
+
+### Outsider reviewing Executor
+
+**Gate results:**
+- G1 Rigor: FAIL — three actions listed, not one.
+- G2 Evidence grounding: PASS — cited.
+- G3 Frame integrity: FAIL — multiple actions violates Executor frame.
+- G4 Actionability: FAIL — action is ambiguous.
+
+**Strongest finding (from reviewee):** Writing the test is still valid.
+
+**Gap from Outsider's frame:** Executor frame requires exactly one action.
+
+**What I would add:** Nothing.
+
+**Disposition:** Reject — frame violation.
+
+### Executor reviewing Contrarian
+
+**Gate results:**
+- G1 Rigor: PASS — specific.
+- G2 Evidence grounding: PASS — cited.
+- G3 Frame integrity: PASS — in lane.
+- G4 Actionability: PASS — decidable.
+
+**Strongest finding (from reviewee):** Retry storm.
+
+**Gap from Executor's frame:** No mitigation named.
+
+**What I would add:** Wire breaker first.
+
+**Disposition:** Accept — risk real.
+
+## Phase 2.5 — Convergence check
+
+No convergence.
+
+## Phase 3 — Chairman's verdict
+
+### Gate summary
+
+| Advisor | G1 | G2 | G3 | G4 | Weight |
+|---|---|---|---|---|---|
+| Contrarian       | PASS | PASS | PASS | PASS | full |
+| First Principles | PASS | PASS | PASS | PASS | full |
+| Expansionist     | PASS | PASS | PASS | PASS | full |
+| Outsider         | PASS | PASS | PASS | PASS | full |
+| Executor         | FAIL | PASS | FAIL | FAIL | low |
+
+### Recommendation
+Rerun Executor.
+
+### Why this, not the alternatives
+Executor violated frame.
+
+### What each advisor got right
+See above.
+
+### Conditions on the recommendation
+Rerun required.
+
+### Next 60-minute action
+Rerun the Executor pass with explicit one-action constraint.
+
+### Confidence
+Medium — four frames solid, one rerun needed.