@event4u/agent-config 5.6.1 → 5.8.0

package/scripts/prediction-pool/pool_winsim.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""Field model + P(finish 1st) simulator for prediction-pool-optimizer.
+
+Honest operationalisation of the large-pool strategy note: in a big pool the
+target is **P(finish ahead of the whole field)**, not E(points). Maximizing EV
+makes your tip-set converge with everyone else's EV-max set, so you cannot open
+the gap you need. This script measures that — and greedily finds the few tips
+worth flipping off EV-max to manufacture upside.
+
+What it does:
+
+  1. Models the FIELD: each opponent commits one tip per match, drawn from a
+     softmax over the per-match EV table (temperature controls spread — low =
+     the crowd clusters tightly on EV-max, high = noisy). This is a model of
+     the crowd, stated as such; feed a real field distribution if you have one.
+  2. Pre-draws R outcome scenarios from the Poisson grids and pre-scores every
+     opponent once, so evaluating any of MY tip-sets is cheap.
+  3. Reports P(win) for the EV-max-everywhere baseline, then runs a greedy
+     flip search: repeatedly flip the single tip that most raises P(win),
+     reporting the EV cost and the P(win) gain per flip, up to --max-flips.
+
+The lesson it makes concrete: with small N the EV-max set already wins often
+and flips do not help (don't add variance you don't need); with large N and a
+deficit, a handful of calculated flips can lift P(win) materially at a small
+EV cost. The crossover is empirical — run it.
+
+It is an APPROXIMATION: the field is a softmax-EV model, not your real pool's
+tips, and the Poisson grids are only as good as the lambdas you feed (de-vigged
+consensus odds — see reference/odds-and-bonus.md). Outcomes and EV are exact
+for that model; the field shape is a prior.
+
+Input JSON:
+{
+  "rule": {"exact": 5, "diff": 3, "tendency": 2},
+  "participants": 120,            # field size N; opponents modelled = N-1 (capped by --max-opponents)
+  "my_lead": 0,                   # my current points minus the rival-to-beat's (negative = behind)
+  "field_temperature": 0.6,       # softmax temp for crowd spread around EV-max
+  "matches": [
+    {"match": "A", "lh": 2.0, "la": 0.7},
+    {"match": "B", "lh": 0.6, "la": 2.1}
+  ]
+}
+
+Usage:
+  python3 scripts/prediction-pool/pool_winsim.py pool.json --runs 4000 --max-flips 4 [--seed 1]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import random
+import sys
+from pathlib import Path
+
+# Reuse the exact-score engine.
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from score_ev import ev_table, grid, _score  # noqa: E402
+
+
+def _parse_tip(s: str) -> tuple[int, int]:
+    h, a = s.split(":")
+    return int(h), int(a)
+
+
+def _flat_grid(g):
+    """Flatten a joint grid into (prob, (h,a)) pairs for sampling."""
+    flat = []
+    for h in range(len(g)):
+        for a in range(len(g[h])):
+            p = g[h][a]
+            if p > 0:
+                flat.append((p, (h, a)))
+    return flat
+
+
+def _sample_outcome(flat, rng: random.Random) -> tuple[int, int]:
+    r = rng.random()
+    acc = 0.0
+    for p, ha in flat:
+        acc += p
+        if r <= acc:
+            return ha
+    return flat[-1][1]
+
+
+def _softmax_pick(rows, temperature: float, rng: random.Random) -> tuple[int, int]:
+    """Pick a tip (h,a) from EV rows via softmax(EV / temperature)."""
+    if temperature <= 0:
+        h, a, _ = rows[0]
+        return h, a
+    top = rows[:24]  # the tail has negligible mass; cap for speed
+    mx = top[0][2]
+    weights = [math.exp((ev - mx) / temperature) for _, _, ev in top]
+    tot = sum(weights)
+    r = rng.random() * tot
+    acc = 0.0
+    for (h, a, _), w in zip(top, weights):
+        acc += w
+        if r <= acc:
+            return h, a
+    h, a, _ = top[-1]
+    return h, a
+
+
+def run(cfg: dict, runs: int, max_flips: int, max_opponents: int, top_flip: int,
+        seed: int):
+    rng = random.Random(seed)
+    rule = cfg.get("rule", {"exact": 4, "diff": 3, "tendency": 2})
+    pe, pd, pt = float(rule["exact"]), float(rule["diff"]), float(rule["tendency"])
+    n = int(cfg.get("participants", 20))
+    my_lead = float(cfg.get("my_lead", 0))
+    temp = float(cfg.get("field_temperature", 0.6))
+    matches = cfg["matches"]
+    n_opp = max(0, min(n - 1, max_opponents))
+
+    # Per match: EV table + sampling grid.
+    per = []
+    for m in matches:
+        rows, _ = ev_table(m["lh"], m["la"], pe, pd, pt, max_tip=6)
+        g = grid(m["lh"], m["la"])
+        per.append({"name": m.get("match", "?"), "rows": rows, "flat": _flat_grid(g)})
+
+    # Pre-draw R outcome scenarios (one actual scoreline per match per run).
+    scenarios = [[_sample_outcome(p["flat"], rng) for p in per] for _ in range(runs)]
+
+    # Model the field: each opponent commits a fixed tip per match (softmax-EV),
+    # then score each opponent across all scenarios. Keep the per-scenario field
+    # MAX so any of my tip-sets can be evaluated against it cheaply.
+    field_max = [(-1e9) for _ in range(runs)]
+    for _ in range(n_opp):
+        opp_tips = [_softmax_pick(p["rows"], temp, rng) for p in per]
+        for s_idx, sc in enumerate(scenarios):
+            tot = 0.0
+            for (th, ta), (ah, aa) in zip(opp_tips, sc):
+                tot += _score(th, ta, ah, aa, pe, pd, pt)
+            if tot > field_max[s_idx]:
+                field_max[s_idx] = tot
+
+    def my_total(tipset, s_idx):
+        sc = scenarios[s_idx]
+        tot = 0.0
+        for (th, ta), (ah, aa) in zip(tipset, sc):
+            tot += _score(th, ta, ah, aa, pe, pd, pt)
+        return tot
+
+    def p_win(tipset):
+        wins = 0
+        for s_idx in range(runs):
+            if my_total(tipset, s_idx) + my_lead > field_max[s_idx]:
+                wins += 1
+        return wins / runs
+
+    # Baseline: EV-max on every match.
+    ev_max_set = [(p["rows"][0][0], p["rows"][0][1]) for p in per]
+    base_pwin = p_win(ev_max_set)
+
+    # Greedy flips: repeatedly flip the one tip that most raises P(win),
+    # considering each match's top-`top_flip` EV candidates.
+    current = list(ev_max_set)
+    flips = []
+    used = set()
+    for _ in range(max_flips):
+        best = None
+        for mi, p in enumerate(per):
+            if mi in used:
+                continue
+            for h, a, ev in p["rows"][:top_flip]:
+                if (h, a) == current[mi]:
+                    continue
+                trial = list(current)
+                trial[mi] = (h, a)
+                pw = p_win(trial)
+                ev_cost = p["rows"][0][2] - ev
+                if best is None or pw > best["pwin"]:
+                    best = {"mi": mi, "tip": (h, a), "pwin": pw, "ev_cost": ev_cost,
+                            "name": p["name"]}
+        if best is None or best["pwin"] <= (flips[-1]["pwin"] if flips else base_pwin):
+            break
+        current[best["mi"]] = best["tip"]
+        used.add(best["mi"])
+        flips.append(best)
+
+    return {
+        "participants": n, "opponents_modelled": n_opp, "runs": runs,
+        "my_lead": my_lead, "field_temperature": temp,
+        "rule": {"exact": pe, "diff": pd, "tendency": pt},
+        "ev_max_set": [f"{per[i]['name']}={h}:{a}" for i, (h, a) in enumerate(ev_max_set)],
+        "p_win_ev_max": round(base_pwin, 4),
+        "flips": [
+            {"match": f["name"], "to": f"{f['tip'][0]}:{f['tip'][1]}",
+             "ev_cost": round(f["ev_cost"], 3), "p_win_after": round(f["pwin"], 4)}
+            for f in flips
+        ],
+        "p_win_after_flips": round((flips[-1]["pwin"] if flips else base_pwin), 4),
+    }
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description="Field model + P(win) simulator.")
+    ap.add_argument("config", help="JSON config (rule, participants, my_lead, matches)")
+    ap.add_argument("--runs", type=int, default=4000, help="outcome scenarios (default 4000)")
+    ap.add_argument("--max-flips", type=int, default=4, help="max tips to flip off EV-max")
+    ap.add_argument("--max-opponents", type=int, default=300,
+                    help="cap opponents modelled (default 300)")
+    ap.add_argument("--top-flip", type=int, default=4,
+                    help="EV candidates per match to consider when flipping")
+    ap.add_argument("--seed", type=int, default=1)
+    ap.add_argument("--json", action="store_true", help="emit JSON instead of text")
+    args = ap.parse_args(argv)
+
+    cfg = json.loads(Path(args.config).read_text())
+    res = run(cfg, args.runs, args.max_flips, args.max_opponents, args.top_flip, args.seed)
+
+    if args.json:
+        print(json.dumps(res, indent=2))
+        return 0
+
+    print(f"participants {res['participants']} (modelled {res['opponents_modelled']})  "
+          f"runs {res['runs']}  my_lead {res['my_lead']}  field_temp {res['field_temperature']}")
+    print(f"EV-max set: {', '.join(res['ev_max_set'])}")
+    print(f"P(win) all-EV-max : {res['p_win_ev_max']:.4f}")
+    if not res["flips"]:
+        print("greedy flips: none improved P(win) — EV-max is already best (small/easy field).")
+    else:
+        print("suggested flips (greedy, each raises P(win) most):")
+        for f in res["flips"]:
+            print(f"  flip {f['match']} -> {f['to']}  (EV cost {f['ev_cost']:+.3f})  "
+                  f"P(win) {f['p_win_after']:.4f}")
+        print(f"P(win) after flips: {res['p_win_after_flips']:.4f}  "
+              f"(+{res['p_win_after_flips'] - res['p_win_ev_max']:.4f})")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/prediction-pool/score_ev.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""Exact-score EV optimiser for prediction-pool-optimizer.
+
+Honest replacement for eyeballing the favourite — given each side's expected
+goals (lambda) and the pool's scoring rule, this builds the full Poisson
+score grid and computes the expected points of EVERY candidate tip, then
+prints the EV-maximizing scoreline. It exists to kill two recurring failure
+modes:
+
+  1. Hallucinated high scorelines (4:2, 1:4, 3:2 ...). Under any partial-points
+     rule these are almost never EV-max for a moderate favourite — the points
+     live in the tendency and goal-difference tiers, not the exact high score.
+  2. Under-tipped draws. A correctly-tipped draw banks the goal-difference
+     tier on every draw scoreline, so a 1:1 can beat a 1:0 in a close game.
+     The grid surfaces this; intuition does not.
+
+The scoring model (configurable points per tier):
+
+    exact result  → --exact     (default 4)
+    goal diff      → --diff      (default 3)   # same difference, not exact; draw-on-draw lands here
+    tendency       → --tendency  (default 2)   # same W/D/L sign only
+    else           → 0
+
+For kicktipp's common "2 / 3 / 5" config run with --tendency 2 --diff 3 --exact 5.
+
+It is an APPROXIMATION only in its goal model: a Poisson per side with the
+provided lambdas, sides independent. That is the standard football scoreline
+model and is robust to small lambda changes — but the lambdas themselves must
+come from de-vigged consensus odds (see reference/odds-and-bonus.md), not a
+guess. Feed it real numbers and the EV-max is exact for that model.
+
+Input — either two lambdas on the CLI:
+
+  python3 scripts/prediction-pool/score_ev.py --lh 2.0 --la 0.7
+  python3 scripts/prediction-pool/score_ev.py --lh 0.6 --la 2.1 --tendency 2 --diff 3 --exact 5
+
+or a JSON file of named matches (batch):
+
+  python3 scripts/prediction-pool/score_ev.py matches.json --tendency 2 --diff 3 --exact 5
+
+  matches.json:
+  [
+    {"match": "Senegal-Iraq",  "lh": 2.0, "la": 0.7},
+    {"match": "Qatar-Switzerland", "lh": 0.6, "la": 2.1}
+  ]
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+from pathlib import Path
+
+MAX_GOALS = 12  # truncation of the Poisson grid; tail beyond this is negligible
+
+
+def _pois_pmf(k: int, rate: float) -> float:
+    if rate <= 0:
+        return 1.0 if k == 0 else 0.0
+    return math.exp(-rate) * rate ** k / math.factorial(k)
+
+
+def _sign(x: int) -> int:
+    return (x > 0) - (x < 0)
+
+
+def _score(th: int, ta: int, ah: int, aa: int,
+           pts_exact: float, pts_diff: float, pts_tend: float) -> float:
+    """Points a tip (th:ta) earns against an actual result (ah:aa)."""
+    if th == ah and ta == aa:
+        return pts_exact
+    if (th - ta) == (ah - aa):
+        return pts_diff
+    if _sign(th - ta) == _sign(ah - aa):
+        return pts_tend
+    return 0.0
+
+
+def grid(lh: float, la: float, max_goals: int = MAX_GOALS):
+    """Joint probability of every actual scoreline up to max_goals."""
+    ph = [_pois_pmf(k, lh) for k in range(max_goals + 1)]
+    pa = [_pois_pmf(k, la) for k in range(max_goals + 1)]
+    return [[ph[h] * pa[a] for a in range(max_goals + 1)] for h in range(max_goals + 1)]
+
+
+def ev_table(lh: float, la: float, pts_exact: float, pts_diff: float, pts_tend: float,
+             max_tip: int = 6, max_goals: int = MAX_GOALS):
+    """EV (expected points) of every candidate tip up to max_tip goals/side."""
+    g = grid(lh, la, max_goals)
+    rows = []
+    for th in range(max_tip + 1):
+        for ta in range(max_tip + 1):
+            ev = 0.0
+            for ah in range(max_goals + 1):
+                for aa in range(max_goals + 1):
+                    p = g[ah][aa]
+                    if p <= 0:
+                        continue
+                    s = _score(th, ta, ah, aa, pts_exact, pts_diff, pts_tend)
+                    if s:
+                        ev += p * s
+            rows.append((th, ta, ev))
+    rows.sort(key=lambda r: r[2], reverse=True)
+    return rows, g
+
+
+def _modal(g) -> tuple[int, int, float]:
+    best = (0, 0, 0.0)
+    for h in range(len(g)):
+        for a in range(len(g[h])):
+            if g[h][a] > best[2]:
+                best = (h, a, g[h][a])
+    return best
+
+
+def _p_draw(g) -> float:
+    return sum(g[i][i] for i in range(len(g)))
+
+
+def analyse(lh: float, la: float, pts_exact: float, pts_diff: float, pts_tend: float,
+            max_tip: int = 6, top: int = 6):
+    rows, g = ev_table(lh, la, pts_exact, pts_diff, pts_tend, max_tip)
+    mh, ma, mp = _modal(g)
+    return {
+        "lambda": [lh, la],
+        "rule": {"exact": pts_exact, "diff": pts_diff, "tendency": pts_tend},
+        "ev_max": {"tip": f"{rows[0][0]}:{rows[0][1]}", "ev": round(rows[0][2], 3)},
+        "modal_result": {"score": f"{mh}:{ma}", "prob": round(mp, 3)},
+        "p_draw": round(_p_draw(g), 3),
+        "ranked": [{"tip": f"{h}:{a}", "ev": round(ev, 3)} for h, a, ev in rows[:top]],
+    }
+
+
+def _print_one(name: str | None, res: dict) -> None:
+    if name:
+        print(f"\n## {name}")
+    lh, la = res["lambda"]
+    r = res["rule"]
+    print(f"lambda {lh}:{la}  rule exact={r['exact']} diff={r['diff']} tendency={r['tendency']}")
+    print(f"EV-max tip : {res['ev_max']['tip']}  (EV {res['ev_max']['ev']})")
+    print(f"modal score: {res['modal_result']['score']}  (P {res['modal_result']['prob']})  "
+          f"P(draw) {res['p_draw']}")
+    print("ranked by EV:")
+    for row in res["ranked"]:
+        flag = "  <- EV-max" if row["tip"] == res["ev_max"]["tip"] else ""
+        print(f"  {row['tip']:>5}  EV {row['ev']:.3f}{flag}")
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description="Exact-score EV optimiser (Poisson grid).")
+    ap.add_argument("matches", nargs="?", help="JSON file of matches [{match,lh,la}]")
+    ap.add_argument("--lh", type=float, help="home expected goals (lambda)")
+    ap.add_argument("--la", type=float, help="away expected goals (lambda)")
+    ap.add_argument("--exact", type=float, default=4.0, help="points for exact result (default 4)")
+    ap.add_argument("--diff", type=float, default=3.0, help="points for correct goal difference (default 3)")
+    ap.add_argument("--tendency", type=float, default=2.0, help="points for correct tendency (default 2)")
+    ap.add_argument("--max-tip", type=int, default=6, help="max goals/side to consider as a tip")
+    ap.add_argument("--top", type=int, default=6, help="rows to print per match")
+    ap.add_argument("--json", action="store_true", help="emit JSON instead of text")
+    args = ap.parse_args(argv)
+
+    jobs: list[tuple[str | None, float, float]] = []
+    if args.matches:
+        data = json.loads(Path(args.matches).read_text())
+        for m in data:
+            jobs.append((m.get("match"), float(m["lh"]), float(m["la"])))
+    elif args.lh is not None and args.la is not None:
+        jobs.append((None, args.lh, args.la))
+    else:
+        ap.error("provide either a matches JSON file or --lh and --la")
+
+    out = []
+    for name, lh, la in jobs:
+        res = analyse(lh, la, args.exact, args.diff, args.tendency, args.max_tip, args.top)
+        if name:
+            res["match"] = name
+        out.append(res)
+        if not args.json:
+            _print_one(name, res)
+
+    if args.json:
+        print(json.dumps(out, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/profile_staleness_hook.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Session-profile staleness notice — `session_start` hook.
+
+Phase 1 companion to the locked Phase-0.1 decision (option a, explicit
+`/profile deactivate`). The `runtime.active_packs` overlay survives an IDE
+restart, so this hook does **not** reset it — it only surfaces a one-line
+**staleness notice** when a new session starts with an overlay carried over
+from a previous session. Silently resetting on `session_start` is the
+registry-refresh Catch-22 the council ruled out (see
+`agents/settings/contexts/session-host-capability-audit.md`).
+
+Contract: never blocks. Reads the JSON envelope on stdin (ignored — the
+notice is derived from the overlay file), emits at most one stderr line,
+returns 0 on every path.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+# Make `scripts` importable when invoked as a bare script path.
+_REPO = Path(__file__).resolve().parent.parent
+if str(_REPO) not in sys.path:
+    sys.path.insert(0, str(_REPO))
+
+try:
+    from scripts.config import session_profiles
+except Exception:  # pragma: no cover - defensive; never block the loop
+    session_profiles = None  # type: ignore
+
+
+def _project_root() -> Path:
+    env = os.environ.get("CLAUDE_PROJECT_DIR") or os.environ.get("AGENT_CONFIG_PROJECT_DIR")
+    if env:
+        return Path(env)
+    return Path.cwd()
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Session-profile staleness notice (session_start).")
+    ap.add_argument("--root", default=None)
+    args, _ = ap.parse_known_args(argv)
+
+    # Drain stdin (the dispatcher passes a JSON envelope); we do not need it.
+    try:
+        if not sys.stdin.isatty():
+            sys.stdin.read()
+    except Exception:
+        pass
+
+    if session_profiles is None:
+        return 0
+
+    root = Path(args.root) if args.root else _project_root()
+    try:
+        notice = session_profiles.stale_notice(root)
+    except Exception:
+        return 0  # fail-open — never block the session
+
+    if notice:
+        print(f"[profile] {notice}", file=sys.stderr)
+    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/roadmap_progress_hook.py

@@ -55,6 +55,21 @@ ROADMAP_PREFIX = "agents/roadmaps/"
 ROADMAP_EXCLUDED_PARTS = frozenset({"archive", "skipped"})
 DASHBOARD_PATH = "agents/roadmaps-progress.md"
 
+REGEN_NAME = "update_roadmap_progress.py"
+# Distributed-content script subtrees that may ship the regenerator,
+# in priority order. Project-scoped installs land it under .augment/ or
+# .agent-src/; the package itself carries the same projection.
+DIST_SCRIPT_SUBDIRS = (
+    Path(".augment") / "scripts",
+    Path(".agent-src") / "scripts",
+    Path(".agent-src.uncondensed") / "scripts",
+)
+# Set by the dispatcher (scripts/hooks/dispatch_hook.py) to its own
+# resolved package root, so a globally-installed binary (ADR-020
+# global-only) can locate the shipped regenerator even when the consumer
+# repo carries no project-local distributed content.
+PACKAGE_ROOT_ENV_VAR = "AGENT_CONFIG_PACKAGE_ROOT"
+
 
 def _candidate_paths(payload: dict) -> list[str]:
     """Pull every plausible file path out of a PostToolUse payload."""
@@ -115,15 +130,50 @@ def _is_roadmap_touch(path: str) -> bool:
     return True
 
 
+def _package_roots() -> list[Path]:
+    """Package roots to search for the shipped regenerator, in priority
+    order, when the consumer carries no project-local copy.
+
+    A global-only consumer (ADR-020) never has `.augment/` / `.agent-src/`
+    in its repo — those trees are *distributed content*, which global-only
+    installs keep in the globally-installed package, not the project. The
+    regenerator therefore lives next to the running code, not next to the
+    edited roadmap.
+
+    1. ``AGENT_CONFIG_PACKAGE_ROOT`` — the dispatcher passes its own
+       resolved package root (``dispatch_hook.REPO_ROOT``). This is the
+       same root the dispatcher already trusts to locate this concern, so
+       it survives editable installs, plugin-cache moves, and symlinks
+       that a naive ``__file__`` walk would mis-resolve.
+    2. This hook's own location (``<pkg>/scripts/roadmap_progress_hook.py``
+       → ``<pkg>``) — last-resort fallback for standalone invocation
+       outside the dispatcher.
+    """
+    roots: list[Path] = []
+    env_root = os.environ.get(PACKAGE_ROOT_ENV_VAR, "").strip()
+    if env_root:
+        roots.append(Path(env_root).expanduser())
+    roots.append(Path(__file__).resolve().parent.parent)
+    return roots
+
+
 def _resolve_regenerator(consumer_root: Path) -> Path | None:
-    """Find the regenerator script — package-shipped or installed copy."""
-    for candidate in (
-        consumer_root / ".augment" / "scripts" / "update_roadmap_progress.py",
-        consumer_root / ".agent-src" / "scripts" / "update_roadmap_progress.py",
-        consumer_root / ".agent-src.uncondensed" / "scripts" / "update_roadmap_progress.py",
-    ):
+    """Find the regenerator script.
+
+    Project-local copy first (project-scoped installs), then the package
+    the hook itself ships in (global-only consumers, per ADR-020 — the
+    repo has no project-local distributed content). Returns ``None`` only
+    when no copy exists in either place.
+    """
+    for subdir in DIST_SCRIPT_SUBDIRS:
+        candidate = consumer_root / subdir / REGEN_NAME
         if candidate.is_file():
             return candidate
+    for root in _package_roots():
+        for subdir in DIST_SCRIPT_SUBDIRS:
+            candidate = root / subdir / REGEN_NAME
+            if candidate.is_file():
+                return candidate
     return None
 
 

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,