@event4u/agent-config 1.16.0 → 1.18.0

package/scripts/ai_council/one_off_archive/2026-05/_one_off_phase_2a_post_revert.py

@@ -0,0 +1,197 @@
+"""Council adjudication of post-revert always-budget contract.
+
+Phase 2A executed R4 (revert) per the prior council verdict. The
+three slimmed always-rules and their mechanics contexts have been
+restored; mechanics-context directory removed. Measured state on
+this branch is now 47,448 / 49,000 chars = 96.8 % — strictly better
+than `main` at 100.6 % which currently passes via the G3 tolerance
+band.
+
+The strict 90 % FAIL gate in scripts/check_always_budget.py was
+written assuming Phase 2A would succeed in dropping utilization
+below 90 %. Phase 2A is now structurally infeasible under model (b)
+(per the previous council finding) and the cap-tightening was
+deferred to Phase 5. Branch must unblock CI without regressing the
+contract spirit.
+
+Council task: pick the smallest viable reconciliation.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from scripts.ai_council.bundler import bundle_files
+from scripts.ai_council.clients import (
+    AnthropicClient,
+    OpenAIClient,
+    load_anthropic_key,
+    load_openai_key,
+)
+from scripts.ai_council.orchestrator import (
+    CostBudget,
+    CouncilQuestion,
+    consult,
+    estimate,
+)
+from scripts.ai_council.pricing import estimate_cost, load_prices
+from scripts.ai_council.project_context import detect_project_context
+from scripts.ai_council.session import SessionManifest, save as save_session
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+ARTEFACTS = [
+    REPO_ROOT / "docs/contracts/load-context-budget-model.md",
+    REPO_ROOT / "scripts/check_always_budget.py",
+]
+
+ORIGINAL_ASK = (
+    "Phase 2A reverted (R4) per prior council verdict. Branch budget is "
+    "96.8 % (gap-zone FAIL); main is 100.6 % (PASS via G3 band). Branch "
+    "is strictly better than main yet rejected by the strict 90 % gate. "
+    "Pick the smallest contract reconciliation to unblock CI."
+)
+
+REVIEW_PROMPT = """\
+# Council Adjudication — Post-Revert Always-Budget Reconciliation
+
+## Current state (after R4 revert is committed locally)
+
+```
+FAIL  always-rule extended budget: 47,448 / 49,000 chars (96.8%)
+      thresholds: warn 80% · fail 90% · per-rule ≤ 6,000 (ext) ·
+                  top-3 ≤ 24,500 (ext) · depth ≤ 2 · G3 band ≤ +2%
+```
+
+`main` (last green): **49,311 / 49,000 = 100.6 %** — passes because
+the linter only rejects 90–100 % (gap zone) and > 102 %; 100–102 %
+is the documented G3 tolerance band.
+
+This branch is objectively closer to the cap than `main` but
+rejected. The 90 % gate was written under the assumption Phase 2A
+would land below 90 %. Phase 2A is structurally infeasible under
+model (b) (prior council finding); roadmap re-routes the trim to
+Phase 5 via either model (c) shared-divisor or shared-mechanics
+consolidation.
+
+## Fixed option set (pick exactly one)
+
+- **A1 — Recovery-band carve-out.** Extend the linter so "current
+  pct ≤ last-green-`main` pct AND pct ≤ 100 %" becomes a documented
+  `WARN (recovery band)`, not FAIL. Persists until Phase 5
+  re-tightens. No baseline regression possible; needs `main`-pct
+  lookup (committed scalar in repo or CI artifact).
+- **A2 — Lower FAIL_THRESHOLD to 100 %.** Drop the 90 % gate to
+  match the contract's spirit ("< cap is acceptable; > cap +2 %
+  fails"). Phase 5 re-tightens to 85 %/95 % per its own task list.
+  Smallest diff. Risk: removes the early-warning gate.
+- **A3 — Trim ~3.4k chars from current rules.** Find another
+  candidate (none of the three Phase-2A targets, since 2A proved
+  extraction adds overhead). Risk: the next-largest rules touch
+  the safety floor (Q3=A locked).
+- **A4 — Bump TOTAL_CAP to 53,000 + keep 90 % FAIL.** Rewrites the
+  contract's total cap upward; freezes current state at ~89.5 %.
+  Defers Phase 5 trim to a separate roadmap. Cleanest CI but
+  contract drift.
+- **A5 — Mark phase as `irreducible-at-current-method` and freeze
+  the linter at current state.** Pin a `CURRENT_BASELINE = 47_448`
+  ceiling alongside the 90 % gate; PASS while pct ≤ baseline,
+  FAIL on regression. Deflects Phase 5 work upstream into model (c).
+
+## Constraints
+
+- Safety-floor rules (`non-destructive-by-default`, `commit-policy`,
+  `scope-control`, `verify-before-complete`) are Q3=A locked and
+  may not be slimmed.
+- `road-to-structural-optimization` Phase 5 owns the long-term
+  trim — do not duplicate work into Phase 2A.
+- The four other phases (1, 2B, 3, 4, 6) on this branch are
+  blocked by this CI gate; the choice gates roadmap throughput.
+
+## Output Contract (STRICT)
+
+```
+### Verdict
+**Choice:** <A1 | A2 | A3 | A4 | A5>
+**One-sentence rationale:** <≤ 30 words>
+```
+
+```
+### Required follow-up actions (numbered, ≤ 4)
+  1. <smallest concrete step, files named>
+  2. <...>
+```
+
+```
+### Risk note
+**Single biggest risk of the chosen option:** <one sentence>
+**Mitigation:** <one sentence>
+```
+
+```
+### Contract amendment needed?
+**Amend load-context-budget-model.md?** <YES — section · NO>
+**Amend road-to-structural-optimization Phase 5 success criterion?**
+  <YES — new criterion in 1 line · NO>
+```
+
+Be decisive — total response ≤ 800 words. Artefacts follow verbatim.
+"""
+
+
+def main() -> int:
+    anthropic = AnthropicClient(api_key=load_anthropic_key(), model="claude-sonnet-4-5")
+    openai = OpenAIClient(api_key=load_openai_key(), model="gpt-4o")
+    members = [anthropic, openai]
+
+    context = bundle_files(ARTEFACTS)
+    project = detect_project_context(REPO_ROOT)
+    table = load_prices()
+
+    user_prompt = REVIEW_PROMPT + "\n\n---\n\n" + context.text
+
+    question = CouncilQuestion(mode="files", user_prompt=user_prompt, max_tokens=2048)
+    estimates = estimate(question, members, table, project=project, original_ask=ORIGINAL_ASK)
+    print("=== ESTIMATE (single round) ===")
+    total_est = 0.0
+    for c, e in zip(members, estimates):
+        print(f"  {c.name}/{c.model}: ~{e.input_tokens} in + {e.output_tokens} out = ${e.total_usd:.4f}")
+        total_est += e.total_usd
+    print(f"  TOTAL per round (max): ${total_est:.4f}")
+
+    budget = CostBudget(max_input_tokens=200_000, max_output_tokens=80_000, max_calls=20, max_total_usd=2.50)
+    rounds_collected: list[list] = []
+
+    def _on_round_complete(round_idx, round_responses) -> None:
+        rounds_collected.append(list(round_responses))
+        print(f"=== ROUND {round_idx + 1} COMPLETE ===")
+        for r in round_responses:
+            if r.error:
+                print(f"  [error] {r.provider}/{r.model}: {r.error}")
+                continue
+            a = estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, table)
+            print(f"  [done] {r.provider}/{r.model}: {r.input_tokens} in / {r.output_tokens} out · ${a.total_usd:.4f}")
+
+    print("=== CONSULT (1 round, post-revert reconciliation) ===")
+    consult(members, question, budget, rounds=1, on_round_complete=_on_round_complete,
+            table=table, project=project, original_ask=ORIGINAL_ASK)
+    if not rounds_collected:
+        return 1
+    actual = sum(estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, table).total_usd
+                 for rr in rounds_collected for r in rr if not r.error)
+    print(f"=== TOTAL ACTUAL: ${actual:.4f} ===")
+    final = rounds_collected[-1]
+    if not [r for r in final if not r.error]:
+        return 1
+    manifest = SessionManifest(
+        mode="files", artefact="agents/roadmaps/road-to-structural-optimization.md",
+        original_ask=ORIGINAL_ASK, members=[f"{r.provider}/{r.model}" for r in final],
+        rounds=len(rounds_collected), cost_usd_estimated=total_est, cost_usd_actual=actual,
+        extra={"purpose": "Post-revert always-budget contract reconciliation"},
+    )
+    sd = save_session(manifest=manifest, responses=rounds_collected)
+    print(f"[saved] {sd.relative_to(REPO_ROOT)}/")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/ai_council/one_off_archive/2026-05/_one_off_rule_hardening_v1.py

@@ -0,0 +1,251 @@
+"""Council review of road-to-rule-hardening.md v1.
+
+Three independent self-check rules silently skipped within one
+session despite being valid, loaded, and active. Host agent drafted
+a 6-phase lightweight roadmap proposing a 3-tier hardening model
+(Mechanical / Nudge / Inherent-soft).
+
+Council task: validate the architecture and the pilot order before
+the host agent autonomously implements Tier 1 hooks.
+
+Invocation:
+    .venv/bin/python -m scripts.ai_council._one_off_rule_hardening_v1
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from scripts.ai_council.bundler import bundle_prompt
+from scripts.ai_council.clients import (
+    AnthropicClient,
+    OpenAIClient,
+    load_anthropic_key,
+    load_openai_key,
+)
+from scripts.ai_council.orchestrator import (
+    CostBudget,
+    CouncilQuestion,
+    consult,
+    estimate,
+)
+from scripts.ai_council.pricing import estimate_cost, load_prices
+from scripts.ai_council.project_context import detect_project_context
+from scripts.ai_council.session import SessionManifest, save as save_session
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+ROADMAP_PATH = REPO_ROOT / "agents/roadmaps/road-to-rule-hardening.md"
+
+ORIGINAL_ASK = (
+    "Three independent self-check rules silently skipped within one "
+    "session: model-recommendation (task-start gate), context-hygiene "
+    "(turn-count handoff), roadmap-progress-sync (file-write side "
+    "effect). All valid, loaded, active. Host agent drafted a 6-phase "
+    "lightweight roadmap proposing a 3-tier hardening model. Council "
+    "task: validate the architecture and the pilot ordering before "
+    "implementation."
+)
+
+PROMPT_HEADER = """\
+# Council Review — road-to-rule-hardening.md v1
+
+## Background (verbatim, do not re-frame)
+
+Within a single session the host agent observed three rules failing
+the same way:
+
+| Rule | Trigger that should have fired | What happened |
+|---|---|---|
+| `model-recommendation` | Opus recommendation at task-start | silently skipped |
+| `context-hygiene` | Handoff at turn-count >= 20/40/60 | silently skipped |
+| `roadmap-progress-sync` | Regenerate dashboard on roadmap touch | silently skipped |
+
+All three are valid auto-load rules in `.augment/rules/`, all three
+are part of the active rule set surfaced to the agent. None of them
+fired. Hypothesis: they share a structural property — the trigger
+is observable only inside the agent, the check runs in the agent's
+head, no deterministic gate sits between decision and output. When
+the agent is in flow (multi-tool work, file edits, council
+orchestration), the self-check is the first thing to be dropped.
+
+The host agent drafted a 6-phase lightweight roadmap proposing a
+3-tier model:
+
+- **Tier 1 — Mechanical.** Hook + deterministic check.
+  Agent-independent.
+- **Tier 2 — Nudge.** Hook detects, marker injected, agent
+  formulates the response.
+- **Tier 3 — Inherent soft.** No platform mechanism exists. Either
+  accept as self-check, convert to user-invoked `/`-command, or
+  deprecate.
+
+Pilot order proposed by user: roadmap-progress-sync (1) → onboarding-gate
+(3) → context-hygiene (2). Hook surface available today: Augment
+PostToolUse / Stop, Claude Code Stop / SessionStart. Cursor / Cline /
+Windsurf parity is explicitly out of scope for this roadmap.
+
+Existing precedent: `chat-history-cadence` is the only rule already
+mechanically hardened (heartbeat marker pattern). Inventory:
+57 rules total, 18 contain self-check phrases (`MUST`, `MANDATORY`,
+`pre-send`, `before drafting`), 6 mention hooks today.
+
+## Your task
+
+Review road-to-rule-hardening.md v1 (full text appended below).
+Be adversarial — the host will autonomously execute the pilots, so
+catch architectural mistakes now, not after Phase 4.
+
+1. **Three-tier model:** is Mechanical / Nudge / Inherent-soft the
+   right partition, or does it collapse meaningful distinctions?
+   Specifically: should "Tier 2 Nudge" exist at all, or is it just a
+   weaker Tier 1?
+2. **Pilot order (1, 3, 2):** does roadmap-progress-sync prove the
+   pattern, or is it too narrow to generalise? Is per-turn counter
+   (context-hygiene) actually feasible cross-platform, or should it
+   move to Tier 3?
+3. **Failure-class generalisation:** are there self-check rules in
+   the inventory that the audit will MISS because they fire so
+   rarely the agent has not yet observed a skip? Name 1-2 likely
+   candidates.
+4. **Cross-platform scope:** roadmap defers Cursor/Cline/Windsurf.
+   Is this honest scope or hidden tech debt that will silently
+   block Phase 4 rollout?
+5. **Tier 3 disposition:** the roadmap allows accept-as-soft as a
+   valid disposition. Is that a real choice, or a way to declare
+   victory without solving anything?
+
+## Output contract (STRICT)
+
+For EACH of the six phases:
+
+```
+### Phase N — <title>
+
+**Verdict:** <ACCEPT | PARTIAL | REJECT>
+**What v1 gets right (1 sentence):** ...
+**What v1 misses or over-reaches (1-2 sentences):** ...
+**Concrete change to v2 (binding):** ...
+```
+
+Then five answers to the questions above (numbered 1-5, ≤ 3 sentences
+each).
+
+Then a final block:
+
+```
+### Greenlight verdict
+
+<one of: FULL GREENLIGHT — proceed with pilots / CONDITIONAL GREENLIGHT
+— apply N revisions then proceed / BLOCKED — major rework needed>
+
+**Binding revisions for v2 (numbered, ≤ 6):** ...
+**Pilot order recommendation:** <1,3,2 | 1,2,3 | 3,1,2 | other>
+**One-line architectural risk you would still proceed with:** ...
+```
+
+Total response budget: ≤ 1500 words. Do not re-write the roadmap.
+"""
+
+
+def _read(path: Path) -> str:
+    return path.read_text(encoding="utf-8") if path.exists() else ""
+
+
+def main() -> int:
+    anthropic = AnthropicClient(api_key=load_anthropic_key(), model="claude-sonnet-4-5")
+    openai = OpenAIClient(api_key=load_openai_key(), model="gpt-4o")
+    members = [anthropic, openai]
+
+    roadmap_text = _read(ROADMAP_PATH)
+    if not roadmap_text:
+        print(f"[error] roadmap not found: {ROADMAP_PATH}", file=sys.stderr)
+        return 1
+
+    bundle_text = "\n\n---\n\n".join([
+        PROMPT_HEADER,
+        "## Roadmap v1 (verbatim, the artefact to validate)\n\n" + roadmap_text,
+    ])
+    context = bundle_prompt(bundle_text)
+    project = detect_project_context(REPO_ROOT)
+    table = load_prices()
+
+    question = CouncilQuestion(
+        mode="prompt",
+        user_prompt=context.text,
+        max_tokens=4096,
+    )
+
+    estimates = estimate(
+        question, members, table, project=project, original_ask=ORIGINAL_ASK,
+    )
+    print("=== ESTIMATE (single round, max tokens) ===")
+    total_est = 0.0
+    for c, e in zip(members, estimates):
+        print(f"  {c.name}/{c.model}: ~{e.input_tokens} in + {e.output_tokens} out = ${e.total_usd:.4f}")
+        total_est += e.total_usd
+    print(f"  TOTAL per round (max): ${total_est:.4f}")
+    print()
+
+    budget = CostBudget(
+        max_input_tokens=200_000,
+        max_output_tokens=80_000,
+        max_calls=20,
+        max_total_usd=2.50,
+    )
+
+    rounds_collected: list[list] = []
+
+    def _on_round_complete(round_idx: int, round_responses) -> None:
+        rounds_collected.append(list(round_responses))
+        print(f"=== ROUND {round_idx + 1} COMPLETE ===")
+        for r in round_responses:
+            if r.error:
+                print(f"  [error] {r.provider}/{r.model}: {r.error}")
+                continue
+            actual = estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, table)
+            print(f"  [done] {r.provider}/{r.model}: {r.input_tokens} in / "
+                  f"{r.output_tokens} out · {r.latency_ms} ms · ${actual.total_usd:.4f}")
+        print()
+
+    print("=== CONSULT (1 round) ===")
+    consult(
+        members, question, budget,
+        rounds=1,
+        on_round_complete=_on_round_complete,
+        table=table, project=project, original_ask=ORIGINAL_ASK,
+    )
+
+    if not rounds_collected:
+        print("[error] no rounds completed", file=sys.stderr)
+        return 1
+
+    actual_total = 0.0
+    for round_responses in rounds_collected:
+        for r in round_responses:
+            if r.error:
+                continue
+            actual = estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, table)
+            actual_total += actual.total_usd
+    print(f"=== TOTAL ACTUAL: ${actual_total:.4f} ===")
+
+    final_round = rounds_collected[-1]
+    if not [r for r in final_round if not r.error]:
+        return 1
+
+    manifest = SessionManifest(
+        mode="prompt",
+        artefact=str(ROADMAP_PATH.relative_to(REPO_ROOT)),
+        original_ask=ORIGINAL_ASK,
+        members=[f"{r.provider}/{r.model}" for r in final_round],
+        rounds=len(rounds_collected),
+        cost_usd_estimated=total_est,
+        cost_usd_actual=actual_total,
+        extra={"purpose": "Council review of road-to-rule-hardening v1"},
+    )
+    session_dir = save_session(manifest=manifest, responses=rounds_collected)
+    print(f"[saved] {session_dir.relative_to(REPO_ROOT)}/")
+    return 1 if any(r.error for round_r in rounds_collected for r in round_r) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/ai_council/one_off_archive/2026-05/_one_off_structural_open_questions.py

@@ -0,0 +1,232 @@
+"""One-off council run for the three open questions in road-to-structural-optimization.md v2.
+
+Forces a STRUCTURED multiple-choice verdict per question across 2 rounds
+(debate mode). Saves the session under agents/council-sessions/.
+
+Invocation:
+    .venv/bin/python -m scripts.ai_council._one_off_structural_open_questions
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from scripts.ai_council.bundler import bundle_roadmap
+from scripts.ai_council.clients import (
+    AnthropicClient,
+    OpenAIClient,
+    load_anthropic_key,
+    load_openai_key,
+)
+from scripts.ai_council.orchestrator import (
+    CostBudget,
+    CouncilQuestion,
+    consult,
+    estimate,
+)
+from scripts.ai_council.pricing import estimate_cost, load_prices
+from scripts.ai_council.project_context import detect_project_context
+from scripts.ai_council.session import SessionManifest, save as save_session
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+ROADMAP_PATH = REPO_ROOT / "agents/roadmaps/road-to-structural-optimization.md"
+
+ORIGINAL_ASK = (
+    "Lock the three open design questions on road-to-structural-optimization.md v2 "
+    "with binding A/B verdicts + 2-3 sentence rationale each. The roadmap text "
+    "is the context. Be decisive — say A or B (or C with new option). Avoid "
+    "'depends' or 'further investigation needed'."
+)
+
+OPEN_QUESTIONS_PROMPT = """\
+# Lock-the-Decision Council Round
+
+You have already reviewed road-to-structural-optimization.md v2 in two prior \
+rounds (architectural / sequencing critique). The roadmap author now needs \
+**binding verdicts** on the three open design questions. Stop re-reviewing the \
+roadmap. Pick A, B, or propose C with explicit justification.
+
+## Output Contract (STRICT)
+
+For each question, produce exactly this block:
+
+```
+### Q<n>: <short title>
+
+**Verdict:** <A | B | C>
+**Confidence:** <Low | Medium | High>
+**Rationale (2-4 sentences):** <why this option, what failure mode of the other you avoid>
+**Risk if wrong:** <one sentence — what breaks if your verdict is the wrong call>
+**Rollback if wrong:** <one sentence — how to recover if production reveals the choice was bad>
+```
+
+If you propose C (new option), keep the same block structure.
+
+## Q1 — Phase 3a Skill Consolidation Shape
+
+The four `judge-*` skills (`judge-bug-hunter`, `judge-code-quality`, \
+`judge-security-auditor`, `judge-test-coverage`) share procedure but \
+have distinct persona voices. Two consolidation shapes:
+
+- **A.** Keep four separate skills. Extract the shared procedure to \
+  `contexts/judges/judge-shared-procedure.md`. Each skill's SKILL.md \
+  loads the context via `load_context:` and adds its persona-specific \
+  delta (review heuristics, persona prompt, examples).
+- **B.** Single skill `judge` with `mode:` parameter \
+  (`mode: bug-hunter | code-quality | security-auditor | test-coverage`). \
+  One SKILL.md dispatches; persona contexts live at \
+  `contexts/judges/personas/<mode>.md` and are loaded based on `mode:`.
+
+**Decision criterion:** which preserves persona voice better at LLM \
+runtime, and which is more maintainable when a fifth judge persona is \
+added in 6 months?
+
+## Q2 — Phase 6 chat-history Rule Consolidation Shape
+
+Three rules (`chat-history-cadence`, `chat-history-ownership`, \
+`chat-history-visibility`) overlap on triggers and surface but each \
+encodes a distinct concern. Two consolidation shapes:
+
+- **A.** One rule `chat-history` + three contexts \
+  (`contexts/chat-history/cadence.md`, `.../ownership.md`, \
+  `.../visibility.md`). The rule body holds the unified trigger language \
+  and routes to the right context section based on the matched anchor.
+- **B.** Router rule `chat-history` + three thin specialist rules \
+  (`chat-history-cadence` etc.) reduced to <30 LOC each. Router fires \
+  first, dispatches to one specialist based on signal type \
+  (heartbeat / ownership-detection / cadence-decision).
+
+**Decision criterion:** which is more maintainable when a fourth concern \
+(e.g., `chat-history-archive` for log rotation) is added in 12 months, \
+and which has lower cognitive load for an agent reading the rule first \
+time mid-task?
+
+## Q3 — Phase 5 Safety-Floor Rule Endorsement
+
+Phase 5 tightens the always-rule budget. The four safety-floor rules are:
+
+- `non-destructive-by-default` (~4,607 chars)
+- `commit-policy` (~2,800 chars)
+- `scope-control` (~3,900 chars)
+- `verify-before-complete` (~3,200 chars)
+
+Should these be in scope for slimming?
+
+- **A.** Endorse keeping all four UNTOUCHED. Slimming risks weakening Iron \
+  Laws under budget pressure. Phase 5 hits target without them.
+- **B.** Allow slimming with stricter 2A.4-style obligation-diff (every \
+  MUST/NEVER preserved verbatim, mechanics moved to context). Treat them \
+  like normal always-rules.
+
+**Decision criterion:** is the marginal budget gain worth the residual \
+risk of an Iron Law regression slipping through the obligation-diff \
+gate?
+
+## Final Output
+
+After the three blocks, add:
+
+```
+### Cross-question coupling
+
+<2-3 sentences: do your verdicts on Q1/Q2/Q3 reinforce or conflict with \
+each other? Are there hidden dependencies between them?>
+```
+
+Do not write an executive summary. Do not re-review v2. Pick, justify, \
+ship. Total response budget: ≤ 1500 words.
+"""
+
+
+def main() -> int:
+    anthropic = AnthropicClient(api_key=load_anthropic_key(), model="claude-sonnet-4-5")
+    openai = OpenAIClient(api_key=load_openai_key(), model="gpt-4o")
+    members = [anthropic, openai]
+
+    context = bundle_roadmap(ROADMAP_PATH)
+    project = detect_project_context(REPO_ROOT)
+    table = load_prices()
+
+    user_prompt = OPEN_QUESTIONS_PROMPT + "\n\n---\n\n" + context.text
+
+    question = CouncilQuestion(
+        mode="roadmap",
+        user_prompt=user_prompt,
+        max_tokens=4096,
+    )
+
+    estimates = estimate(
+        question, members, table, project=project, original_ask=ORIGINAL_ASK,
+    )
+    print("=== ESTIMATE (single round, max tokens) ===")
+    total_est = 0.0
+    for c, e in zip(members, estimates):
+        print(f"  {c.name}/{c.model}: ~{e.input_tokens} in + {e.output_tokens} out = ${e.total_usd:.4f}")
+        total_est += e.total_usd
+    print(f"  TOTAL per round (max): ${total_est:.4f}")
+    print(f"  TOTAL 2 rounds (max): ${total_est * 2:.4f}")
+    print()
+
+    budget = CostBudget(
+        max_input_tokens=200_000,
+        max_output_tokens=80_000,
+        max_calls=20,
+        max_total_usd=2.50,
+    )
+
+    rounds_collected: list[list] = []
+
+    def _on_round_complete(round_idx: int, round_responses) -> None:
+        rounds_collected.append(list(round_responses))
+        print(f"=== ROUND {round_idx + 1} COMPLETE ===")
+        for r in round_responses:
+            if r.error:
+                print(f"  [error] {r.provider}/{r.model}: {r.error}")
+                continue
+            actual = estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, table)
+            print(f"  [done] {r.provider}/{r.model}: {r.input_tokens} in / "
+                  f"{r.output_tokens} out · {r.latency_ms} ms · ${actual.total_usd:.4f}")
+        print()
+
+    print("=== CONSULT (2 rounds, debate mode) ===")
+    consult(
+        members, question, budget,
+        rounds=2,
+        on_round_complete=_on_round_complete,
+        table=table, project=project, original_ask=ORIGINAL_ASK,
+    )
+
+    if not rounds_collected:
+        print("[error] no rounds completed", file=sys.stderr)
+        return 1
+
+    actual_total = 0.0
+    for round_responses in rounds_collected:
+        for r in round_responses:
+            if r.error:
+                continue
+            actual = estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, table)
+            actual_total += actual.total_usd
+    print(f"=== TOTAL ACTUAL: ${actual_total:.4f} (across {len(rounds_collected)} rounds) ===")
+
+    final_round = rounds_collected[-1]
+    if not [r for r in final_round if not r.error]:
+        return 1
+
+    manifest = SessionManifest(
+        mode="roadmap",
+        artefact=str(ROADMAP_PATH.relative_to(REPO_ROOT)),
+        original_ask=ORIGINAL_ASK,
+        members=[f"{r.provider}/{r.model}" for r in final_round],
+        rounds=len(rounds_collected),
+        cost_usd_estimated=total_est * 2,
+        cost_usd_actual=actual_total,
+        extra={"purpose": "council lock on three open questions of structural-optimization v2"},
+    )
+    session_dir = save_session(manifest=manifest, responses=rounds_collected)
+    print(f"[saved] {session_dir.relative_to(REPO_ROOT)}/")
+    return 1 if any(r.error for round_r in rounds_collected for r in round_r) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())