@event4u/agent-config 2.26.0 → 3.1.0

package/scripts/skill_trigger_eval.py

@@ -149,16 +149,32 @@ class MockRouter:
         return loaded, len(query) // 4 + len(skills) * 20, 16
 
 
-def load_skill_metas(root: Path = SKILLS_SOURCE) -> list[SkillMeta]:
-    """Parse name + description from every SKILL.md frontmatter under root."""
+def load_skill_metas(root: Path | None = None) -> list[SkillMeta]:
+    """Parse name + description from every SKILL.md frontmatter under root.
+
+    If ``root`` is None, the package's ``artefact_roots()`` are scanned so
+    discovery works across the monorepo's per-pack ``.agent-src.uncompressed/``
+    trees. A single explicit ``root`` keeps tests that mock a sub-tree working
+    unchanged.
+    """
+    if root is not None:
+        roots = [root]
+    else:
+        from _lib.agent_src import artefact_roots
+        roots = [r / "skills" for r in artefact_roots()]
     metas: list[SkillMeta] = []
-    for skill_dir in sorted(p for p in root.iterdir() if p.is_dir()):
-        skill_md = skill_dir / "SKILL.md"
-        if not skill_md.exists():
+    seen: set[str] = set()
+    for skills_dir in roots:
+        if not skills_dir.is_dir():
             continue
-        meta = _parse_frontmatter(skill_md)
-        if meta is not None:
-            metas.append(meta)
+        for skill_dir in sorted(p for p in skills_dir.iterdir() if p.is_dir()):
+            skill_md = skill_dir / "SKILL.md"
+            if not skill_md.exists():
+                continue
+            meta = _parse_frontmatter(skill_md)
+            if meta is not None and meta.name not in seen:
+                metas.append(meta)
+                seen.add(meta.name)
     return metas
 
 
@@ -587,6 +603,10 @@ def build_arg_parser() -> argparse.ArgumentParser:
 
 
 def _default_triggers_path(skill: str) -> Path:
+    from _lib.agent_src import resolve_logical
+    resolved = resolve_logical(f"skills/{skill}/evals/triggers.json")
+    if resolved is not None:
+        return resolved
     return SKILLS_SOURCE / skill / "evals" / "triggers.json"
 
 

package/scripts/skill_usage_collect.py

@@ -14,12 +14,12 @@ parses each turn for two signals:
     `.agent-src/skills/<slug>/`.
 
 Emits one JSONL record per (session, turn, slug, kind) to
-`agents/metrics/skill-usage.jsonl` (append-only, deduped on the
+`agents/runtime/metrics/skill-usage.jsonl` (append-only, deduped on the
 (session_id, turn_idx, slug, kind) tuple).
 
 Privacy: `prompt_excerpt_hash` = SHA-256 of the first 200 chars of the
 user prompt that opened the turn. No raw user or assistant bodies are
-persisted. See `agents/audit-2026-05-14-north-star/skill-usage-sources.md`.
+persisted. See `agents/evidence/audits/2026-05-14-north-star/skill-usage-sources.md`.
 """
 from __future__ import annotations
 
@@ -153,7 +153,7 @@ def dedup_key(rec: dict) -> tuple:
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
     ap.add_argument("--project-slug", help="Override the ~/.claude/projects slug (defaults to current repo)")
-    ap.add_argument("--out", type=Path, default=OUT, help="Output jsonl (default: agents/metrics/skill-usage.jsonl)")
+    ap.add_argument("--out", type=Path, default=OUT, help="Output jsonl (default: agents/runtime/metrics/skill-usage.jsonl)")
     ap.add_argument("--quiet", action="store_true", help="Suppress non-error output")
     args = ap.parse_args()
 

package/scripts/skill_usage_report.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
-"""Aggregate `agents/metrics/skill-usage.jsonl` into a per-skill report.
+"""Aggregate `agents/runtime/metrics/skill-usage.jsonl` into a per-skill report.
 
 Implements step-2-skill-inventory-rationalization.md Phase 1 Step 3.
-Groups records by slug; emits `agents/metrics/skill-usage-report.md`
+Groups records by slug; emits `agents/runtime/metrics/skill-usage-report.md`
 with columns:
 
   slug · exposures_total · mentions_total · exposures_30d · mentions_30d
@@ -112,7 +112,7 @@ def render(per: dict[str, dict], known: set[str]) -> str:
         "# Skill Usage Report (baseline)",
         "",
         "> Generated by `scripts/skill_usage_report.py`. Source:",
-        "> `agents/metrics/skill-usage.jsonl` (collector emits per-turn",
+        "> `agents/runtime/metrics/skill-usage.jsonl` (collector emits per-turn",
         "> exposure/mention records). See",
         "> [`step-2-skill-inventory-rationalization.md`](../roadmaps/step-2-skill-inventory-rationalization.md)",
         "> Phase 1.",

package/scripts/smoke/kernel.sh

@@ -29,7 +29,7 @@ log() { [ "$quiet" = "1" ] || printf '%s\n' "$*"; }
 # 1. kernel ids from router.json
 kernel_ids=$(python3 -c '
 import json
-d = json.load(open("router.json"))
+d = json.load(open("dist/router.json"))
 print("\n".join(d.get("kernel", [])))
 ')
 kernel_count=$(printf '%s\n' "$kernel_ids" | grep -c .)

package/scripts/smoke/router.sh

@@ -24,7 +24,12 @@ log() { [ "$quiet" = "1" ] || printf '%s\n' "$*"; }
 result=$(python3 <<'PY'
 import json, os, sys, pathlib
 
-d = json.load(open("router.json"))
+# ADR-017: routes_to resolution walks artefact_roots() across the
+# monorepo. Skills/commands/guidelines may live under any source root.
+sys.path.insert(0, "scripts")
+from _lib.agent_src import resolve_logical
+
+d = json.load(open("dist/router.json"))
 kernel = d.get("kernel", [])
 tier1 = d.get("tier_1", [])
 tier2 = d.get("tier_2", [])
@@ -34,20 +39,34 @@ total = len(ids)
 # Rule-file resolution
 missing_rules = [i for i in ids if not os.path.exists(f".agent-src/rules/{i}.md")]
 
-# routes_to resolution
+# routes_to resolution — multi-root aware via resolve_logical.
 def resolve(ref):
     if ":" not in ref:
-        return f".agent-src.uncompressed/skills/{ref}/SKILL.md", "skill"
-    kind, rest = ref.split(":", 1)
+        kind, rest = "skill", ref
+    else:
+        kind, rest = ref.split(":", 1)
     if kind == "skill":
-        return f".agent-src.uncompressed/skills/{rest}/SKILL.md", "skill"
+        # Legacy projected path first (fast path), then multi-root source.
+        for p in (
+            f".agent-src/skills/{rest}/SKILL.md",
+            f".agent-src.uncompressed/skills/{rest}/SKILL.md",
+        ):
+            if os.path.exists(p):
+                return p, "skill"
+        hit = resolve_logical(f"skills/{rest}/SKILL.md")
+        return (str(hit) if hit else f".agent-src.uncompressed/skills/{rest}/SKILL.md"), "skill"
     if kind == "command":
         for p in (
+            f".agent-src/commands/{rest}.md",
             f".agent-src.uncompressed/commands/{rest}.md",
             f".agent-src.uncompressed/commands/{rest}/INDEX.md",
         ):
             if os.path.exists(p):
                 return p, "command"
+        for logical in (f"commands/{rest}.md", f"commands/{rest}/INDEX.md"):
+            hit = resolve_logical(logical)
+            if hit:
+                return str(hit), "command"
         return f".agent-src.uncompressed/commands/{rest}.md", "command"
     if kind == "guideline":
         return f"docs/guidelines/{rest}.md", "guideline"

package/scripts/smoke/skills.sh

@@ -26,13 +26,21 @@ result=$(python3 <<'PY'
 import os, sys, time, hashlib, pathlib, glob
 sys.path.insert(0, "scripts")
 from validate_frontmatter import parse_frontmatter, load_schema, validate
+from _lib.agent_src import artefact_roots
 
-root = ".agent-src.uncompressed/skills"
-skills = sorted(
-    d for d in os.listdir(root)
-    if os.path.isdir(os.path.join(root, d))
-    and os.path.exists(os.path.join(root, d, "SKILL.md"))
-)
+# ADR-017: walk every source root, collect skill dirs by logical name.
+# First root wins on collision (legacy > core > packs per agent_src).
+skills_by_name: dict[str, str] = {}
+for src_root in artefact_roots():
+    sd = src_root / "skills"
+    if not sd.exists():
+        continue
+    for d in sorted(sd.iterdir()):
+        if not d.is_dir():
+            continue
+        if (d / "SKILL.md").exists() and d.name not in skills_by_name:
+            skills_by_name[d.name] = str(d / "SKILL.md")
+skills = sorted(skills_by_name.keys())
 total = len(skills)
 print(f"TOTAL_SKILLS={total}")
 
@@ -46,7 +54,7 @@ schema = load_schema("skill")
 
 failures = []
 for name in sample:
-    path = os.path.join(root, name, "SKILL.md")
+    path = skills_by_name[name]
     text = open(path, encoding="utf-8").read()
     fm, _ = parse_frontmatter(text)
     if fm is None:

package/scripts/smoke_quickstart.py

@@ -7,7 +7,7 @@ Verifies the 3-step Quickstart from a fresh-project perspective:
      `.agent-settings.yml` with the documented default `cost_profile`.
   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/state/<id>.json`) is
+  3. The work-engine state-file format (`agents/runtime/state/<id>.json`) is
      emit-ready — schema for `decision_result` matches the contract.
 
 What it does NOT do:
@@ -20,6 +20,7 @@ Exit codes: 0 = green; 1 = one or more checks failed; 2 = setup error.
 """
 from __future__ import annotations
 
+import os
 import shutil
 import subprocess
 import sys
@@ -49,8 +50,10 @@ def _check_installer_runs(tmpdir: Path) -> tuple[int, Path | None]:
         str(ROOT),
         "--skip-bridges",
     ]
+    # ADR-020: --project is reserved for maintainers; CI is a maintainer context.
+    env = {**os.environ, "AGENT_CONFIG_DEV_MODE": "1"}
     try:
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60, env=env)
     except subprocess.TimeoutExpired:
         return _fail("installer timed out after 60s"), None
     if result.returncode != 0:
@@ -82,7 +85,13 @@ def _check_default_profile(settings: Path) -> int:
 
 def _check_decision_engine_block(settings: Path) -> int:
     """Step 3 — decision_engine block parses through the engine parser."""
-    sys.path.insert(0, str(ROOT / ".agent-src.uncompressed" / "templates" / "scripts"))
+    sys.path.insert(0, str(ROOT / "scripts"))
+    from _lib.agent_src import resolve_logical  # noqa: E402
+
+    template_scripts = resolve_logical("templates/scripts") or (
+        ROOT / ".agent-src.uncompressed" / "templates" / "scripts"
+    )
+    sys.path.insert(0, str(template_scripts))
     try:
         from work_engine.scoring.decision_engine import (  # type: ignore[import-not-found]
             DecisionEngineSettings,

package/scripts/snapshot_agent_outputs.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Snapshot the agent-config build outputs for byte-identity verification.
+
+Used by monorepo Phase 4 (physical layout move) to assert that the
+pre-move and post-move `task sync` + `task build-discovery` outputs
+match byte-for-byte except for `artefacts[].path` values.
+
+Captures sha256 of every file under:
+  - .agent-src/
+  - .augment/
+  - dist/discovery/discovery-manifest.json (also stores parsed copy
+    with paths stripped so the post-move diff is path-only)
+
+CLI:
+  --out PATH    write JSON to this path (default: dist/migration/pre-move-snapshot.json)
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_OUT = ROOT / "dist" / "migration" / "pre-move-snapshot.json"
+
+TARGETS = (
+    ROOT / ".agent-src",
+    ROOT / ".augment",
+)
+MANIFEST = ROOT / "dist" / "discovery" / "discovery-manifest.json"
+
+
+def _sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(65536), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+# Runtime artefacts that never participate in byte-identity verification.
+# Eval last-run.json + pytest caches are gitignored; including them just
+# adds noise when the worktree is clean.
+_SKIP_NAMES = frozenset({"last-run.json"})
+_SKIP_DIRS = frozenset({".pytest_cache", "__pycache__", ".mypy_cache",
+                         ".ruff_cache", "node_modules", ".DS_Store"})
+
+
+def _hash_tree(root: Path) -> dict[str, str]:
+    if not root.exists():
+        return {}
+    hashes: dict[str, str] = {}
+    for p in sorted(root.rglob("*")):
+        if not p.is_file():
+            continue
+        if p.name in _SKIP_NAMES:
+            continue
+        if any(part in _SKIP_DIRS for part in p.parts):
+            continue
+        hashes[p.relative_to(ROOT).as_posix()] = _sha256(p)
+    return hashes
+
+
+def _logical_path(rel: str) -> str:
+    """Strip any source-root prefix (legacy or packages/*) so the diff
+    compares the artefact's logical identity, not its physical location.
+    Non-source paths are returned unchanged.
+    """
+    posix = rel.replace("\\", "/")
+    if posix.startswith(".agent-src.uncompressed/"):
+        return posix[len(".agent-src.uncompressed/"):]
+    if posix.startswith("packages/"):
+        marker = "/.agent-src.uncompressed/"
+        idx = posix.find(marker)
+        if idx != -1:
+            return posix[idx + len(marker):]
+    return posix
+
+
+def _manifest_path_stripped(manifest_path: Path) -> dict[str, Any] | None:
+    if not manifest_path.exists():
+        return None
+    data = json.loads(manifest_path.read_text(encoding="utf-8"))
+    # Strip `path` from every artefact so the diff is path-only, then
+    # re-sort by (category, checksum) so the list order is content-stable
+    # — the original sort is path-based, which shifts when files move
+    # between roots even though no artefact body changed.
+    artefacts = data.get("artefacts", []) or []
+    for a in artefacts:
+        a.pop("path", None)
+    artefacts.sort(key=lambda a: (a.get("category", ""), a.get("checksum", "")))
+    data["artefacts"] = artefacts
+    # Normalise unassigned / documented_unassigned to logical paths and
+    # re-sort so the post-move diff is content-only.
+    for key in ("unassigned", "documented_unassigned"):
+        entries = data.get(key) or []
+        for e in entries:
+            if isinstance(e, dict) and "path" in e:
+                e["path"] = _logical_path(e["path"])
+        entries.sort(key=lambda e: (e.get("path", ""), e.get("category", "")))
+        data[key] = entries
+    # Drop volatile fields: timestamp, the manifest's own checksum (which
+    # covers everything above and changes with any path text), and the
+    # scanner_version (sha of the build script — moves with code edits).
+    data.pop("generated_at", None)
+    data.pop("checksum", None)
+    data.pop("scanner_version", None)
+    return data
+
+
+def _build_snapshot() -> dict[str, Any]:
+    snap: dict[str, Any] = {"schema_version": "1", "trees": {}}
+    for tgt in TARGETS:
+        key = tgt.relative_to(ROOT).as_posix()
+        snap["trees"][key] = _hash_tree(tgt)
+    snap["manifest_sha256"] = _sha256(MANIFEST) if MANIFEST.exists() else None
+    snap["manifest_path_stripped"] = _manifest_path_stripped(MANIFEST)
+    return snap
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    args = ap.parse_args()
+
+    snap = _build_snapshot()
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(
+        json.dumps(snap, indent=2, sort_keys=True, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+    n_files = sum(len(t) for t in snap["trees"].values())
+    print(f"Snapshot: {args.out.relative_to(ROOT)}")
+    print(f"  files hashed     : {n_files}")
+    print(f"  trees            : {list(snap['trees'])}")
+    print(f"  manifest sha256  : {snap['manifest_sha256'][:16] if snap['manifest_sha256'] else 'MISSING'}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/spotcheck_thin_root.py

@@ -4,7 +4,7 @@
 Sends the refactored package-root AGENTS.md and the consumer template
 to Sonnet 4.5 + gpt-4o, asks each member to answer five questions
 that simulate a fresh agent landing on the file. Records qualitative
-verdicts in agents/reports/thin-root-platform-spotcheck.md.
+verdicts in agents/runtime/reports/thin-root-platform-spotcheck.md.
 """
 from __future__ import annotations
 

package/scripts/sync_github_metadata.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Sync `.github/topics.yml` + `.github/about.yml` to the GitHub repo.
+
+Reads two on-disk manifests and pushes them via the REST API:
+  * `PUT  /repos/{owner}/{repo}/topics`   \u2014 topics list
+  * `PATCH /repos/{owner}/{repo}`         \u2014 description + homepage
+
+Default mode is `--dry-run`: fetches remote state, prints a unified
+diff (remote \u2192 desired), exits 0 (or 2 if drift exists when
+`--strict` is passed). `--apply` is required to mutate; it also
+appends an audit row to `agents/evidence/notes/visibility-sync-audit.md`.
+
+Auth: `GITHUB_TOKEN` env var. The repo slug is taken from
+`package.json` `repository.url` (parsed) or `--repo owner/name`.
+
+Stdlib only \u2014 `urllib.request` matches the convention in
+`scripts/_lib/update_check.py`.
+
+Roadmap: agents/roadmaps/strategic-visibility-mcp-topics-positioning.md Phase 1.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as _dt
+import difflib
+import json
+import os
+import re
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+import yaml
+
+ROOT = Path(__file__).resolve().parents[1]
+TOPICS_FILE = ROOT / ".github" / "topics.yml"
+ABOUT_FILE = ROOT / ".github" / "about.yml"
+AUDIT_FILE = ROOT / "agents" / "notes" / "visibility-sync-audit.md"
+API = "https://api.github.com"
+
+
+def _load_yaml(path: Path) -> dict:
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+
+
+def _resolve_repo(explicit: str | None) -> str:
+    if explicit:
+        return explicit
+    pkg = json.loads((ROOT / "package.json").read_text(encoding="utf-8"))
+    url = (pkg.get("repository") or {}).get("url") or ""
+    m = re.search(r"github\.com[:/]+([^/]+/[^/.]+)", url)
+    if not m:
+        sys.exit("ERROR: cannot resolve owner/repo from package.json; pass --repo")
+    return m.group(1)
+
+
+def _request(method: str, url: str, token: str, body: dict | None = None) -> dict:
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, method=method)
+    req.add_header("Authorization", f"Bearer {token}")
+    req.add_header("Accept", "application/vnd.github+json")
+    req.add_header("X-GitHub-Api-Version", "2022-11-28")
+    req.add_header("User-Agent", "event4u-agent-config-sync")
+    if body is not None:
+        req.add_header("Content-Type", "application/json")
+    try:
+        with urllib.request.urlopen(req, timeout=20) as resp:  # noqa: S310
+            return json.loads(resp.read() or b"{}")
+    except urllib.error.HTTPError as e:
+        sys.exit(f"ERROR: {method} {url} \u2192 HTTP {e.code}: {e.read().decode('utf-8', 'replace')[:300]}")
+    except urllib.error.URLError as e:
+        sys.exit(f"ERROR: {method} {url} \u2192 {e.reason}")
+
+
+def _diff(label: str, remote, desired) -> list[str]:
+    a = json.dumps(remote, indent=2, sort_keys=True).splitlines()
+    b = json.dumps(desired, indent=2, sort_keys=True).splitlines()
+    return list(difflib.unified_diff(a, b, fromfile=f"remote/{label}", tofile=f"desired/{label}", lineterm=""))
+
+
+def _audit(repo: str, mutations: list[str]) -> None:
+    AUDIT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    if not AUDIT_FILE.exists():
+        AUDIT_FILE.write_text("# Visibility sync audit log\n\nAppend-only. Every `--apply` run logs one block.\n", encoding="utf-8")
+    ts = _dt.datetime.now(_dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    block = [f"\n## {ts} \u2014 {repo}\n"]
+    block.extend(f"- {m}\n" for m in mutations)
+    with AUDIT_FILE.open("a", encoding="utf-8") as f:
+        f.writelines(block)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("--apply", action="store_true", help="actually mutate the remote (default: dry-run)")
+    ap.add_argument("--strict", action="store_true", help="exit 2 if drift exists (dry-run only)")
+    ap.add_argument("--quiet", action="store_true")
+    ap.add_argument("--repo", help="owner/name (default: parsed from package.json)")
+    args = ap.parse_args()
+
+    repo = _resolve_repo(args.repo)
+    token = os.environ.get("GITHUB_TOKEN")
+    if not token:
+        sys.exit("ERROR: GITHUB_TOKEN not set")
+
+    topics_doc = _load_yaml(TOPICS_FILE)
+    about_doc = _load_yaml(ABOUT_FILE)
+    desired_topics = sorted(topics_doc.get("topics") or [])
+    desired_about = {"description": about_doc.get("description", ""), "homepage": about_doc.get("homepage", "")}
+
+    remote_topics = sorted((_request("GET", f"{API}/repos/{repo}/topics", token).get("names") or []))
+    repo_payload = _request("GET", f"{API}/repos/{repo}", token)
+    remote_about = {"description": repo_payload.get("description") or "", "homepage": repo_payload.get("homepage") or ""}
+
+    topic_diff = _diff("topics", remote_topics, desired_topics)
+    about_diff = _diff("about", remote_about, desired_about)
+    has_drift = bool(topic_diff or about_diff)
+
+    if not args.quiet:
+        if topic_diff:
+            print("\n".join(topic_diff))
+        if about_diff:
+            print("\n".join(about_diff))
+        if not has_drift:
+            print(f"\u2705  {repo}: topics + about already in sync")
+
+    if not args.apply:
+        return 2 if (has_drift and args.strict) else 0
+
+    mutations: list[str] = []
+    if topic_diff:
+        _request("PUT", f"{API}/repos/{repo}/topics", token, {"names": desired_topics})
+        mutations.append(f"topics \u2192 {desired_topics}")
+    if about_diff:
+        _request("PATCH", f"{API}/repos/{repo}", token, desired_about)
+        mutations.append(f"about \u2192 {desired_about}")
+    if mutations:
+        _audit(repo, mutations)
+        if not args.quiet:
+            print(f"\u2705  {repo}: applied {len(mutations)} mutation(s); audit appended")
+    elif not args.quiet:
+        print(f"\u2705  {repo}: nothing to apply")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/sync_gitignore.py

@@ -41,17 +41,27 @@ DEFAULT_GITIGNORE = ".gitignore"
 DEFAULT_TEMPLATE = Path(__file__).resolve().parent.parent / "config" / "gitignore-block.txt"
 
 # Legacy patterns that lived in older versions of config/gitignore-block.txt
-# before runtime artefacts moved under /agents/ (May 2026). They get stripped
-# wherever they appear in the consumer's .gitignore — inside the managed block
-# or outside (older installers / hand-edits). Current canonical equivalents
-# (e.g. /agents/.agent-chat-history) come from the template and are NOT
-# affected. Leading-slash variants are matched defensively.
+# before runtime artefacts moved under /agents/runtime/ (May 2026). They get
+# stripped wherever they appear in the consumer's .gitignore — inside the
+# managed block or outside (older installers / hand-edits). Current canonical
+# equivalents (e.g. /agents/runtime/.agent-prices.md) come from the template
+# and are NOT affected. Leading-slash variants are matched defensively.
 LEGACY_PATTERNS: tuple[str, ...] = (
     ".agent-chat-history",
     ".agent-chat-history.bak",
     ".agent-chat-history.*.bak",
     ".agent-prices.md",
     ".council-tmp/",
+    # 2.x intermediate: prices cache lived directly under agents/ before
+    # consolidating under agents/runtime/.
+    "agents/.agent-prices.md",
+    # Budget history JSONLs — previously listed explicitly at project
+    # root or under agents/; now covered by the /agents/runtime/
+    # catch-all in the managed block.
+    ".augment-budget-history.jsonl",
+    ".rule-budget-history.jsonl",
+    "agents/.augment-budget-history.jsonl",
+    "agents/.rule-budget-history.jsonl",
 )
 
 

package/scripts/update_counts.py

@@ -20,31 +20,59 @@ import re
 import sys
 from pathlib import Path
 
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from _lib.agent_src import artefact_roots  # noqa: E402
+
 REPO_ROOT = Path(__file__).resolve().parent.parent
-SRC = REPO_ROOT / ".agent-src.uncompressed"
 
 
 def count(kind: str) -> int:
-    if kind == "skills":
-        return sum(1 for _ in (SRC / "skills").rglob("SKILL.md"))
     if kind == "guidelines":
         # Guidelines live under docs/guidelines/{topic}/ — they are reference
         # material, not packaged artefacts. Recursive walk to count every .md.
         return sum(1 for _ in (REPO_ROOT / "docs" / "guidelines").rglob("*.md"))
-    if kind == "personas":
-        # personas live as flat .md files, README excluded
-        pdir = SRC / "personas"
-        if not pdir.exists():
-            return 0
-        return sum(1 for f in pdir.glob("*.md") if f.name != "README.md")
-    if kind == "commands":
-        # Commands may be flat (`commands/<name>.md`) or nested under a
-        # cluster directory (`commands/<cluster>/<sub>.md`). Walk the tree
-        # and skip the AGENTS.md reference orchestrator.
-        return sum(
-            1 for f in (SRC / kind).rglob("*.md") if f.name != "AGENTS.md"
-        )
-    return sum(1 for _ in (SRC / kind).glob("*.md"))
+    total = 0
+    seen: set[str] = set()
+    for root in artefact_roots():
+        subdir = root / kind
+        if not subdir.exists():
+            continue
+        if kind == "skills":
+            for f in subdir.rglob("SKILL.md"):
+                rel = f.relative_to(root).as_posix()
+                if rel in seen:
+                    continue
+                seen.add(rel)
+                total += 1
+        elif kind == "personas":
+            # personas live as flat .md files, README excluded
+            for f in subdir.glob("*.md"):
+                if f.name == "README.md":
+                    continue
+                rel = f.relative_to(root).as_posix()
+                if rel in seen:
+                    continue
+                seen.add(rel)
+                total += 1
+        elif kind == "commands":
+            # Commands may be flat or nested under a cluster directory.
+            # Skip the AGENTS.md reference orchestrator.
+            for f in subdir.rglob("*.md"):
+                if f.name == "AGENTS.md":
+                    continue
+                rel = f.relative_to(root).as_posix()
+                if rel in seen:
+                    continue
+                seen.add(rel)
+                total += 1
+        else:
+            for f in subdir.glob("*.md"):
+                rel = f.relative_to(root).as_posix()
+                if rel in seen:
+                    continue
+                seen.add(rel)
+                total += 1
+    return total
 
 
 # file → list of (regex, kind)