@event4u/agent-config 5.6.1 → 5.8.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/inventory_abstraction_budget.py

@@ -45,7 +45,12 @@ try:
 except ImportError:
     script_output = None  # graceful fallback when running outside repo
 
-CORE_SRC = REPO_ROOT / "packages" / "core" / ".agent-src.uncondensed"
+from _lib.agent_src import resolve_package_core_path  # noqa: E402
+
+CORE_SRC = resolve_package_core_path(".agent-src.uncondensed")
+# Enforced packages/core targets — read by scripts/check_gate_paths.py so a
+# future move that desyncs this path fails CI instead of silently no-opping.
+GATE_CORE_PATHS = (CORE_SRC,)
 DIRECTIVES_ROOT = CORE_SRC / "templates" / "scripts" / "work_engine" / "directives"
 EVIDENCE_DIR = REPO_ROOT / "agents" / "evidence" / "analysis"
 

package/scripts/lint_agents_md.py

@@ -23,8 +23,18 @@ from dataclasses import dataclass
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "scripts"))
+from _lib.agent_src import resolve_package_core_path  # noqa: E402
+
 QUIET = "--quiet" in sys.argv
 
+_CONSUMER_TEMPLATE = resolve_package_core_path(".agent-src.uncondensed/templates/AGENTS.md")
+# Enforced packages/core target — read by scripts/check_gate_paths.py so a
+# future move that desyncs this path fails CI instead of silently no-opping.
+# Only the consumer-template lives under packages/core; the package-root
+# AGENTS.md sits at the repo root and is intentionally excluded.
+GATE_CORE_PATHS = (_CONSUMER_TEMPLATE,)
+
 LINK_RE = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
 PATH_BACKTICK_RE = re.compile(r"`[^`]*/[^`]*`")
 BULLET_RE = re.compile(r"^\s*[-*+]\s+")
@@ -64,10 +74,7 @@ class Target:
 
 TARGETS = [
     Target(ROOT / "AGENTS.md", "package-root", 3000, 2800, template=False),
-    Target(
-        ROOT / "packages" / "core" / ".agent-src.uncondensed" / "templates" / "AGENTS.md",
-        "consumer-template", 2500, 2300, template=True,
-    ),
+    Target(_CONSUMER_TEMPLATE, "consumer-template", 2500, 2300, template=True),
 ]
 
 

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_hook_concern_budget.py

@@ -49,10 +49,14 @@ import argparse
 import re
 import sys
 from pathlib import Path
+try:  # invocation-agnostic import (repo-root-on-path vs scripts-on-path)
+    from scripts._lib.agent_settings import project_settings_path
+except ModuleNotFoundError:  # pragma: no cover
+    from _lib.agent_settings import project_settings_path
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
 DEFAULT_MANIFEST = REPO_ROOT / "scripts" / "hook_manifest.yaml"
-DEFAULT_SETTINGS = REPO_ROOT / ".agent-settings.yml"
+DEFAULT_SETTINGS = project_settings_path(REPO_ROOT)
 
 DEFAULT_MAX_PER_EVENT = 8
 DEFAULT_TIER1: list[str] = []

package/scripts/lint_marketplace.py

@@ -25,7 +25,14 @@ from pathlib import Path
 ROOT = Path(".")
 MARKETPLACE = ROOT / ".claude-plugin" / "marketplace.json"
 PACKAGE_JSON = ROOT / "package.json"
-CLAUDE_SKILLS_DIR = ROOT / ".claude" / "skills"
+# Committed marketplace skill sources (git-consumed): real skills resolve to
+# .agent-src/skills/<name>; command-as-skill entries to the committed
+# .claude-plugin/skills/<slug> projection. .claude/skills/ is a gitignored
+# local channel and is intentionally NOT a marketplace source.
+SKILL_SOURCE_DIRS = (
+    ROOT / ".agent-src" / "skills",
+    ROOT / ".claude-plugin" / "skills",
+)
 
 
 def fail(errors: list[str]) -> int:
@@ -124,9 +131,10 @@ def main() -> int:
             if not skill_md.exists():
                 errors.append(f"{entry} has no SKILL.md: `{path}`")
 
-    # Reverse-completeness: every SKILL.md on disk under .claude/skills/
-    # must appear in some plugin's skills[]. Catches the drift where new
-    # skills are generated but never added to the marketplace manifest.
+    # Reverse-completeness: every SKILL.md on disk under the committed skill
+    # sources (.agent-src/skills/ + .claude-plugin/skills/) must appear in some
+    # plugin's skills[]. Catches the drift where new skills/commands are
+    # generated but never added to the marketplace manifest.
     listed: set[str] = set()
     for plugin in plugins:
         if not isinstance(plugin, dict):
@@ -135,13 +143,16 @@ def main() -> int:
             if isinstance(path, str):
                 listed.add(path.removeprefix("./"))
 
-    if CLAUDE_SKILLS_DIR.exists():
-        for skill_dir in sorted(CLAUDE_SKILLS_DIR.iterdir()):
+    for source_dir in SKILL_SOURCE_DIRS:
+        if not source_dir.exists():
+            continue
+        prefix = source_dir.relative_to(ROOT).as_posix()
+        for skill_dir in sorted(source_dir.iterdir()):
             if not skill_dir.is_dir():
                 continue
             if not (skill_dir / "SKILL.md").exists():
                 continue
-            rel = f".claude/skills/{skill_dir.name}"
+            rel = f"{prefix}/{skill_dir.name}"
             if rel not in listed:
                 errors.append(
                     f"skill exists on disk but is not listed in marketplace.json: "

package/scripts/lint_roadmap_ci_steps.py

@@ -22,12 +22,16 @@ from __future__ import annotations
 import re
 import sys
 from pathlib import Path
+try:  # invocation-agnostic import (repo-root-on-path vs scripts-on-path)
+    from scripts._lib.agent_settings import project_settings_path
+except ModuleNotFoundError:  # pragma: no cover
+    from _lib.agent_settings import project_settings_path
 
 QUIET = "--quiet" in sys.argv
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
 ROADMAP_GLOB = "agents/roadmaps/*.md"
-SETTINGS_FILE = REPO_ROOT / ".agent-settings.yml"
+SETTINGS_FILE = project_settings_path(REPO_ROOT)
 LOCAL_AUTO_RUN_PAT = re.compile(
     r"^\s*local_auto_run:\s*(true|false)\s*(?:#.*)?$", re.MULTILINE
 )

package/scripts/lint_roadmap_complexity.py

@@ -23,6 +23,10 @@ from __future__ import annotations
 import re
 import sys
 from pathlib import Path
+try:  # invocation-agnostic import (repo-root-on-path vs scripts-on-path)
+    from scripts._lib.agent_settings import project_settings_path
+except ModuleNotFoundError:  # pragma: no cover
+    from _lib.agent_settings import project_settings_path
 
 QUIET = "--quiet" in sys.argv
 
@@ -30,7 +34,7 @@ REPO_ROOT = Path(__file__).resolve().parent.parent
 ROADMAP_GLOB = "agents/roadmaps/*.md"
 LIGHTWEIGHT_LINE_CAP = 600
 LIGHTWEIGHT_PHASE_CAP = 6
-SETTINGS_FILE = REPO_ROOT / ".agent-settings.yml"
+SETTINGS_FILE = project_settings_path(REPO_ROOT)
 HORIZON_WEEKS_PAT = re.compile(
     r"^\s*horizon_weeks:\s*(\d+)\s*(?:#.*)?$", re.MULTILINE
 )

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/mcp_server/prompts.py

@@ -21,6 +21,10 @@ from __future__ import annotations
 import dataclasses
 from dataclasses import dataclass, field
 from pathlib import Path
+try:  # invocation-agnostic import (repo-root-on-path vs scripts-on-path)
+    from scripts._lib.agent_settings import project_settings_path
+except ModuleNotFoundError:  # pragma: no cover
+    from _lib.agent_settings import project_settings_path
 from typing import Any, Literal
 
 # Phase 1 hand-picked skills — kept for the Phase-1 entrypoint
@@ -128,7 +132,7 @@ def _load_active_user_type(root: Path) -> str:
     the loader (consistent with `_strip_frontmatter`). Only matches
     `user_type:` directly under the top-level `personal:` block.
     """
-    settings = root / ".agent-settings.yml"
+    settings = project_settings_path(root)
     if not settings.is_file():
         return ""
     try:

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())