@cleocode/skills 2026.5.4 → 2026.5.6

package/skills/ct-council/optimization/scripts/test_campaign.py

@@ -1,143 +0,0 @@
-"""Tests for the YAML-driven scenario loader in campaign.py."""
-
-from __future__ import annotations
-
-import json
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from unittest import mock
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-sys.path.insert(0, str(SCRIPT_DIR))
-
-# Import after path injection.
-import campaign  # noqa: E402
-
-
-class TestScenarioLoader(unittest.TestCase):
-    """Verify scenarios.yaml drives campaign.py without code edits."""
-
-    def test_default_load_returns_scenarios(self):
-        # The committed scenarios.yaml should produce ≥1 scenario.
-        scenarios = campaign._load_scenarios()
-        self.assertGreater(len(scenarios), 0)
-        for s in scenarios:
-            self.assertIsInstance(s, campaign.Scenario)
-            self.assertTrue(s.id)
-            self.assertTrue(s.title)
-
-    def test_default_scenarios_are_sorted_by_number(self):
-        scenarios = campaign._load_scenarios()
-        numbers = [s.number for s in scenarios]
-        self.assertEqual(numbers, sorted(numbers))
-
-    def test_default_scenarios_have_unique_ids(self):
-        scenarios = campaign._load_scenarios()
-        ids = [s.id for s in scenarios]
-        self.assertEqual(len(ids), len(set(ids)), f"Duplicate scenario IDs: {ids}")
-
-    def test_yaml_load_picks_up_appended_scenario(self):
-        # Write a custom scenarios.yaml in a temp dir and point loader at it.
-        with tempfile.TemporaryDirectory() as tmp:
-            yaml_path = Path(tmp) / "scenarios.yaml"
-            yaml_path.write_text(
-                "schema_version: \"1.0.0\"\n"
-                "scenarios:\n"
-                "  - id: alpha\n"
-                "    number: 1\n"
-                "    title: Alpha\n"
-                "    dimension: dim\n"
-                "    shape: shape\n"
-                "    learn: learn\n"
-                "    briefing: |\n"
-                "      Alpha briefing.\n"
-                "  - id: beta\n"
-                "    number: 99\n"
-                "    title: Beta\n"
-                "    dimension: dim\n"
-                "    shape: shape\n"
-                "    learn: learn\n"
-                "    briefing: |\n"
-                "      Beta briefing.\n"
-            )
-            with mock.patch.object(campaign, "SCENARIOS_YAML_PATH", yaml_path), \
-                 mock.patch.object(campaign, "SCENARIOS_JSON_PATH", Path(tmp) / "nope.json"):
-                scenarios = campaign._load_scenarios()
-        self.assertEqual([s.id for s in scenarios], ["alpha", "beta"])
-        self.assertEqual(scenarios[1].number, 99)
-
-    def test_json_fallback_when_yaml_missing(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            json_path = Path(tmp) / "scenarios.json"
-            json_path.write_text(json.dumps({
-                "schema_version": "1.0.0",
-                "scenarios": [
-                    {"id": "json-only", "number": 1, "title": "T", "dimension": "d",
-                     "shape": "s", "learn": "l", "briefing": "b"},
-                ],
-            }))
-            with mock.patch.object(campaign, "SCENARIOS_YAML_PATH", Path(tmp) / "missing.yaml"), \
-                 mock.patch.object(campaign, "SCENARIOS_JSON_PATH", json_path):
-                scenarios = campaign._load_scenarios()
-        self.assertEqual([s.id for s in scenarios], ["json-only"])
-
-    def test_skips_scenarios_with_missing_required_fields(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            yaml_path = Path(tmp) / "scenarios.yaml"
-            yaml_path.write_text(
-                "scenarios:\n"
-                "  - id: good\n"
-                "    number: 1\n"
-                "    title: Good\n"
-                "    dimension: d\n"
-                "    shape: s\n"
-                "    learn: l\n"
-                "    briefing: b\n"
-                "  - id: bad-missing-briefing\n"
-                "    number: 2\n"
-                "    title: Bad\n"
-                "    dimension: d\n"
-                "    shape: s\n"
-                "    learn: l\n"
-            )
-            with mock.patch.object(campaign, "SCENARIOS_YAML_PATH", yaml_path), \
-                 mock.patch.object(campaign, "SCENARIOS_JSON_PATH", Path(tmp) / "nope.json"):
-                scenarios = campaign._load_scenarios()
-        self.assertEqual([s.id for s in scenarios], ["good"])
-
-    def test_fallback_when_no_yaml_or_json_exists(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            with mock.patch.object(campaign, "SCENARIOS_YAML_PATH", Path(tmp) / "x.yaml"), \
-                 mock.patch.object(campaign, "SCENARIOS_JSON_PATH", Path(tmp) / "x.json"):
-                scenarios = campaign._load_scenarios()
-        # _FALLBACK_SCENARIOS provides exactly one entry.
-        self.assertEqual(len(scenarios), 1)
-        self.assertEqual(scenarios[0].id, "baseline")
-
-    def test_yaml_briefing_preserves_multiline_format(self):
-        scenarios = campaign._load_scenarios()
-        # The committed scenarios.yaml has multi-line briefings — confirm preserved.
-        baseline = next((s for s in scenarios if s.id == "baseline"), None)
-        if baseline:
-            self.assertIn("\n", baseline.briefing,
-                          "Multi-line briefings should preserve newlines from YAML literal block.")
-
-
-class TestNoSkippedScenarioNumbers(unittest.TestCase):
-    """Soft policy: numbers should be 1..N without gaps for human readability,
-    but the loader allows gaps. This test documents the convention without enforcing it."""
-
-    def test_committed_scenarios_have_contiguous_numbers(self):
-        scenarios = campaign._load_scenarios()
-        if len(scenarios) <= 1:
-            self.skipTest("Only fallback scenario loaded")
-        numbers = [s.number for s in scenarios]
-        expected = list(range(numbers[0], numbers[0] + len(numbers)))
-        self.assertEqual(numbers, expected,
-                         f"Committed scenarios.yaml has gaps in numbering: {numbers}")
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/skills/ct-council/references/chairman.md

@@ -1,119 +0,0 @@
-# The Chairman — Synthesis Protocol
-
-The Chairman is the sixth and final voice. Not one of the five advisors. Not a neutral arbiter. The Chairman reads all five analyses, all five gate-based peer reviews, and produces *one* clear verdict the owner can act on.
-
-The Chairman is an owner-surrogate. Their job is to do what a thoughtful decision-maker would do after hearing all five frames and their cross-checks: **decide**.
-
-## Prerequisites — do NOT begin synthesis if any of these are violated
-
-1. Phase 0 evidence pack has ≥3 items, each with file/symbol/sha + rationale.
-2. All 5 advisor sections exist and pass their own structural checks.
-3. All 5 peer reviews exist, matching the fixed rotation, each with gate results + disposition.
-4. The convergence detector (Phase 2.5) has been run. If it flagged convergence, the convergent advisors have been rerun and the new outputs re-reviewed.
-
-If any prerequisite fails, refuse to synthesize. Name what's missing and stop. The validator (`scripts/validate.py`) checks all four prerequisites automatically — run it on the output before writing the verdict.
-
-## What the Chairman reads
-
-1. The restated question (Phase 0).
-2. The evidence pack.
-3. All five advisor analyses (Phase 1).
-4. All five peer reviews with gate results (Phase 2).
-
-Nothing else. The Chairman does NOT re-run the analysis from scratch, does NOT add new advisor perspectives, and does NOT introduce findings that were not surfaced by an advisor or peer reviewer. The Chairman **selects, weights, reconciles, and decides**.
-
-## Synthesis procedure
-
-Work through these steps in order. Don't skip.
-
-### Step 1 — Compute per-advisor weights from gate results
-
-For each advisor, count the number of peer-review gates passed (0–4):
-
-- **4 passes**: full weight. This advisor's verdict pulls hardest on the synthesis.
-- **3 passes**: high weight.
-- **2 passes**: moderate weight. Read their single sharpest point carefully, but discount their broader verdict.
-- **0–1 passes**: low weight. Surface their sharpest point in the "What each advisor got right" section for completeness, but do not let their verdict drive the recommendation.
-
-This is not a popularity contest. An advisor can be right at 2/4 — the weight adjusts how much their verdict pulls, not whether it's heard.
-
-### Step 2 — Map convergence, contention, singletons
-
-- **Convergence**: every finding where ≥2 advisors from different frames reached the same conclusion. These are high-confidence claims.
-- **Contention**: every finding where advisors disagreed. List each contested point and name the frame on each side.
-- **Singletons**: findings only one advisor surfaced. Often the most valuable — a Contrarian-only risk or an Expansionist-only opportunity.
-
-### Step 3 — Reconcile each contested point
-
-For every contested item, pick a side or a synthesis, and state **why** in terms of which frame applies more strongly to the owner's actual question.
-
-There is no "both are valid". Pick.
-
-Good reconciliation pattern: *"The Contrarian flagged X as a fatal flaw; the Expansionist treated it as acceptable cost for opportunity Y. For the owner's question — [restate] — the Contrarian's frame applies because [specific reason tied to the question]. Verdict: X must be mitigated before Y is pursued."*
-
-### Step 4 — Produce the verdict
-
-Use the template below. The verdict MUST:
-
-- State a **single clear recommendation** on the first line. No fence-sitting. If the honest answer is "not enough information to decide", say so and name exactly what information would unlock the decision.
-- Carry the **single sharpest point from each of the five advisors** forward, so the final artifact surfaces all five lenses to the owner.
-- End with the **Executor's 60-minute next action** verbatim (or a modified version if peer review punctured the original).
-- Name a **confidence rating**: low / medium / high, with a one-sentence justification of what would raise or lower it.
-
-## Chairman verdict template
-
-```
-## Phase 3 — Chairman's Verdict
-
-### Gate summary
-| Advisor | G1 Rigor | G2 Evidence | G3 Frame | G4 Actionability | Weight |
-|---|---|---|---|---|---|
-| Contrarian       | PASS/FAIL | PASS/FAIL | PASS/FAIL | PASS/FAIL | full/high/moderate/low |
-| First Principles | PASS/FAIL | PASS/FAIL | PASS/FAIL | PASS/FAIL | full/high/moderate/low |
-| Expansionist     | PASS/FAIL | PASS/FAIL | PASS/FAIL | PASS/FAIL | full/high/moderate/low |
-| Outsider         | PASS/FAIL | PASS/FAIL | PASS/FAIL | PASS/FAIL | full/high/moderate/low |
-| Executor         | PASS/FAIL | PASS/FAIL | PASS/FAIL | PASS/FAIL | full/high/moderate/low |
-
-### Recommendation
-<one or two sentences. Single clear position. No hedging.>
-
-### Why this, not the alternatives
-<3–5 sentences. Name the contested points and how you reconciled them. Show your work.>
-
-### What each advisor got right (carried forward)
-- **Contrarian's fatal flaw to mitigate:** <one sentence from Contrarian's sharpest point>
-- **First Principles' atomic truth worth protecting:** <one sentence from First Principles' sharpest point>
-- **Expansionist's upside to pursue (or defer):** <one sentence from Expansionist's sharpest point>
-- **Outsider's pattern flag:** <one sentence from Outsider's sharpest point>
-- **Executor's action (validated or modified):** <one sentence from Executor's sharpest point, adjusted for peer review if needed>
-
-### Conditions on the recommendation
-<any "yes, if..." or "no, unless..." qualifiers. If none, say "Unconditional.">
-
-### Next 60-minute action
-<exactly one action. Startable now. Unambiguous.>
-
-### Confidence
-<low | medium | high> — <one sentence: what would raise or lower this confidence?>
-
-### Open questions for the owner
-<0–3 bullets. Only include if the Chairman genuinely needs owner input. Otherwise leave empty.>
-```
-
-## Tiebreaker rules (when gates and weights leave it genuinely 50/50)
-
-In order of precedence:
-
-1. **Evidence-grounding wins.** The advisor whose claims were more tightly anchored to the evidence pack gets the nod.
-2. **Reversibility wins.** Prefer the recommendation whose outcome is more reversible if wrong. (Bezos "two-way door".)
-3. **Align with the owner's stated question.** Some advisors' concerns, while valid, address a *different* question than the one asked. Stay on question.
-4. **Defaults:** Contrarian on safety; Executor on speed; First Principles on correctness. Use only if 1–3 tied.
-
-## Anti-patterns
-
-- Verdict that reads like a summary of the five advisors. That's what the prior phases were for. The Chairman **decides**.
-- "Further analysis recommended" as the final line. If more analysis is genuinely needed, name **exactly what** would close the gap and what the decision will be conditional on.
-- Averaging the advisors' verdicts. The frames are categorically different; you don't average a risk score with an opportunity score.
-- Ignoring gate failures. If an advisor's Frame-integrity gate failed, their verdict is compromised — surface the sharpest point but weight the verdict low.
-- Discovering a new consideration the advisors missed. If this happens, note it and rerun the council — do not smuggle Chairman-originated analysis into the verdict.
-- Writing the verdict before the convergence check (Phase 2.5) has run. The check may require rerunning advisors; a verdict written over convergent outputs is invalid.

package/skills/ct-council/references/contrarian.md

@@ -1,70 +0,0 @@
-# The Contrarian
-
-**You are the Contrarian.** You are the risk analyst and devil's advocate. You assume the plan is wrong and work backward to where it breaks.
-
-## Frame line (state verbatim at the top of your output)
-
-> Assume the plan is wrong. What fails first? What's been overlooked? Why is this a worse idea than it looks?
-
-## Your lane vs. other advisors' lanes
-
-You find **failure modes**. You do NOT find:
-- **Correctness errors** — that's First Principles' job (e.g., "the plan violates idempotency" is a correctness error, not a failure mode).
-- **Claim/reality gaps** — that's the Outsider's job (e.g., "the docs say X but the code shows Y" is an artifact observation, not a failure).
-- **Opportunities, hidden upside, asymmetric bets** — that's the Expansionist's job. You never propose them.
-- **Actions** — that's the Executor's job. You name the failure; the Executor names what to do about it.
-
-The single distinguishing test: your finding must name **what goes wrong at runtime / under load / over time / under human pressure**. If the finding would be true even if no one ever ran the code, it belongs to a different advisor.
-
-## Mandate
-
-- Treat the proposal as already broken and work backward to where it breaks.
-- Name the single first thing that goes wrong in production, under load, after a month, when the one person who understands it leaves, or when the cheap path ("just do X") gets taken by a future maintainer.
-- Challenge every claim of "this is safe / simple / obvious" with a concrete counterexample from the evidence pack.
-- Find the assumption that would invalidate the entire plan if false — and name it explicitly.
-
-**Your "single sharpest point" is always a fatal flaw with a named trigger condition.** "It might have problems" is not a finding. "It fails when the retry wrapper meets a non-idempotent POST and the caller deduplicates on HTTP status alone" is a finding.
-
-## Hard rules (peer review will check these)
-
-- MUST find at least one concrete failure mode. "Looks fine" fails the Rigor gate.
-- MUST NOT propose upside, opportunities, actions, or correctness re-derivations.
-- MUST NOT hedge. Replace "might" / "could" / "may" with "will, when X".
-- MUST anchor each claim to the evidence pack with a specific file:line, commit sha, or symbol name.
-- MUST name the **trigger condition** (the concrete circumstance that realizes the failure) for each finding.
-
-## What the Contrarian specifically looks for
-
-- **Load / scale cliffs** — fine until they aren't.
-- **Concurrency / ordering** — races, retries, duplicate writes, out-of-order events.
-- **Failure cascades** — one dependency dies, what dies with it.
-- **Rollback paths** — exists? tested?
-- **Operational blind spots** — who pages at 3am; what they see; whether they can act.
-- **"One person" risk** — design that only works if a specific human remembers something.
-- **Assumption stacking** — two or three individually-safe assumptions that multiply to high P(fail).
-- **Silent failure modes** — system keeps appearing to work while producing wrong answers.
-
-## Your output (use this template verbatim)
-
-**Destination:** when invoked as a Phase 1 subagent, save your full output below to `<run-dir>/phase1-contrarian.md` via the `Write` tool, then return only a one-line confirmation. Do not include the full advisor analysis in your reply text — the orchestrator reads it back from the file at assembly time.
-
-```
-### Advisor: Contrarian
-
-**Frame:** Assume the plan is wrong. What fails first? What's been overlooked? Why is this a worse idea than it looks?
-
-**Evidence anchored:**
-- <file:line | commit | symbol> — <why this matters to my frame>
-- <file:line | commit | symbol> — <why this matters to my frame>
-- (at least two)
-
-**Findings (failure modes, from my frame only):**
-1. **<short name>** — triggers when <trigger condition>. Fails by <concrete failure>. Detected by <what operators would see, or "silently">.
-2. ...
-3. ...
-(1–3 findings. Stop unless a distinct failure mode demands a fourth.)
-
-**Verdict from this lens:** <1–3 sentences. If there's a fatal flaw, the verdict reflects it.>
-
-**Single sharpest point:** <one sentence. The fatal flaw, with its trigger condition. The Chairman carries this forward.>
-```

package/skills/ct-council/references/evidence-pack.md

@@ -1,145 +0,0 @@
-# Phase 0 — Building the Evidence Pack
-
-The evidence pack is the factual ground all five advisors stand on. If it's thin, every downstream phase is thin. If it's padded, advisors drown in irrelevant material. Aim for **3–7 items**, each directly load-bearing for the owner's question.
-
-Every advisor cites from this pack. Peer reviewers check grounding *against* this pack. The Chairman's tiebreaker rules reference "evidence-grounding". Investing here pays off everywhere downstream.
-
-## The Phase 0 gate (structural — validator-enforced)
-
-Phase 1 MUST NOT begin until Phase 0 produces:
-
-1. **A restated question** — one sentence, testable decision shape.
-2. **An evidence pack of 3–7 items**, each consisting of:
-   - A citation (`path:line-range` | `symbol` | `sha` | URL)
-   - A one-line rationale ("why this matters to the question")
-
-If either condition is unmet, the validator reports a structural failure and the advisors refuse to run. This is non-negotiable — Phase 0 is the anchor for frame integrity in Phase 1 and gate scoring in Phase 2.
-
-## What goes in the evidence pack
-
-Each item is one of:
-
-| Type | Format | Example |
-|---|---|---|
-| File slice | `path/to/file.ts:L123-L150` | `packages/core/src/store.ts:L44-L89` |
-| Symbol | `symbolName` (function / class / type) | `validateEnvelope`, `StoreClient.put` |
-| Commit | `<short-sha> <one-line summary>` | `4f4426ad9 clean-forward purge of dogfood special cases` |
-| Test | `path/to/test.ts::test name` | `packages/cleo/test/brain.test.ts::verifyAndStore` |
-| External contract | URL + one-line what it asserts | `ADR-055 — worktree canonicalization` |
-| Data point | metric / measurement + source | `BRAIN has 2440 noise patterns (MEMORY.md line 98)` |
-| Compressed external doc | `llmtxt:<slug>[@<version>]` — fetched via `scripts/llmtxt_ref.py` | `llmtxt:drizzle-orm-v1@beta.3` |
-
-Each item gets a **one-line "why this matters"** annotation. Without it, advisors won't know which lens to apply.
-
-## The `llmtxt:` item type — for external docs, APIs, and specs
-
-When a question touches an external library, API, or standard that the advisors need to cite but the full text would bloat the evidence pack (especially in subagent mode where 5 advisors each receive the pack), use the `llmtxt:<slug>[@<version>]` item type. The `scripts/llmtxt_ref.py` wrapper fetches a compressed overview from api.llmtxt.my and caches it locally.
-
-**Fetch and paste:**
-
-```bash
-# Anonymous read (public docs — wrapper persists the anonymous session cookie automatically)
-python3 .claude/skills/council/scripts/llmtxt_ref.py <slug>
-
-# Pinned version (cached indefinitely; immutable)
-python3 .claude/skills/council/scripts/llmtxt_ref.py <slug>@<version>
-
-# Private / org docs require an API key
-LLMTXT_API_KEY="llmtxt_<43-char-token>" python3 .claude/skills/council/scripts/llmtxt_ref.py <slug>
-```
-
-**Caching (automatic):**
-- `<slug>@<version>` → cached indefinitely under `~/.cache/council/llmtxt/<slug>/<version>.md` (immutable per service contract).
-- `<slug>` (latest) → cached 60s to catch lifecycle state transitions.
-- Override cache directory with `COUNCIL_CACHE_DIR`.
-
-**When to use this item type:**
-- Question involves an external library, SDK, API, or spec whose docs are load-bearing.
-- Multiple advisors will cite the same external source (5× distribution in subagent mode compounds the savings).
-- The source has a stable slug + version in the llmtxt catalog.
-
-**When NOT to use it:**
-- The reference is already in your local codebase (use `path:line`).
-- The reference is a git commit (use the sha directly).
-- The source isn't in the llmtxt catalog (use a regular URL citation with a one-line summary).
-
-**Rate limits to respect** (api.llmtxt.my):
-- Anonymous per-IP: 60 reads/min.
-- Session-authenticated: 300/min.
-- API-key Bearer: 600/min.
-- Wrapper surfaces `x-ratelimit-*` warnings to stderr and honors `retry-after` on 429.
-
-## How to build it
-
-Do this in order. Stop when you have 3–7 solid items.
-
-1. **Parse the owner's question.** Extract key nouns — subsystem names, file paths, symbol names, ADR numbers, task IDs. Each noun is a candidate search anchor.
-
-2. **Pull the most recent changes.** `git log -20 --oneline` in the relevant paths, or `git log --follow -- <path>`. Anything touched in the last few commits is load-bearing for the question.
-
-3. **Use the best available intelligence tool.**
-   - **If `gitnexus` MCP is indexed**: `gitnexus_query({query: "<the owner's question, rephrased as a concept>"})` returns process-grouped execution flows. Then `gitnexus_context({name: "<main symbol>"})` for 360-view. Then `gitnexus_impact({target: "<symbol>", direction: "upstream"})` if the question involves modifying something.
-   - **Otherwise**: `grep -rn --include='*.ts' '<keyword>'` for keyword anchors, then `Read` the top hits at relevant line ranges.
-
-4. **Check for ADRs, memory, and docs.** Search `docs/adr/`, `.cleo/memory*`, any referenced `.md` files. Contracts and prior decisions are disproportionately load-bearing for council questions.
-
-5. **Sanity-check with tests.** If a subsystem is involved, find its tests and confirm the current contract. Tests document claimed behavior better than code comments.
-
-## What belongs in the pack vs. what doesn't
-
-**Include** — items that advisors from more than one frame will cite:
-- Core code path being discussed (Contrarian finds risks; First Principles checks atomicity; Executor picks an action on it).
-- Most recent commit touching it (Outsider spots drift from stated intent; Contrarian checks regression risk).
-- The test or assertion that defines its contract (First Principles' atomic truth candidate; Contrarian's "what breaks this" target).
-- The relevant ADR or memory entry (Expansionist spots latent capability; Outsider spots claim/reality gaps).
-
-**Exclude** — items only one frame would care about:
-- Ambient project lore not touching the question.
-- "Everything that mentions X" dumps — noise.
-- Speculative or future code that doesn't exist yet.
-- The owner's plan itself (that's the thing *being reviewed*, not evidence advisors ground in — keep it separate at the top).
-
-## The restated question
-
-At the top of the evidence pack, restate the owner's question in **one sentence**. All advisors anchor to this. If you can't compress the question into one sentence, the question is too fuzzy — clarify with the owner before running the council.
-
-A good restated question:
-- Has a subject (the thing being decided).
-- Has a binary or short-list decision shape ("should we X?", "is Y ready to ship?", "which of A/B/C?").
-- Is testable — you'd recognize an answer when you saw it.
-
-A bad restated question:
-- "What do you think about X?" (no decision shape)
-- "Review the codebase" (no scope)
-- "Make X better" (no success criterion)
-
-## Phase 0 fact-check (added after shakedown #8 caught a fabricated stat)
-
-**If the restated question contains any quantitative claim about the codebase, prior runs, or external data — "X happens N% of the time", "the historical mean is N", "S1-S5 averaged 6.4 items", "70% of users hit this path" — that claim MUST resolve to a citation in the evidence pack itself.**
-
-In shakedown #8, the orchestrator's question framing said *"S1-S5 averaged 6.4 items"*; the cited `council-runs.jsonl` actually showed all five runs at 7 items (mean 7.0). The Outsider was the only advisor whose frame *required* verifying the cited artifact, and only Outsider caught it — the other four reasoned downstream from a fabricated premise. The pre-action verification rule for the Executor (instituted in shakedown #1) protects the *action* against fabricated paths but does NOT extend upstream to the *question framing*; this gate fills that gap.
-
-Rule: every quantitative claim in the restated question must have a corresponding evidence-pack item that, when read, supports the claim. If the supporting data lives in `.cleo/council-runs.jsonl`, cite that file as a pack item and (in the rationale) name the specific values being claimed. If the supporting data does not exist anywhere in the project, either (a) measure it before running the council and cite the new artifact, or (b) restate the question without the unverifiable quantification.
-
-Anti-patterns this gate catches:
-- "Average 6.4 items" with the jsonl never read.
-- "Most teams use X" with no survey/data citation.
-- "This pattern fails 30% of the time" with no postmortem citation.
-- "S1-S5 showed Y" without a per-run breakdown that demonstrates Y.
-
-The Outsider remains the structural backstop, but with this gate the orchestrator should rarely hand the council a question that needs the backstop.
-
-## Output format for Phase 0 (validator-checked)
-
-```
-# The Council — <one-line restated question>
-
-## Evidence pack
-
-1. `<path:line-range | symbol | sha | URL>` — <why this matters to the question>
-2. `<path:line-range | symbol | sha | URL>` — <why this matters to the question>
-3. ...
-(3–7 items)
-```
-
-Nothing else in Phase 0. No opinions, no framing, no narrative. Just the pack. The advisors read only the question and the pack before forming their views.