@event4u/agent-config 1.19.0 → 1.21.0

package/scripts/_pilot_measure.py

@@ -0,0 +1,53 @@
+"""Pilot compression ratio + Iron-Law checksum verification (one-off, not CI)."""
+import sys, re, hashlib, statistics
+from pathlib import Path
+
+sys.path.insert(0, "scripts")
+from measure_rule_budget import strip_frontmatter
+
+FENCE_RE = re.compile(r"```(?:[^\n]*\n)([\s\S]*?)```")
+
+
+def iron_law_sha(body: str) -> str:
+    blocks = FENCE_RE.findall(body)
+    norm = "".join(re.sub(r"\s+", " ", b).strip().upper() for b in blocks)
+    return hashlib.sha256(norm.encode()).hexdigest()[:16]
+
+
+pairs = [
+    ("agent-authority",   ".agent-src.uncompressed/rules/agent-authority.md",   "docs/contracts/pilot/agent-authority.md"),
+    ("direct-answers",    ".agent-src.uncompressed/rules/direct-answers.md",    "docs/contracts/pilot/direct-answers.md"),
+    ("language-and-tone", ".agent-src.uncompressed/rules/language-and-tone.md", "docs/contracts/pilot/language-and-tone.md"),
+]
+
+header = f"{'rule':25s} {'orig':>6s}  {'pilot':>6s}  {'r':>6s}  {'budget':>7s}  {'sha-orig':>16s}  {'sha-pilot':>16s}  {'IL':>3s}"
+print(header)
+print("-" * len(header))
+
+ratios = []
+for rid, orig_path, pilot_path in pairs:
+    orig_body, _  = strip_frontmatter(Path(orig_path).read_text())
+    pilot_body, _ = strip_frontmatter(Path(pilot_path).read_text())
+    o, p = len(orig_body), len(pilot_body)
+    r = p / o
+    ratios.append(r)
+    sha_o = iron_law_sha(orig_body)
+    sha_p = iron_law_sha(pilot_body)
+    match = "OK" if sha_o == sha_p else "FAIL"
+    budget = "OK" if p <= 1500 else f"+{p - 1500}"
+    print(f"{rid:25s} {o:6d}  {p:6d}  {r:6.3f}  {budget:>7s}  {sha_o:>16s}  {sha_p:>16s}  {match:>3s}")
+
+mean   = sum(ratios) / len(ratios)
+median = statistics.median(ratios)
+print()
+print(f"r-values : {[round(x, 3) for x in ratios]}")
+print(f"mean   r = {mean:.3f}")
+print(f"median r = {median:.3f}")
+print(f"max    r = {max(ratios):.3f}")
+print(f"min    r = {min(ratios):.3f}")
+print()
+
+TOTAL = 32403
+print(f"Projected always-bucket @ r=mean ({mean:.3f})  : {int(TOTAL * mean):>6d}  (target ≤ 25000)")
+print(f"Projected always-bucket @ r=max  ({max(ratios):.3f})  : {int(TOTAL * max(ratios)):>6d}  (target ≤ 25000)")
+print(f"Projected always-bucket @ r=med  ({median:.3f})  : {int(TOTAL * median):>6d}  (target ≤ 25000)")

package/scripts/agent-config

@@ -68,7 +68,7 @@ Commands:
   refine-ticket:detect       Run the deterministic refine-ticket detection helper
   chat-history:hook          Platform hook entry point (read JSON from stdin)
                              Usage: chat-history:hook --platform <claude|augment|cursor|cline|windsurf|gemini>
-  chat-history:checkpoint    Append a phase-boundary entry to .agent-chat-history
+  chat-history:checkpoint    Append a phase-boundary entry to agents/.agent-chat-history
                              (CHECKPOINT fallback for platforms without native hooks)
   roadmap-progress:hook      PostToolUse hook entry point (read JSON from stdin)
                              Regenerates roadmaps-progress.md when a tool wrote under agents/roadmaps/

package/scripts/ai_council/_default_prices.py

@@ -1,7 +1,7 @@
 """Shipped baseline prices for the AI Council.
 
-This file is the bootstrap source for `.agent-prices.md` when the
-runtime file is missing. It is also the network-fallback source for
+This file is the bootstrap source for `agents/.agent-prices.md` when
+the runtime file is missing. It is also the network-fallback source for
 `scripts/update_prices.py` when the upstream feed (LiteLLM) is
 unreachable.
 
@@ -9,8 +9,8 @@ Prices are USD per **1 000 000** tokens. Models are identified by the
 exact `model:` string the user puts into `.agent-settings.yml`.
 
 Numbers below are a hand-curated snapshot — they will drift. The
-runtime never reads them directly once `.agent-prices.md` exists; the
-weekly refresh and user edits are the live source of truth.
+runtime never reads them directly once `agents/.agent-prices.md`
+exists; the weekly refresh and user edits are the live source of truth.
 """
 
 from __future__ import annotations

package/scripts/ai_council/clients.py

@@ -100,7 +100,7 @@ class ExternalAIClient(ABC):
 
     name: str = ""
     model: str = ""
-    billable: bool = True  # API-mode subclasses spend money; manual/playwright don't.
+    billable: bool = True  # API-mode subclasses spend money; manual doesn't.
 
     @abstractmethod
     def ask(

package/scripts/ai_council/modes.py

@@ -4,14 +4,13 @@ Each council member runs in exactly one transport mode per invocation:
 
 - ``api``      — direct SDK call against the provider's API (billable).
 - ``manual``   — copy-paste loop with the user as transport (free).
-- ``playwright`` — browser automation (Phase 2c, not yet wired).
 
 Resolution precedence — first non-empty wins:
 
     1. Invocation flag      e.g. ``/council mode:manual``
     2. Per-member setting   ``ai_council.members.<name>.mode``
     3. Global setting       ``ai_council.mode``
-    4. Built-in default     ``api``
+    4. Built-in default     ``manual``
 
 This mirrors how ``cost_profile`` resolves in
 ``.augment/guidelines/agent-infra/layered-settings.md``.
@@ -24,9 +23,9 @@ from __future__ import annotations
 
 from typing import Mapping
 
-VALID_MODES: frozenset[str] = frozenset({"api", "manual", "playwright"})
+VALID_MODES: frozenset[str] = frozenset({"api", "manual"})
 
-DEFAULT_MODE: str = "api"
+DEFAULT_MODE: str = "manual"
 
 
 class InvalidModeError(ValueError):

package/scripts/ai_council/pricing.py

@@ -1,18 +1,19 @@
 """Runtime pricing layer for the AI Council.
 
-Reads `.agent-prices.md` from the repo root, parses YAML frontmatter
-and the Markdown table, and exposes:
+Reads `agents/.agent-prices.md` from the repo root, parses YAML
+frontmatter and the Markdown table, and exposes:
 
-- `load_prices()`           — parse `.agent-prices.md` (bootstraps if missing)
+- `load_prices()`           — parse `agents/.agent-prices.md` (bootstraps if missing)
 - `estimate_input_tokens()` — chars / 4 heuristic
 - `estimate_cost()`         — input + output USD for a single member
 - `is_stale()`              — True if `last_updated` is older than the
                               most recent UTC Monday 00:00
-- `bootstrap_from_defaults()` — write a fresh `.agent-prices.md` from
-                              `_default_prices.DEFAULT_PRICES`
+- `bootstrap_from_defaults()` — write a fresh `agents/.agent-prices.md`
+                              from `_default_prices.DEFAULT_PRICES`
 
 The orchestrator never reads `_default_prices` directly. It always
-goes through `load_prices()` so user edits to `.agent-prices.md` win.
+goes through `load_prices()` so user edits to
+`agents/.agent-prices.md` win.
 """
 
 from __future__ import annotations
@@ -24,7 +25,7 @@ from pathlib import Path
 from scripts.ai_council._default_prices import DEFAULT_PRICES, LAST_UPDATED, as_rows
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
-PRICES_FILE = REPO_ROOT / ".agent-prices.md"
+PRICES_FILE = REPO_ROOT / "agents" / ".agent-prices.md"
 
 # Heuristic: 1 token ≈ 4 characters of English text. OpenAI's tiktoken
 # is more accurate but pulls in a heavy dep we explicitly avoid.
@@ -115,14 +116,14 @@ def is_stale(table: PriceTable, now: _dt.datetime | None = None) -> bool:
 
 
 def load_prices(path: Path = PRICES_FILE) -> PriceTable:
-    """Parse `.agent-prices.md`; bootstrap from defaults if missing."""
+    """Parse `agents/.agent-prices.md`; bootstrap from defaults if missing."""
     if not path.exists():
         bootstrap_from_defaults(path)
     return _parse(path.read_text(encoding="utf-8"))
 
 
 def bootstrap_from_defaults(path: Path = PRICES_FILE) -> None:
-    """Write a fresh `.agent-prices.md` from `_default_prices.py`."""
+    """Write a fresh `agents/.agent-prices.md` from `_default_prices.py`."""
     rows = as_rows()
     body = _render_markdown(LAST_UPDATED, "shipped-default", rows)
     path.write_text(body, encoding="utf-8")

package/scripts/ai_council/session.py

@@ -35,9 +35,15 @@ from scripts.ai_council.orchestrator import render
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
 SESSIONS_DIR = REPO_ROOT / "agents" / "council-sessions"
+QUESTIONS_DIR = REPO_ROOT / "agents" / "council-questions"
+RESPONSES_DIR = REPO_ROOT / "agents" / "council-responses"
 SETTINGS_FILE = REPO_ROOT / ".agent-settings.yml"
 
-DEFAULT_RETENTION_DAYS = 14
+# Default retention for all council artefacts (questions, responses,
+# sessions). Overridden by `ai_council.session_retention_days`
+# in `.agent-settings.yml`. Council files are local-only scratch — short
+# retention keeps the working tree from accumulating dead weight.
+DEFAULT_RETENTION_DAYS = 7
 _TS_RE = re.compile(r"^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})Z$")
 
 
@@ -152,6 +158,92 @@ def prune_old_sessions(
     return removed
 
 
+def prune_old_artifacts(
+    artifact_dir: Path,
+    retention_days: int,
+    *,
+    now: _dt.datetime | None = None,
+) -> list[Path]:
+    """Delete files and timestamp-less directories older than `retention_days`.
+
+    mtime-based — used for `agents/council-questions/`,
+    `agents/council-responses/`, and root-level files in
+    `agents/council-sessions/` that don't match the
+    timestamp-subdir convention handled by `prune_old_sessions`.
+
+    Walks the directory non-recursively. For files: deletes when
+    mtime predates the cutoff. For sub-directories without a
+    timestamp name: deletes recursively when mtime predates the
+    cutoff. Never raises — disk failures log to stderr.
+
+    Returns the list of deleted paths. `retention_days <= 0`
+    disables pruning and returns an empty list.
+    """
+    if retention_days <= 0 or not artifact_dir.exists():
+        return []
+    cutoff = (now or _dt.datetime.now(_dt.timezone.utc)) - _dt.timedelta(days=retention_days)
+    cutoff_ts = cutoff.timestamp()
+    removed: list[Path] = []
+    try:
+        entries = list(artifact_dir.iterdir())
+    except OSError as exc:  # noqa: BLE001 - never block the report
+        print(f"[council:session] artifact iterdir failed: {exc}", file=sys.stderr)
+        return removed
+    for entry in entries:
+        # Timestamp subdirs are owned by prune_old_sessions; skip them
+        # so the two pruners don't race.
+        if entry.is_dir() and _parse_session_timestamp(entry.name) is not None:
+            continue
+        try:
+            mtime = entry.stat().st_mtime
+        except OSError as exc:  # noqa: BLE001 - never block the report
+            print(f"[council:session] artifact stat failed for {entry}: {exc}",
+                  file=sys.stderr)
+            continue
+        if mtime >= cutoff_ts:
+            continue
+        try:
+            if entry.is_dir():
+                shutil.rmtree(entry)
+            else:
+                entry.unlink()
+            removed.append(entry)
+        except OSError as exc:  # noqa: BLE001 - never block the report
+            print(f"[council:session] artifact remove failed for {entry}: {exc}",
+                  file=sys.stderr)
+    return removed
+
+
+def prune_all_council_artifacts(
+    retention_days: int | None = None,
+    *,
+    repo_root: Path | None = None,
+    now: _dt.datetime | None = None,
+) -> dict[str, list[Path]]:
+    """Prune every council artefact dir under `repo_root` in one pass.
+
+    Reads `retention_days` from settings if not supplied. Used by the
+    `task council-prune` target and by `save()`. Never raises.
+
+    Returns a dict keyed by directory label — `sessions`,
+    `questions`, `responses` — each mapped to the list of
+    paths actually removed.
+    """
+    root = repo_root or REPO_ROOT
+    days = _load_retention_days() if retention_days is None else retention_days
+    sessions = root / "agents" / "council-sessions"
+    questions = root / "agents" / "council-questions"
+    responses = root / "agents" / "council-responses"
+    return {
+        "sessions": (
+            prune_old_sessions(sessions, days, now=now)
+            + prune_old_artifacts(sessions, days, now=now)
+        ),
+        "questions": prune_old_artifacts(questions, days, now=now),
+        "responses": prune_old_artifacts(responses, days, now=now),
+    }
+
+
 def save(
     *,
     manifest: SessionManifest,
@@ -167,10 +259,12 @@ def save(
     - `Iterable[list[CouncilResponse]]` — multi-round, one list per
       round in execution order.
 
-    `retention_days` controls auto-pruning of older sibling sessions
-    after the new one is written. `None` reads the value from
-    `.agent-settings.yml` (`ai_council.session_retention_days`,
-    default `14`); `0` disables pruning.
+    `retention_days` controls auto-pruning of older council artefacts
+    after the new one is written — sibling sessions plus, when
+    `sessions_dir` is not overridden, files in `council-questions/`
+    and `council-responses/`. `None` reads the value
+    from `.agent-settings.yml` (`ai_council.session_retention_days`,
+    default `7`); `0` disables pruning.
 
     Disk-write failures are surfaced via a stderr line but do not
     raise; the caller's text report is the source of truth.
@@ -232,5 +326,13 @@ def save(
 
     days = _load_retention_days() if retention_days is None else retention_days
     prune_old_sessions(base, days)
+    prune_old_artifacts(base, days)
+    # In production (no sessions_dir override), also prune the sibling
+    # council artefact dirs so questions/responses aren't left as dead
+    # weight. Tests that pass an explicit sessions_dir stay isolated
+    # from the wider tree.
+    if sessions_dir is None:
+        prune_old_artifacts(QUESTIONS_DIR, days)
+        prune_old_artifacts(RESPONSES_DIR, days)
 
     return session_dir

package/scripts/build_linear_digest.py

@@ -76,15 +76,13 @@ WORKSPACE: list[RuleEntry] = [
     RuleEntry("reviewer-awareness"),
     RuleEntry("scope-control"),
     RuleEntry("security-sensitive-stop"),
-    RuleEntry("think-before-action", "degraded",
-              strip_sections=["Consult memory before editing"]),
+    RuleEntry("think-before-action"),
     RuleEntry("verify-before-complete"),
-    RuleEntry("cli-output-handling", "degraded",
-              strip_sections=["Iron Law — rtk first, tail/grep fallback"]),
+    RuleEntry("cli-output-handling"),
     RuleEntry("downstream-changes"),
     RuleEntry("improve-before-implement"),
     RuleEntry("language-and-tone", "degraded",
-              strip_sections=["`.md` files are ALWAYS English — no exceptions"]),
+              strip_sections=["`.md` files — ALWAYS English"]),
     RuleEntry("missing-tool-handling"),
     RuleEntry("token-efficiency"),
     RuleEntry("user-interaction"),

package/scripts/build_rule_trigger_matrix.py

@@ -71,14 +71,6 @@ add("no-cheap-questions.md", "pre-send Q&A check", "agent-only", "output",
     "NA-soft", "3", notes="Pre-send self-check, no platform surface")
 
 # ── Auto-rules — Tier 1 candidates (mechanizable, deterministic) ──────
-add("chat-history-cadence.md", "per-turn / per-tool / per-phase", "mechanical-already",
-    "hook", "NA-mechanical", "mechanical-already",
-    notes="PRECEDENT — heartbeat + chat_history.py + hooks. Reference pattern.")
-add("chat-history-ownership.md", "first turn", "hook", "state",
-    "low", "1", notes="Detectable: ownership classification at session start")
-add("chat-history-visibility.md", "heartbeat marker emit", "mechanical-already",
-    "hook", "NA-mechanical", "mechanical-already",
-    notes="Subprocess marker print is already mechanical")
 add("onboarding-gate.md", "first turn (settings.onboarded == false)", "settings",
     "state", "low", "1",
     notes="Pilot candidate — frequency 100% on un-onboarded projects, binary verifiable")
@@ -341,7 +333,7 @@ def emit():
     lines.append("## Cross-references")
     lines.append("")
     lines.append("- Budget contract: [`docs/contracts/load-context-budget-model.md`](../../docs/contracts/load-context-budget-model.md)")
-    lines.append("- Pattern precedent: `chat-history-cadence` (heartbeat hook + `scripts/chat_history.py`)")
+    lines.append("- Pattern precedent: `roadmap-progress-sync` (PostToolUse path-filter hook)")
     lines.append("- Phase 2A finding: [`adr-always-rule-context-split-not-viable.md`](adr-always-rule-context-split-not-viable.md)")
     lines.append("")