@event4u/agent-config 1.16.0 → 1.18.0

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

@@ -0,0 +1,209 @@
+"""Council inline-content audit for `non-destructive-by-default` (Phase 1.1.3).
+
+Roadmap `road-to-1-16-followups` Phase 1.1.3 requires a council audit
+before merging the `load_context:` rollout for the safety-floor rule.
+Both reviewers must return PASS confirming that:
+
+  - The Hard-Floor trigger table stays inline.
+  - The Iron Law caps block stays inline.
+  - The Cloud Behavior section stays inline.
+  - No obligation moved to `destructive-mechanics.md` that should
+    have stayed in the rule.
+
+This audit is post-rollout (the rollout already shipped via Phase 7.4
+of `road-to-structural-optimization`); it certifies the *current* state
+of `main` against the Phase 1.1.3 contract.
+
+Invocation:
+    .venv/bin/python -m scripts.ai_council._one_off_nondestructive_inline_audit
+"""
+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 / ".agent-src.uncompressed/rules/non-destructive-by-default.md",
+    REPO_ROOT / ".agent-src.uncompressed/contexts/authority/destructive-mechanics.md",
+]
+
+ORIGINAL_ASK = (
+    "Phase 1.1.3 of road-to-1-16-followups requires a council audit on "
+    "the `non-destructive-by-default` rule after `load_context:` rollout. "
+    "Verify that Hard-Floor table, Iron Law caps block, and Cloud Behavior "
+    "section are still inline; flag any obligation that moved to context "
+    "and should not have."
+)
+
+REVIEW_PROMPT = """\
+# Council Inline-Content Audit — non-destructive-by-default
+
+## Context
+
+The host agent rolled out `load_context:` to the `non-destructive-by-default` \
+rule (universal safety floor). Failure-mode catalog and Bulk-deletions-WIP \
+allowed/forbidden lists moved to `destructive-mechanics.md`. The roadmap \
+contract requires that the load-bearing inline obligations stay in the rule.
+
+You are auditing the **current state** of two files (rule + mechanics) to \
+certify the rollout. This is not a re-design review.
+
+## Required-inline checklist
+
+1. **Hard-Floor trigger table** — six rows: production-branch merge, \
+   deploy/release, push to remote, production data/infra, whimsical or \
+   unscoped bulk deletion, commit containing bulk deletions or infra changes.
+2. **Iron Law caps block** — three lines starting with \
+   `HARD FLOOR OVERRIDES EVERYTHING.`
+3. **Cloud Behavior section** — two-sentence statement that the floor applies \
+   on Claude.ai Web, Skills API, and any cloud agent, with no cloud override.
+4. **"Triggers require explicit user confirmation on this turn" clause** — \
+   the not-from-previous-turn, not-from-roadmap, not-from-standing-autonomy \
+   anchor.
+
+## Output Contract (STRICT)
+
+Produce exactly these blocks in order. Total response budget <= 800 words.
+
+```
+### Inline-content audit
+
+**Hard-Floor trigger table inline:** <YES | NO — list missing rows>
+**Iron Law caps block inline:** <YES | NO — quote what is there>
+**Cloud Behavior section inline:** <YES | NO — quote what is there>
+**On-this-turn confirmation clause inline:** <YES | NO — quote anchor>
+```
+
+```
+### Misplaced-content audit
+
+**Any obligation moved to mechanics that should be inline:** <NONE | list>
+**Any failure mode duplicated in both files (drift risk):** <NONE | list>
+```
+
+```
+### Final verdict
+
+**Verdict:** <PASS | FAIL>
+**If FAIL, single blocking issue:** <one sentence>
+```
+
+Verdict definitions:
+- **PASS** — every required-inline item is present in the rule; no obligation \
+  is misplaced. The rollout meets the Phase 1.1.3 contract.
+- **FAIL** — at least one required-inline item is missing, weakened, or \
+  duplicated in a way that creates a normative drift surface.
+
+The two artefacts follow this prompt 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, 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, Phase 1.1.3 inline-content audit) ===")
+    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="files",
+        artefact=".agent-src.uncompressed/rules/non-destructive-by-default.md",
+        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": "Phase 1.1.3 inline-content audit on non-destructive-by-default"},
+    )
+    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_phase4_dispatch_latency.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Phase 4.3.1 — council cluster dispatch-latency benchmark.
+
+Measures the wall-clock overhead of the cluster dispatch layer for the
+`/council` family. Compares:
+
+  baseline: directly read council-pr.md / council-design.md (atomic shape)
+  cluster : read council.md (dispatcher) + parse table + read council-pr.md
+            / council-design.md (cluster shape)
+
+The dispatch layer in agent-config is a markdown parse, not a runtime
+function, so this benchmarks the file-system + frontmatter + table-row
+extraction cost. Threshold per roadmap § 4.3.1: ≤ +100ms wall-clock.
+"""
+from __future__ import annotations
+
+import re
+import statistics
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+COMMANDS = ROOT / ".agent-src/commands"
+N_ITER = 1000  # cold + warm; markdown is tiny so we run a lot of iterations
+
+FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
+TABLE_ROW_RE = re.compile(r"\|\s*`/council\s+([a-z-]+)`\s*\|\s*`([^`]+)`")
+
+
+def _read_atomic(target: str) -> str:
+    """Baseline: directly read the routed file (atomic shape)."""
+    path = COMMANDS / f"council-{target}.md"
+    text = path.read_text(encoding="utf-8")
+    m = FRONTMATTER_RE.match(text)
+    if not m:
+        raise RuntimeError(f"no frontmatter in {path}")
+    return text
+
+
+def _read_cluster(target: str) -> str:
+    """Cluster: read dispatcher, parse routing table, then read routed file."""
+    dispatcher = (COMMANDS / "council.md").read_text(encoding="utf-8")
+    routes = dict(TABLE_ROW_RE.findall(dispatcher))
+    routed = routes.get(target)
+    if routed is None:
+        raise RuntimeError(f"no route for {target!r} in dispatcher")
+    text = (COMMANDS / routed).read_text(encoding="utf-8")
+    m = FRONTMATTER_RE.match(text)
+    if not m:
+        raise RuntimeError(f"no frontmatter in {routed}")
+    return text
+
+
+def _bench(fn, target: str, n: int) -> list[float]:
+    samples: list[float] = []
+    for _ in range(n):
+        t0 = time.perf_counter()
+        fn(target)
+        samples.append((time.perf_counter() - t0) * 1000.0)
+    return samples
+
+
+def _summary(name: str, samples: list[float]) -> None:
+    samples = sorted(samples)
+    p50 = statistics.median(samples)
+    p95 = samples[int(len(samples) * 0.95)]
+    p99 = samples[int(len(samples) * 0.99)]
+    mean = statistics.mean(samples)
+    print(f"  {name:18s}  mean={mean:6.3f}ms  p50={p50:6.3f}ms  p95={p95:6.3f}ms  p99={p99:6.3f}ms")
+
+
+def main() -> int:
+    print(f"Phase 4.3.1 — council cluster dispatch latency  (n={N_ITER} per probe)")
+    print()
+
+    overruns = 0
+    for target in ("pr", "design"):
+        print(f"target = /council {target}")
+
+        # warm cache
+        _read_atomic(target)
+        _read_cluster(target)
+
+        baseline = _bench(_read_atomic, target, N_ITER)
+        cluster = _bench(_read_cluster, target, N_ITER)
+
+        _summary("atomic   (baseline)", baseline)
+        _summary("cluster  (dispatcher)", cluster)
+
+        delta_mean = statistics.mean(cluster) - statistics.mean(baseline)
+        delta_p95 = sorted(cluster)[int(N_ITER * 0.95)] - sorted(baseline)[int(N_ITER * 0.95)]
+        verdict = "PASS" if delta_p95 <= 100.0 else "FAIL"
+        marker = "✅" if verdict == "PASS" else "❌"
+        print(f"  delta-mean = {delta_mean:+.3f}ms  delta-p95 = {delta_p95:+.3f}ms  threshold = +100ms  {marker} {verdict}")
+        print()
+
+        if delta_p95 > 100.0:
+            overruns += 1
+
+    if overruns:
+        print(f"❌  {overruns} probe(s) exceeded +100ms p95 threshold.")
+        return 1
+    print("✅  All probes within +100ms p95 threshold.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Phase 6.1 — chat-history-* trigger overlap (Jaccard).
+
+Source of truth per rule = frontmatter `description:` field
+(the trigger surface that decides when an `auto` rule activates).
+Tokens = lowercased alphanum words length ≥ 3, minus a small
+stop-list of file-name fragments and connective words that carry
+no trigger signal.
+
+Output: pairwise Jaccard + branch verdict per roadmap § 6.1.
+"""
+from __future__ import annotations
+
+import re
+from itertools import combinations
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+RULES_DIR = ROOT / ".agent-src.uncompressed/rules"
+
+RULES = [
+    "chat-history-cadence",
+    "chat-history-ownership",
+    "chat-history-visibility",
+]
+
+STOP = {
+    "the", "and", "for", "with", "from", "via", "per", "not",
+    "into", "onto", "out", "off", "any", "all", "this", "that",
+    "agent", "chat", "history",
+    "agentchathistory", "chathistory",
+    "rule", "rules", "file", "files",
+}
+
+DESC_RE = re.compile(r'^description:\s*"([^"]+)"', re.MULTILINE)
+TOKEN_RE = re.compile(r"[a-z][a-z0-9_]{2,}")
+
+
+def tokens(rule_id: str) -> set[str]:
+    text = (RULES_DIR / f"{rule_id}.md").read_text(encoding="utf-8")
+    m = DESC_RE.search(text)
+    if not m:
+        raise RuntimeError(f"no description in {rule_id}")
+    desc = m.group(1).lower()
+    raw = TOKEN_RE.findall(desc)
+    return {t for t in raw if t not in STOP}
+
+
+def jaccard(a: set[str], b: set[str]) -> float:
+    union = a | b
+    if not union:
+        return 0.0
+    return len(a & b) / len(union)
+
+
+def main() -> int:
+    sets = {r: tokens(r) for r in RULES}
+
+    print(f"Phase 6.1 — trigger Jaccard (source: frontmatter `description:`)")
+    print()
+    for r, ts in sets.items():
+        print(f"  {r}  ({len(ts)} tokens)")
+        print(f"    {sorted(ts)}")
+        print()
+
+    print("Pairwise Jaccard:")
+    print()
+    print(f"  {'pair':55s}  intersect  union  Jaccard")
+    pairs_above = 0
+    for a, b in combinations(RULES, 2):
+        inter = sets[a] & sets[b]
+        union = sets[a] | sets[b]
+        j = jaccard(sets[a], sets[b])
+        marker = " **" if j >= 0.30 else ""
+        print(f"  {a + ' × ' + b:55s}  {len(inter):>8d}  {len(union):>5d}  {j:>6.3f}{marker}")
+        print(f"    intersection: {sorted(inter)}")
+        if j >= 0.30:
+            pairs_above += 1
+    print()
+
+    if pairs_above >= 2:
+        print(f"VERDICT: ≥ 30% on {pairs_above}/3 pairs → PROCEED to 6.2 (unified shape).")
+        return 0
+    if pairs_above == 1:
+        print(f"VERDICT: mixed ({pairs_above}/3 pairs ≥ 30%) → ESCALATE to council.")
+        return 0
+    print(f"VERDICT: < 30% on all 3 pairs → STOP at 6.1 (orthogonal — current shape optimal).")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,257 @@
+"""Council adjudication of Phase 2A always-budget overshoot.
+
+Phase 2A of road-to-structural-optimization slimmed the top-3
+budget-consuming `type: always` rules (language-and-tone,
+ask-when-uncertain, direct-answers) by extracting MECHANICS into
+contexts under contexts/communication/rules-always/. Under the
+locked Model (b) literal, the extended budget grew from 47,448 to
+52,534 chars (49,000 cap → 107.2 %), 5.2 pp above the 2 % G3
+tolerance band defined in
+docs/contracts/load-context-budget-model.md.
+
+Per that contract: an overshoot above the band rejects the model
+and escalates to council. Phase 2A § Abort/rollback fires its
+budget kill-switch in this exact case.
+
+This one-off bundles the linter output, the three slimmed rules,
+the three new mechanics contexts, and the locked budget contract,
+and asks the council to pick the smallest viable resolution.
+
+Invocation:
+    .venv/bin/python -m scripts.ai_council._one_off_phase_2a_budget_rebalance
+"""
+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 / ".agent-src.uncompressed/rules/language-and-tone.md",
+    REPO_ROOT / ".agent-src.uncompressed/rules/ask-when-uncertain.md",
+    REPO_ROOT / ".agent-src.uncompressed/rules/direct-answers.md",
+    REPO_ROOT / ".agent-src.uncompressed/contexts/communication/rules-always/language-and-tone-mechanics.md",
+    REPO_ROOT / ".agent-src.uncompressed/contexts/communication/rules-always/ask-when-uncertain-mechanics.md",
+    REPO_ROOT / ".agent-src.uncompressed/contexts/communication/rules-always/direct-answers-mechanics.md",
+]
+
+ORIGINAL_ASK = (
+    "Phase 2A of road-to-structural-optimization slimmed the top-3 "
+    "always-rules and breached the 2 % G3 tolerance band on the "
+    "always-budget under Model (b) literal. The contract requires "
+    "council escalation. Council task: pick the smallest viable "
+    "resolution from a fixed option set."
+)
+
+REVIEW_PROMPT = """\
+# Council Adjudication — Phase 2A Always-Budget Overshoot
+
+## Measured state (linter output, model (b) literal)
+
+```
+FAIL  always-rule extended budget: 52,534 / 49,000 chars (107.2%)
+      thresholds: warn 80% · fail 90% · per-rule ≤ 6,000 (ext) ·
+                  top-3 ≤ 24,500 (ext) · depth ≤ 2 · G3 band ≤ +2%
+
+  ext= 8529  raw= 4636  scope-control.md (top-3)  allowlisted ≤ 8,529
+  ext= 7887  raw= 4607  non-destructive-by-default.md (top-3)  allowlisted ≤ 7,887
+  ext= 6827  raw= 2424  ask-when-uncertain.md (top-3)  PER-RULE BREACH
+  ext= 6283  raw= 2758  direct-answers.md  PER-RULE BREACH
+  ext= 5863  raw= 3658  language-and-tone.md
+  ext= 5781  raw= 3309  commit-policy.md
+  ext= 5481  raw= 2196  verify-before-complete.md
+  ext= 4415  raw= 4415  no-cheap-questions.md
+  ext= 1468  raw= 1468  agent-authority.md
+```
+
+Pre-Phase-2A baseline (Phase 0.2.3 retroactive test, locked):
+**47,448 / 49,000 = 96.8 %** (within tolerance, model (b) accepted).
+
+Phase-2A delta per slimmed rule (raw rule shrank, mechanics
+context loaded as new dependency):
+
+| Rule | ext before | ext after | delta |
+|---|---:|---:|---:|
+| language-and-tone | 5,832 | 5,863 | +31 |
+| ask-when-uncertain | 5,196 | 6,827 | +1,631 |
+| direct-answers | 4,722 | 6,283 | +1,561 |
+
+Phase 0.4 worked example council-locked the +1,561 delta on
+direct-answers. ask-when-uncertain (+1,631) is structurally
+identical. The total overshoot is **+3,534 chars over cap**.
+
+## Why the literal model can no longer hit budget
+
+Under model (b) literal each rule pays full cost for every context
+it loads. Each mechanics extraction adds ~1.5–2 KB of frontmatter +
+headers + context-introduction overhead per rule. Phase 2A is
+structurally unable to satisfy the roadmap success criterion
+("budget delta ≥ −5 %") under model (b); extraction *always* adds
+overhead unless mechanics are consolidated and shared across rules.
+
+## Fixed option set (pick exactly one)
+
+- **R1 — Switch to Model (c) shared-divisor.** Reserved by the
+  contract as "first refinement step if the 2 % tolerance band is
+  exceeded". Under (c), `Σ RawSize(c) / N_loaders`. Currently each
+  mechanics file has N=1, so (c) reduces to (b). Buy-in for (c)
+  enables R5 below.
+- **R2 — Raise TOTAL_CAP.** Set cap to 56,000 chars (current
+  utilization 93.8 % under new cap). Acknowledges extraction
+  overhead is real; freezes Phase 2A wins; abandons the −5 %
+  delta success criterion.
+- **R3 — Raise PER_RULE_CAP to 7,000 + add allowlist entries +
+  raise TOTAL_CAP to 54,000.** Minimal-change variant: keeps the
+  shape, accepts the two new per-rule breaches, raises cap
+  modestly.
+- **R4 — Revert Phase 2A.** Abandon mechanics extraction on the
+  three rules; restore them to original size; mark Phase 2A as
+  "structurally infeasible under locked contract"; close roadmap
+  phase.
+- **R5 — Consolidate the three mechanics into one shared context
+  + adopt R1.** Single `rules-always-mechanics.md` loaded by all
+  three slimmed rules; under (c) each rule pays 1/3 of the
+  consolidated context size. Highest engineering cost, only path
+  that delivers a net negative delta.
+
+## Output Contract (STRICT)
+
+```
+### Verdict
+**Choice:** <R1 | R2 | R3 | R4 | R5>
+**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 2A success criterion?**
+  <YES — new criterion in 1 line · NO>
+```
+
+Be decisive — total response ≤ 1,000 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=2560,
+    )
+
+    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}")
+    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, Phase 2A budget rebalance) ===")
+    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="files",
+        artefact="agents/roadmaps/road-to-structural-optimization.md",
+        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": "Phase 2A always-budget overshoot adjudication"},
+    )
+    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())