@event4u/agent-config 5.6.1 → 5.7.0

package/scripts/install_anthropic_key.sh

@@ -104,5 +104,5 @@ echo "    Remove:  rm ${TARGET_FILE}"
 echo
 echo "ℹ️   Key install ≠ enable. To use this provider in /council:"
 echo "    set ai_council.enabled: true and ai_council.members.anthropic.enabled: true"
-echo "    in .agent-settings.yml. Council is a 'full' cost_profile feature; under"
+echo "    in .agent-settings.yml. Council is a 'full' rule_loading_tier feature; under"
 echo "    'minimal' / 'balanced' the runtime hooks stay inactive."

package/scripts/install_openai_key.sh

@@ -104,5 +104,5 @@ echo "    Remove:  rm ${TARGET_FILE}"
 echo
 echo "ℹ️   Key install ≠ enable. To use this provider in /council:"
 echo "    set ai_council.enabled: true and ai_council.members.openai.enabled: true"
-echo "    in .agent-settings.yml. Council is a 'full' cost_profile feature; under"
+echo "    in .agent-settings.yml. Council is a 'full' rule_loading_tier feature; under"
 echo "    'minimal' / 'balanced' the runtime hooks stay inactive."

package/scripts/lint_discovery_vocabulary.py

@@ -10,7 +10,7 @@ every pack listed as a workspace's default/optional MUST list that
 workspace in its own `workspaces:` array (and vice versa).
 
 Non-overlap (ADR-010 alignment): no pack id may collide with a
-`cost_profile` value (minimal/balanced/full/custom) or a `profile.id`
+`rule_loading_tier` value (minimal/balanced/full/custom) or a `profile.id`
 value (founder/developer/content_creator/agency/finance/ops).
 
 Cap: ≤ 150 LOC, stdlib + PyYAML. Exit 0 clean, 1 on failure.
@@ -41,11 +41,11 @@ ADR_PACKS: frozenset[str] = frozenset({
     "typescript", "react", "nextjs", "python", "product-basic",
     "product-discovery", "finance-basic", "finance-advanced",
     "gtm-sales", "gtm-marketing", "ops-people", "founder-strategy", "small-business",
-    "construction", "ai-video", "meta",
+    "construction", "ai-video", "fun", "meta",
 })
 
 # ADR-010 non-overlap reservations.
-COST_PROFILE_RESERVED: frozenset[str] = frozenset({
+RULE_LOADING_TIER_RESERVED: frozenset[str] = frozenset({
     "minimal", "balanced", "full", "custom",
 })
 PROFILE_ID_RESERVED: frozenset[str] = frozenset({
@@ -136,9 +136,9 @@ def lint(quiet: bool) -> int:
                     )
 
     # 5. Non-overlap (ADR-010).
-    overlap_cost = pack_ids & COST_PROFILE_RESERVED
+    overlap_cost = pack_ids & RULE_LOADING_TIER_RESERVED
     if overlap_cost:
-        errors.append(f"pack ids collide with cost_profile values: {sorted(overlap_cost)}")
+        errors.append(f"pack ids collide with rule_loading_tier values: {sorted(overlap_cost)}")
     overlap_profile = pack_ids & PROFILE_ID_RESERVED
     if overlap_profile:
         errors.append(f"pack ids collide with profile.id values: {sorted(overlap_profile)}")

package/scripts/lint_value_dashboard.py

@@ -48,7 +48,7 @@ REQUIRED_SECTIONS = (
     "**NETTO",
 )
 
-CANONICAL_RUNG_IDS = ("baseline", "load", "condense", "rtk", "terse")
+CANONICAL_RUNG_IDS = ("baseline", "load", "thin", "condense", "rtk", "terse")
 
 
 def _log(msg: str, quiet: bool, *, err: bool = False) -> None:

package/scripts/prediction-pool/adapters/_schema.md

@@ -0,0 +1,42 @@
+# Tippspiel adapter contract — declarative selector maps
+
+An adapter is **data, not code**: a YAML file mapping a prediction-pool
+platform's tip-form fields to CSS selectors. A generic, trusted Playwright
+driver reads it and fills the inputs. Because adapters carry no executable
+code, contributing one via PR is safe — there is no supply-chain surface to
+audit beyond the selectors themselves.
+
+One file per platform: `scripts/prediction-pool/adapters/<platform>.yml`.
+
+## Required keys
+
+| Key | Type | Meaning |
+|---|---|---|
+| `platform` | string | Stable id, matches the filename (`kicktipp`). |
+| `match` | string | URL host (or substring) this adapter applies to. |
+| `login_required` | bool | Always `true` — the user logs in; the driver never handles credentials. |
+| `selectors.row` | string | CSS selector for one repeated **match row** on the tip page. |
+| `selectors.home_input` | string | Within a row: the home-score input. |
+| `selectors.away_input` | string | Within a row: the away-score input. |
+
+## Optional keys
+
+| Key | Type | Meaning |
+|---|---|---|
+| `tip_page_hint` | string | URL path pattern of the tip page (e.g. `/<pool>/tippabgabe`). |
+| `selectors.home_team` / `selectors.away_team` | string | Within a row: team-name nodes, to align the right tip to the right match. |
+| `selectors.bonus_*` | string | Selectors for bonus-question inputs. |
+| `selectors.submit` | string | The submit control. **The driver NEVER clicks this** unless the user authorized submit this turn. |
+| `notes` | string | Drift warnings, quirks, last-verified date. |
+
+## Rules for adapters
+
+- **No code.** YAML data only — no scripts, no JS, no URLs the driver
+  fetches. Selectors and hints, nothing else.
+- **`submit` is never auto-clicked.** It exists so the driver can *locate*
+  (and, only on explicit authorization, click) the control — never by default.
+- **Selectors drift.** If a row/input selector no longer matches at run
+  time, the driver falls back to the **vision-assisted synthesis** path
+  (screenshot → identify fields → user confirms) rather than guessing.
+- **PR contributions** add exactly one `<platform>.yml` plus, ideally, a
+  `notes:` line with the date the selectors were verified.

package/scripts/prediction-pool/adapters/kicktipp.yml

@@ -0,0 +1,23 @@
+# kicktipp — declarative selector map (see _schema.md)
+#
+# Selectors are a STARTING POINT and may drift if kicktipp changes its DOM.
+# They have not been re-verified against the live site in this commit — if a
+# selector no longer matches at run time, the driver falls back to the
+# vision-assisted synthesis path. Update `notes.verified` when you confirm.
+platform: kicktipp
+match: kicktipp.de
+login_required: true
+tip_page_hint: "/<pool>/tippabgabe"
+selectors:
+  row: "form#tippabgabeSpiele tbody tr"
+  home_team: "td.col1 .nfooball, td.col1"
+  away_team: "td.col3 .nfooball, td.col3"
+  home_input: "input.kicktipp-heimtipp"
+  away_input: "input.kicktipp-gasttipp"
+  # submit is located, never auto-clicked unless the user authorizes it this turn
+  submit: "input[type=submit][value*='Tipps speichern'], button[type=submit]"
+notes: |
+  verified: unverified (DOM not inspected in this commit)
+  kicktipp renders one <tr> per match inside the tip form; each row carries a
+  home and away number input. Bonus questions live on separate pages per pool.
+  If the row/input selectors miss, use the vision path — do not guess.

package/scripts/prediction-pool/poisson_sim.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""Poisson tournament simulator for prediction-pool-optimizer.
+
+Honest replacement for "I simulated 10,000 runs" — this actually runs them.
+Goals per match are drawn from a Poisson whose rate comes from each team's
+attack / defence strength; group stages are round-robin, then a single-
+elimination bracket runs over the qualifiers. Aggregates advancement and
+title probabilities over N runs.
+
+It is an APPROXIMATION, stated as such: real tournament bracket pairings
+(winner-of-A vs runner-up-of-B …) are format-specific. Provide an explicit
+`bracket` (list of name pairs per round, or "auto" for a random seed) to
+control this; the default "auto" randomly seeds qualifiers and is good
+enough for outright/advancement estimates, not for exact-pairing bonus
+questions.
+
+Input JSON shape:
+{
+  "base_goals": 1.35,                       # league-average goals per side
+  "teams": { "Germany": {"att": 1.3, "def": 0.8}, ... },   # att/def multipliers (1.0 = average)
+  "groups": [ ["Germany","Scotland","Hungary","Switzerland"], ... ],
+  "advance_per_group": 2,
+  "bracket": "auto"                          # or omit; "auto" = random seed of qualifiers
+}
+
+Usage:
+  python3 scripts/prediction-pool/poisson_sim.py teams.json --runs 20000 [--seed 1]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import random
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+
+def _poisson(rate: float, rng: random.Random) -> int:
+    """Knuth's algorithm — stdlib only, no numpy."""
+    if rate <= 0:
+        return 0
+    L = math.exp(-rate)
+    k, p = 0, 1.0
+    while True:
+        k += 1
+        p *= rng.random()
+        if p <= L:
+            return k - 1
+
+
+def _rates(home: str, away: str, teams: dict, base: float) -> tuple[float, float]:
+    h, a = teams.get(home, {}), teams.get(away, {})
+    lam_h = base * h.get("att", 1.0) * a.get("def", 1.0)
+    lam_a = base * a.get("att", 1.0) * h.get("def", 1.0)
+    return lam_h, lam_a
+
+
+def _play(home: str, away: str, teams: dict, base: float, rng: random.Random,
+          allow_draw: bool = True) -> tuple[int, int]:
+    lam_h, lam_a = _rates(home, away, teams, base)
+    gh, ga = _poisson(lam_h, rng), _poisson(lam_a, rng)
+    if not allow_draw and gh == ga:
+        # extra-time / penalties proxy: edge to the stronger attack, else coin flip
+        if lam_h == lam_a:
+            return (gh + 1, ga) if rng.random() < 0.5 else (gh, ga + 1)
+        return (gh + 1, ga) if lam_h > lam_a else (gh, ga + 1)
+    return gh, ga
+
+
+def _group_table(group: list[str], teams: dict, base: float, rng: random.Random) -> list[str]:
+    pts = defaultdict(int)
+    gd = defaultdict(int)
+    gf = defaultdict(int)
+    for i in range(len(group)):
+        for j in range(i + 1, len(group)):
+            gh, ga = _play(group[i], group[j], teams, base, rng)
+            gd[group[i]] += gh - ga
+            gd[group[j]] += ga - gh
+            gf[group[i]] += gh
+            gf[group[j]] += ga
+            if gh > ga:
+                pts[group[i]] += 3
+            elif ga > gh:
+                pts[group[j]] += 3
+            else:
+                pts[group[i]] += 1
+                pts[group[j]] += 1
+    # rank: points, then goal difference, then goals for, then random tiebreak
+    return sorted(group, key=lambda t: (pts[t], gd[t], gf[t], rng.random()), reverse=True)
+
+
+def _knockout(qualifiers: list[str], teams: dict, base: float, rng: random.Random) -> str:
+    field = qualifiers[:]
+    rng.shuffle(field)
+    # pad to a power of two with byes
+    while (len(field) & (len(field) - 1)) != 0:
+        field.append(None)
+    while len(field) > 1:
+        nxt = []
+        for i in range(0, len(field), 2):
+            a, b = field[i], field[i + 1]
+            if a is None:
+                nxt.append(b)
+            elif b is None:
+                nxt.append(a)
+            else:
+                gh, ga = _play(a, b, teams, base, rng, allow_draw=False)
+                nxt.append(a if gh > ga else b)
+        field = nxt
+    return field[0]
+
+
+def simulate(cfg: dict, runs: int, seed: int | None) -> dict:
+    rng = random.Random(seed)
+    base = float(cfg.get("base_goals", 1.35))
+    teams = cfg["teams"]
+    groups = cfg.get("groups", [])
+    adv = int(cfg.get("advance_per_group", 2))
+
+    advanced = defaultdict(int)
+    champ = defaultdict(int)
+    for _ in range(runs):
+        qualifiers: list[str] = []
+        if groups:
+            for g in groups:
+                ranked = _group_table(g, teams, base, rng)
+                top = ranked[:adv]
+                qualifiers.extend(top)
+                for t in top:
+                    advanced[t] += 1
+        else:
+            qualifiers = list(teams.keys())
+        winner = _knockout(qualifiers, teams, base, rng) if len(qualifiers) > 1 else (qualifiers or [None])[0]
+        if winner is not None:
+            champ[winner] += 1
+
+    def pct(d):
+        return {t: round(100 * c / runs, 2) for t, c in sorted(d.items(), key=lambda kv: -kv[1])}
+
+    return {"runs": runs, "seed": seed, "advance_pct": pct(advanced), "title_pct": pct(champ)}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="Poisson tournament simulator (stdlib only).")
+    ap.add_argument("config", help="Path to teams/groups JSON.")
+    ap.add_argument("--runs", type=int, default=20000, help="Number of simulated tournaments.")
+    ap.add_argument("--seed", type=int, default=None, help="RNG seed for reproducibility.")
+    args = ap.parse_args()
+
+    cfg_path = Path(args.config)
+    if not cfg_path.is_file():
+        print(f"ERROR: config not found: {cfg_path}", file=sys.stderr)
+        return 2
+    cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+    if "teams" not in cfg:
+        print("ERROR: config needs a 'teams' object.", file=sys.stderr)
+        return 2
+
+    result = simulate(cfg, args.runs, args.seed)
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/render_value_md.py

@@ -67,6 +67,7 @@ def confidence_badge(level: str) -> str:
         "estimated": "≈ geschätzt",
         "vendor-claim": "⚠️ vendor-claim",
         "pending": "⏳ pending",
+        "available": "🔁 verfügbar (Default aus)",
     }
     return badges.get(level, level)
 

package/scripts/schemas/agent-settings.schema.json

@@ -0,0 +1,77 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/event4u-app/agent-config/scripts/schemas/agent-settings.schema.json",
+  "title": "Agent settings (.agent-settings.yml)",
+  "$comment": "Collision-prevention schema added by the 2026-06-01 rule_loading_tier untangle. It enum-constrains the value-bearing keys that have historically been overloaded with a foreign vocabulary (the root cause of the rule_loading_tier/memory-cadence collision: the same key carrying two value sets). It is deliberately PERMISSIVE elsewhere (additionalProperties: true at every level) — exhaustive per-key validation is out of scope and would be brittle. The job of this schema is to make a value-vocabulary collision a hard CI failure, not to type every setting.",
+  "type": "object",
+  "additionalProperties": true,
+  "properties": {
+    "rule_loading_tier": {
+      "type": "string",
+      "enum": ["minimal", "balanced", "full", "custom"],
+      "description": "Rule-tier loading footprint. See docs/contracts/cost-profile-defaults.md and docs/contracts/rule-router.md. NOT a memory or model lever."
+    },
+    "memory": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "cadence": {
+          "type": "string",
+          "enum": ["auto", "always", "never"],
+          "description": "Cadence of the 🧠 memory-visibility line. See docs/contracts/memory-visibility-v1.md. Owns its own key since the 2026-06-01 untangle; previously collided with rule_loading_tier."
+        }
+      }
+    },
+    "model": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "auto_switch": {
+          "type": "string",
+          "enum": ["suggest", "auto", "off"],
+          "description": "Per-skill model-tier routing (ADR-035). Distinct from rule_loading_tier — picks WHICH model runs, not how many rules load."
+        }
+      }
+    },
+    "lean_projection": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "mode": {
+          "type": "string",
+          "enum": ["eager-all", "thin"]
+        }
+      }
+    },
+    "cost": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "enforcement": {
+          "type": "string",
+          "enum": ["advisory", "hard-stop"]
+        }
+      }
+    },
+    "personal": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "autonomy": {
+          "type": "string",
+          "enum": ["on", "off", "auto"]
+        }
+      }
+    },
+    "worktrees": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "mode": {
+          "type": "string",
+          "enum": ["off", "on", "ask"]
+        }
+      }
+    }
+  }
+}

package/scripts/schemas/skill.schema.json

@@ -154,6 +154,13 @@
       "default": "active",
       "description": "ADR-013 lifecycle state."
     },
+    "requires_skills": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {"type": "string", "pattern": "^[a-z][a-z0-9-]*$"},
+      "description": "Skill-composition graph (roadmap 3.4): names of sub-skills this skill's body invokes/assumes. Distinct from ADR-015 `requires` (artefact→pack edges). scripts/check_skill_requires.py enforces (a) each target exists and (b) the required skill is co-available wherever this skill ships (same pack, a requires_hint-reachable pack, or always-on)."
+    },
     "trust": {
       "type": "object",
       "additionalProperties": false,

package/scripts/smoke_quickstart.py

@@ -4,7 +4,7 @@
 Verifies the 3-step Quickstart from a fresh-project perspective:
 
   1. `scripts/install.py --project <tmpdir>` produces a usable
-     `.agent-settings.yml` with the documented default `cost_profile`.
+     `.agent-settings.yml` with the documented default `rule_loading_tier`.
   2. The decision_engine block (P2.x of road-to-productization) parses
      cleanly through the same engine parser the runtime uses.
   3. The work-engine state-file format (`agents/runtime/state/<id>.json`) is
@@ -68,16 +68,16 @@ def _check_installer_runs(tmpdir: Path) -> tuple[int, Path | None]:
 
 
 def _check_default_profile(settings: Path) -> int:
-    """Step 2 — assert default cost_profile matches the contract."""
+    """Step 2 — assert default rule_loading_tier matches the contract."""
     import yaml
 
     parsed = yaml.safe_load(settings.read_text(encoding="utf-8"))
     if not isinstance(parsed, dict):
         return _fail(f"{settings.name}: top-level is not a YAML mapping")
-    profile = parsed.get("cost_profile")
+    profile = parsed.get("rule_loading_tier")
     if profile != EXPECTED_DEFAULT_PROFILE:
         return _fail(
-            f"cost_profile drift: docs/contracts/cost-profile-defaults.md "
+            f"rule_loading_tier drift: docs/contracts/rule-loading-tier-defaults.md "
             f"declares '{EXPECTED_DEFAULT_PROFILE}', settings has '{profile!r}'"
         )
     return 0

package/scripts/sync_agent_settings.py

@@ -90,7 +90,7 @@ def main(argv: list[str] | None = None) -> int:
     ap.add_argument("--template", default=str(DEFAULT_TEMPLATE),
                     help="path to the settings template")
     ap.add_argument("--profile", default=None,
-                    help="cost_profile preset (minimal|balanced|full). "
+                    help="rule_loading_tier preset (minimal|balanced|full). "
                          "Default: inferred from target, else 'minimal'")
     ap.add_argument("--profile-dir", default=str(DEFAULT_PROFILE_DIR),
                     help="directory containing profile .ini files")
@@ -108,7 +108,9 @@ def main(argv: list[str] | None = None) -> int:
 
     try:
         user_data = load_user(target)
-        profile = args.profile or str(user_data.get("cost_profile") or "minimal")
+        profile = args.profile or str(
+            user_data.get("rule_loading_tier") or user_data.get("cost_profile") or "minimal"
+        )
         if profile not in _install.SUPPORTED_PROFILES:
             print(f"error: unsupported profile {profile!r}", file=sys.stderr)
             return 2

package/scripts/validate_agent_settings.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Agent-settings schema validator (rule_loading_tier untangle, 2026-06-01).
+
+Validates ``config/agent-settings.template.yml`` and any local
+``.agent-settings.yml`` against
+``scripts/schemas/agent-settings.schema.json``. The schema is
+deliberately permissive (``additionalProperties: true`` everywhere) and
+only enum-constrains the value-bearing keys that have historically been
+overloaded with a foreign vocabulary — the root cause of the
+``rule_loading_tier`` / memory-cadence collision. Its job is to make a
+value-vocabulary collision a hard CI failure.
+
+Template placeholders (``__RULE_LOADING_TIER__``, ``__USER_TYPE__``) are
+substituted with their installer defaults before validation, mirroring
+``scripts/install.py``.
+
+Exit codes:
+- 0 — every checked file validates.
+- 1 — at least one schema violation (unknown enum value, wrong type).
+- 3 — bootstrap failure (missing dependency / schema file).
+
+Contract: docs/contracts/cost-profile-defaults.md +
+docs/contracts/memory-visibility-v1.md. Wired into ``task ci`` via
+``taskfiles/ci-fast.yml``.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:  # pragma: no cover — bootstrap guard
+    print("::error::PyYAML not installed; cannot validate agent settings")
+    sys.exit(3)
+
+try:
+    import jsonschema
+except ImportError:  # pragma: no cover — bootstrap guard
+    print("::error::jsonschema not installed; cannot validate agent settings")
+    sys.exit(3)
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+SCHEMA_PATH = REPO_ROOT / "scripts" / "schemas" / "agent-settings.schema.json"
+TEMPLATE_PATH = REPO_ROOT / "config" / "agent-settings.template.yml"
+LOCAL_PATHS = [REPO_ROOT / ".agent-settings.yml"]
+
+# Installer-default substitutions, mirroring scripts/install.py so the
+# template validates as it would after a fresh `balanced` install.
+PLACEHOLDERS = {
+    "__RULE_LOADING_TIER__": "balanced",
+    "__USER_TYPE__": "",
+}
+
+
+def _load_yaml(path: Path, *, substitute: bool) -> dict | None:
+    if not path.is_file():
+        return None
+    text = path.read_text(encoding="utf-8")
+    if substitute:
+        for placeholder, value in PLACEHOLDERS.items():
+            text = text.replace(placeholder, value)
+    try:
+        raw = yaml.safe_load(text)
+    except yaml.YAMLError as exc:
+        print(f"::error file={path}::malformed YAML: {exc}")
+        return {}
+    if raw is None:
+        return {}
+    if not isinstance(raw, dict):
+        print(f"::error file={path}::top-level must be a mapping")
+        return {}
+    return raw
+
+
+def _validate(path: Path, doc: dict, validator: jsonschema.Draft7Validator) -> int:
+    errors = sorted(validator.iter_errors(doc), key=lambda e: list(e.path))
+    if not errors:
+        return 0
+    for err in errors:
+        loc = ".".join(str(p) for p in err.path) or "<root>"
+        print(f"::error file={path}::{loc}: {err.message}")
+    return len(errors)
+
+
+def main() -> int:
+    if not SCHEMA_PATH.is_file():
+        print(f"::error::schema missing: {SCHEMA_PATH}")
+        return 3
+    schema = json.loads(SCHEMA_PATH.read_text(encoding="utf-8"))
+    validator = jsonschema.Draft7Validator(schema)
+
+    total_errors = 0
+    checked = 0
+
+    template = _load_yaml(TEMPLATE_PATH, substitute=True)
+    if template is None:
+        print(f"::error file={TEMPLATE_PATH}::template missing")
+        return 1
+    total_errors += _validate(TEMPLATE_PATH, template, validator)
+    checked += 1
+
+    for local in LOCAL_PATHS:
+        doc = _load_yaml(local, substitute=False)
+        if doc is None:
+            continue
+        total_errors += _validate(local, doc, validator)
+        checked += 1
+
+    if total_errors:
+        print(f"agent-settings schema: {total_errors} violation(s) across {checked} file(s)")
+        return 1
+    print(f"agent-settings schema: OK ({checked} file(s) validated)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/templates/minimal/.agent-settings.yml

@@ -15,7 +15,7 @@
 # --- Cost profile ---
 # Master switch for which rule tiers load. Options: minimal | balanced | full.
 # `balanced` is the recommended default; flip to `minimal` for kernel-only.
-cost_profile: balanced
+rule_loading_tier: balanced
 
 # --- Version pin (opt-in) ---
 # Leave commented out to follow whatever `agent-config` is on $PATH (per D4).