@event4u/agent-config 5.10.1 → 6.0.0

package/src/scripts/skill_usage_collect.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""Collect skill-activation signal from Claude Code session jsonl.
+
+Implements step-2-skill-inventory-rationalization.md Phase 1 Step 2.
+Reads `~/.claude/projects/<project-slug>/*.jsonl` for the current repo,
+parses each turn for two signals:
+
+  - exposure: the skill slug appeared in an `attachment.type=skill_listing`
+    payload (catalog presented to the agent that turn).
+  - mention:  the assistant-text response in the same or following turn
+    referenced the slug in backticks with one of the anchor verbs
+    (using, via, per, route, dispatch, invoke, call) OR cited a SKILL.md
+    path under `.augment/skills/<slug>/`, `.claude/skills/<slug>/`, or
+    `dist/agent-src/skills/<slug>/`.
+
+Emits one JSONL record per (session, turn, slug, kind) to
+`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/evidence/audits/2026-05-14-north-star/skill-usage-sources.md`.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Iterable, Iterator
+
+REPO = Path(__file__).resolve().parent.parent.parent
+OUT = REPO / "agents" / "metrics" / "skill-usage.jsonl"
+
+LISTING_LINE_RE = re.compile(r"^-\s+([a-z0-9][a-z0-9_-]+):\s", re.MULTILINE)
+ANCHOR_VERBS = ("using", "via", "per", "route", "routing", "dispatch", "dispatched", "invoke", "call")
+PATH_RE = re.compile(r"\.(?:augment|claude|agent-src)/skills/([a-z0-9][a-z0-9_-]+)/SKILL\.md")
+
+
+def project_slug(repo: Path) -> str:
+    return str(repo).replace("/", "-")
+
+
+def session_files(slug: str) -> list[Path]:
+    base = Path.home() / ".claude" / "projects" / slug
+    if not base.is_dir():
+        return []
+    return sorted(base.glob("*.jsonl"))
+
+
+def iter_turns(jsonl: Path) -> Iterator[dict]:
+    with jsonl.open("r", encoding="utf-8", errors="replace") as fh:
+        for line in fh:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+
+def extract_listing(entry: dict) -> set[str]:
+    att = entry.get("attachment") or {}
+    if att.get("type") != "skill_listing":
+        return set()
+    content = att.get("content", "") or ""
+    return set(LISTING_LINE_RE.findall(content))
+
+
+def extract_text(entry: dict) -> str:
+    if entry.get("type") != "assistant":
+        return ""
+    msg = entry.get("message") or {}
+    content = msg.get("content")
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(p.get("text", "") for p in content if isinstance(p, dict) and p.get("type") == "text")
+    return ""
+
+
+def find_mentions(text: str, known_slugs: Iterable[str]) -> set[str]:
+    hits: set[str] = set()
+    if not text:
+        return hits
+    hits.update(PATH_RE.findall(text))
+    for slug in known_slugs:
+        token = f"`{slug}`"
+        if token not in text:
+            continue
+        lower = text.lower()
+        for verb in ANCHOR_VERBS:
+            if f"{verb} {token}".lower() in lower or f"{verb} the {token}".lower() in lower:
+                hits.add(slug)
+                break
+    return hits
+
+
+def hash_prompt(text: str) -> str:
+    if not text:
+        return ""
+    return hashlib.sha256(text[:200].encode("utf-8", errors="replace")).hexdigest()[:16]
+
+
+def collect_session(jsonl: Path, all_known: set[str]) -> list[dict]:
+    session_id = jsonl.stem
+    records: list[dict] = []
+    last_prompt_hash = ""
+    listed: set[str] = set()
+    turn_idx = -1
+    for entry in iter_turns(jsonl):
+        etype = entry.get("type")
+        if etype == "user":
+            turn_idx += 1
+            msg = entry.get("message") or {}
+            body = msg.get("content") if isinstance(msg.get("content"), str) else ""
+            last_prompt_hash = hash_prompt(body or "")
+            continue
+        if etype == "attachment":
+            listed |= extract_listing(entry)
+            continue
+        if etype == "assistant":
+            text = extract_text(entry)
+            mentions = find_mentions(text, listed | all_known)
+            ts = entry.get("timestamp") or ""
+            for slug in sorted(listed):
+                records.append({"session_id": session_id, "turn_idx": turn_idx, "slug": slug,
+                                "kind": "exposure", "ts": ts, "prompt_excerpt_hash": last_prompt_hash})
+            for slug in sorted(mentions):
+                records.append({"session_id": session_id, "turn_idx": turn_idx, "slug": slug,
+                                "kind": "mention", "ts": ts, "prompt_excerpt_hash": last_prompt_hash})
+            listed = set()
+    return records
+
+
+def load_known_slugs(repo: Path) -> set[str]:
+    slugs: set[str] = set()
+    for root in (repo / ".augment" / "skills", repo / ".claude" / "skills", repo / "dist/agent-src" / "skills"):
+        if not root.is_dir():
+            continue
+        for skill_md in root.glob("*/SKILL.md"):
+            slugs.add(skill_md.parent.name)
+    return slugs
+
+
+def dedup_key(rec: dict) -> tuple:
+    return (rec["session_id"], rec["turn_idx"], rec["slug"], rec["kind"])
+
+
+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/runtime/metrics/skill-usage.jsonl)")
+    ap.add_argument("--quiet", action="store_true", help="Suppress non-error output")
+    args = ap.parse_args()
+
+    slug = args.project_slug or project_slug(REPO)
+    files = session_files(slug)
+    if not files:
+        if not args.quiet:
+            print(f"no session files for slug {slug}", file=sys.stderr)
+        return 0
+    known = load_known_slugs(REPO)
+    seen: set[tuple] = set()
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    if args.out.exists():
+        for line in args.out.read_text(encoding="utf-8", errors="replace").splitlines():
+            try:
+                seen.add(dedup_key(json.loads(line)))
+            except (json.JSONDecodeError, KeyError):
+                continue
+    appended = 0
+    with args.out.open("a", encoding="utf-8") as fh:
+        for jsonl in files:
+            for rec in collect_session(jsonl, known):
+                k = dedup_key(rec)
+                if k in seen:
+                    continue
+                seen.add(k)
+                fh.write(json.dumps(rec, separators=(",", ":")) + "\n")
+                appended += 1
+    if not args.quiet:
+        print(f"✅  Wrote {appended} new record(s) to {args.out.relative_to(REPO)} ({len(seen)} total)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/scripts/skill_usage_report.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""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/runtime/metrics/skill-usage-report.md`
+with columns:
+
+  slug · exposures_total · mentions_total · exposures_30d · mentions_30d
+       · last_seen · status
+
+`status` ∈ { active, exposed-only, dead } per:
+
+  active        = mentions_30d ≥ 1
+  exposed-only  = exposures_30d ≥ 1 ∧ mentions_30d == 0
+  dead          = exposures_30d == 0
+
+The report is **a baseline, not a verdict**. Rationalization decisions
+live in Phase 2 (`skill-rationalization-candidates.md`).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from collections import defaultdict
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent.parent
+IN = REPO / "agents" / "metrics" / "skill-usage.jsonl"
+OUT = REPO / "agents" / "metrics" / "skill-usage-report.md"
+
+
+def parse_ts(raw: str) -> datetime | None:
+    if not raw:
+        return None
+    try:
+        return datetime.fromisoformat(raw.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+
+
+def load_records(path: Path) -> list[dict]:
+    if not path.exists():
+        return []
+    records: list[dict] = []
+    for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+        if not line.strip():
+            continue
+        try:
+            records.append(json.loads(line))
+        except json.JSONDecodeError:
+            continue
+    return records
+
+
+def aggregate(records: list[dict], now: datetime, window_days: int = 30) -> dict[str, dict]:
+    cutoff = now - timedelta(days=window_days)
+    per: dict[str, dict] = defaultdict(lambda: {
+        "exposures_total": 0, "mentions_total": 0,
+        "exposures_30d": 0, "mentions_30d": 0,
+        "last_seen": None,
+    })
+    for rec in records:
+        slug = rec.get("slug")
+        kind = rec.get("kind")
+        if not slug or kind not in ("exposure", "mention"):
+            continue
+        ts = parse_ts(rec.get("ts") or "")
+        bucket = per[slug]
+        bucket[f"{kind}s_total"] += 1
+        if ts and ts >= cutoff:
+            bucket[f"{kind}s_30d"] += 1
+        if ts and (bucket["last_seen"] is None or ts > bucket["last_seen"]):
+            bucket["last_seen"] = ts
+    return per
+
+
+def status_for(row: dict) -> str:
+    if row["mentions_30d"] >= 1:
+        return "active"
+    if row["exposures_30d"] >= 1:
+        return "exposed-only"
+    return "dead"
+
+
+def all_known_slugs(repo: Path) -> set[str]:
+    slugs: set[str] = set()
+    for root in (repo / ".augment" / "skills", repo / ".claude" / "skills", repo / "dist/agent-src" / "skills"):
+        if not root.is_dir():
+            continue
+        for skill_md in root.glob("*/SKILL.md"):
+            slugs.add(skill_md.parent.name)
+    return slugs
+
+
+def render(per: dict[str, dict], known: set[str]) -> str:
+    rows = []
+    for slug in sorted(known | set(per)):
+        data = per.get(slug, {
+            "exposures_total": 0, "mentions_total": 0,
+            "exposures_30d": 0, "mentions_30d": 0, "last_seen": None,
+        })
+        rows.append({"slug": slug, **data, "status": status_for(data)})
+    rows.sort(key=lambda r: (r["status"] != "dead", -r["exposures_total"], r["slug"]))
+
+    counts = {"active": 0, "exposed-only": 0, "dead": 0}
+    for r in rows:
+        counts[r["status"]] += 1
+    total = len(rows)
+
+    lines = [
+        "# Skill Usage Report (baseline)",
+        "",
+        "> Generated by `scripts/skill_usage_report.py`. Source:",
+        "> `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.",
+        "",
+        f"**Window:** 30-day rolling \u00b7 **Skills tracked:** {total} \u00b7 "
+        f"**Active:** {counts['active']} \u00b7 **Exposed-only:** {counts['exposed-only']} \u00b7 "
+        f"**Dead:** {counts['dead']}",
+        "",
+        "| # | slug | status | exposures_30d | mentions_30d | exposures_total | mentions_total | last_seen |",
+        "|---|---|---|---|---|---|---|---|",
+    ]
+    for i, r in enumerate(rows, 1):
+        last = r["last_seen"].date().isoformat() if r["last_seen"] else "\u2014"
+        lines.append(
+            f"| {i} | `{r['slug']}` | {r['status']} | {r['exposures_30d']} | "
+            f"{r['mentions_30d']} | {r['exposures_total']} | {r['mentions_total']} | {last} |"
+        )
+    lines.append("")
+    lines.append("**Read-out:** rows tagged `dead` are first-cut archive candidates; "
+                 "rows tagged `exposed-only` are first-cut merge / rename candidates "
+                 "(catalog noise, agent never invokes). Phase 2 confirms with "
+                 "structural overlap before any deletion.")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("--in", dest="inp", type=Path, default=IN)
+    ap.add_argument("--out", type=Path, default=OUT)
+    ap.add_argument("--window", type=int, default=30, help="Rolling window in days")
+    ap.add_argument("--quiet", action="store_true")
+    args = ap.parse_args()
+
+    records = load_records(args.inp)
+    now = datetime.now(timezone.utc)
+    per = aggregate(records, now, args.window)
+    known = all_known_slugs(REPO)
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(render(per, known), encoding="utf-8")
+    if not args.quiet:
+        print(f"\u2705  Wrote {args.out.relative_to(REPO)} ({len(known | set(per))} skill(s))")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/scripts/smoke/kernel.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# scripts/smoke/kernel.sh — kernel-tier smoke (step-11 Phase 3 Step 2).
+#
+# Asserts:
+#   1. router.json lists exactly 10 kernel rules.
+#   2. Every kernel rule file exists at dist/agent-src/rules/<id>.md.
+#   3. 9 of 10 carry at least one Iron-Law fenced block.
+#      agent-authority is the dispatch index, exempt from the fence
+#      requirement (docs/contracts/smoke-contracts.md § 3.1).
+#   4. Kernel-bucket char budget breaches ≤ EXPECTED_BREACHES.
+#
+# Runtime ceiling: 30 s.
+# Output: table by default, baseline line on stdout last; SMOKE_QUIET=1
+# suppresses the table.
+# Contract: docs/contracts/smoke-contracts.md
+
+set -euo pipefail
+
+EXPECTED_KERNEL_COUNT=10
+EXPECTED_FENCE_CARRIERS=9
+# Bumped 2 → 3 in v4.0.0: the `fix(authority): block execution offers
+# after roadmap/vision artifact save` commit (d30d441e) pushed
+# scope-control and commit-policy past their per-rule caps; kernel-bucket
+# now sits at 26 538 chars (cap 26 000). The shrinkage belongs in its
+# own kernel-rule-edit PR per `scope-control § Kernel-rule edits` —
+# this PR ships v4 without re-doing the kernel.
+EXPECTED_BREACHES=3
+EXEMPT_FROM_FENCE="agent-authority"
+
+quiet="${SMOKE_QUIET:-0}"
+fail=0
+
+log() { [ "$quiet" = "1" ] || printf '%s\n' "$*"; }
+
+# 1. kernel ids from router.json
+kernel_ids=$(python3 -c '
+import json
+d = json.load(open("dist/router.json"))
+print("\n".join(d.get("kernel", [])))
+')
+kernel_count=$(printf '%s\n' "$kernel_ids" | grep -c .)
+
+log "## Kernel smoke"
+log ""
+log "| Check | Value |"
+log "|---|---:|"
+log "| router.json kernel count | $kernel_count |"
+
+if [ "$kernel_count" -ne "$EXPECTED_KERNEL_COUNT" ]; then
+  echo "❌ kernel count: $kernel_count (expected $EXPECTED_KERNEL_COUNT)"
+  fail=1
+fi
+
+# 2. every kernel rule has a file
+missing=0
+for id in $kernel_ids; do
+  if [ ! -f "dist/agent-src/rules/$id.md" ]; then
+    echo "❌ missing rule file: dist/agent-src/rules/$id.md"
+    missing=$((missing + 1))
+  fi
+done
+log "| Rule files present | $((kernel_count - missing))/$kernel_count |"
+if [ "$missing" -gt 0 ]; then fail=1; fi
+
+# 3. count Iron-Law fences per rule
+fence_carriers=0
+for id in $kernel_ids; do
+  if printf ' %s ' "$EXEMPT_FROM_FENCE" | grep -q " $id "; then
+    continue
+  fi
+  if [ -f "dist/agent-src/rules/$id.md" ]; then
+    fences=$(awk 'BEGIN{c=0;open=0} /^```/{ if(open==0){c++;open=1}else{open=0} } END{print c}' "dist/agent-src/rules/$id.md")
+    if [ "$fences" -ge 1 ]; then
+      fence_carriers=$((fence_carriers + 1))
+    else
+      echo "❌ no Iron-Law fence in dist/agent-src/rules/$id.md"
+      fail=1
+    fi
+  fi
+done
+log "| Iron-Law fence carriers | $fence_carriers/$((kernel_count - 1)) |"
+
+if [ "$fence_carriers" -lt "$EXPECTED_FENCE_CARRIERS" ]; then
+  echo "❌ fence carriers: $fence_carriers (expected $EXPECTED_FENCE_CARRIERS)"
+  fail=1
+fi
+
+# 4. kernel char-budget breach count (advisory: locked at current measured)
+breach_count=0
+if python3 src/scripts/measure_rule_budget.py --kernel-budget-check >/tmp/kernel-budget.$$ 2>&1; then
+  breach_count=0
+else
+  breach_count=$(grep -c "^  - " /tmp/kernel-budget.$$ || true)
+fi
+rm -f /tmp/kernel-budget.$$
+log "| Kernel-budget breaches | $breach_count (locked ≤ $EXPECTED_BREACHES) |"
+
+if [ "$breach_count" -gt "$EXPECTED_BREACHES" ]; then
+  echo "❌ kernel budget breaches: $breach_count > $EXPECTED_BREACHES (regression)"
+  fail=1
+fi
+
+# Baseline line — last line of stdout for CI summary parsing.
+log ""
+echo "BASELINE: $kernel_count kernel rules · $fence_carriers carry Iron-Law fences · 1 dispatch index · $breach_count budget breach(es)"
+
+exit $fail

package/src/scripts/smoke/router.sh

@@ -0,0 +1,148 @@
+#!/usr/bin/env bash
+# scripts/smoke/router.sh — router-tier smoke (step-11 Phase 3 Step 3).
+#
+# Asserts router.json structural integrity:
+#   1. 68 ids = 10 kernel + 23 tier_1 + 35 tier_2 (locked count).
+#   2. Every id resolves to dist/agent-src/rules/<id>.md (0 broken).
+#   3. Every routes_to ref resolves through its prefix
+#      (skill:, command:, guideline:, contract:); missing-contract
+#      count locked at ≤ EXPECTED_MISSING_CONTRACTS.
+#
+# Runtime ceiling: 30 s.
+# Output: table by default, baseline line on stdout last; SMOKE_QUIET=1
+# suppresses the table.
+# Contract: docs/contracts/smoke-contracts.md § 3.2
+
+set -euo pipefail
+
+EXPECTED_TOTAL_IDS=68
+EXPECTED_MISSING_CONTRACTS=2
+
+quiet="${SMOKE_QUIET:-0}"
+log() { [ "$quiet" = "1" ] || printf '%s\n' "$*"; }
+
+result=$(python3 <<'PY'
+import json, os, sys, pathlib
+
+# ADR-017: routes_to resolution walks artefact_roots() across the
+# monorepo. Skills/commands/guidelines may live under any source root.
+sys.path.insert(0, "src/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", [])
+ids = list(kernel) + [r["id"] for r in tier1] + [r["id"] for r in tier2]
+total = len(ids)
+
+# Rule-file resolution
+missing_rules = [i for i in ids if not os.path.exists(f"dist/agent-src/rules/{i}.md")]
+
+# routes_to resolution — multi-root aware via resolve_logical.
+def resolve(ref):
+    if ":" not in ref:
+        kind, rest = "skill", ref
+    else:
+        kind, rest = ref.split(":", 1)
+    if kind == "skill":
+        # Legacy projected path first (fast path), then multi-root source.
+        for p in (
+            f"dist/agent-src/skills/{rest}/SKILL.md",
+            f".agent-src.uncondensed/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.uncondensed/skills/{rest}/SKILL.md"), "skill"
+    if kind == "command":
+        for p in (
+            f"dist/agent-src/commands/{rest}.md",
+            f".agent-src.uncondensed/commands/{rest}.md",
+            f".agent-src.uncondensed/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.uncondensed/commands/{rest}.md", "command"
+    if kind == "guideline":
+        return f"docs/guidelines/{rest}.md", "guideline"
+    if kind == "contract":
+        return f"docs/contracts/{rest}.md", "contract"
+    return None, kind
+
+refs = set()
+for r in tier1 + tier2:
+    for ref in r.get("routes_to", []):
+        refs.add(ref)
+
+missing_by_kind = {"skill": [], "command": [], "guideline": [], "contract": []}
+for ref in refs:
+    path, kind = resolve(ref)
+    if path is None or not os.path.exists(path):
+        missing_by_kind.setdefault(kind, []).append(ref)
+
+print(f"TOTAL_IDS={total}")
+print(f"KERNEL={len(kernel)}")
+print(f"TIER1={len(tier1)}")
+print(f"TIER2={len(tier2)}")
+print(f"MISSING_RULES={len(missing_rules)}")
+print(f"ROUTES_TO_REFS={len(refs)}")
+for kind, items in missing_by_kind.items():
+    print(f"MISSING_{kind.upper()}={len(items)}")
+    for r in items:
+        print(f"  - {kind}: {r}")
+PY
+)
+
+# Parse out the counters
+TOTAL_IDS=$(echo "$result" | grep '^TOTAL_IDS=' | cut -d= -f2)
+KERNEL=$(echo "$result" | grep '^KERNEL=' | cut -d= -f2)
+TIER1=$(echo "$result" | grep '^TIER1=' | cut -d= -f2)
+TIER2=$(echo "$result" | grep '^TIER2=' | cut -d= -f2)
+MISSING_RULES=$(echo "$result" | grep '^MISSING_RULES=' | cut -d= -f2)
+ROUTES_TO_REFS=$(echo "$result" | grep '^ROUTES_TO_REFS=' | cut -d= -f2)
+MISSING_SKILL=$(echo "$result" | grep '^MISSING_SKILL=' | cut -d= -f2)
+MISSING_COMMAND=$(echo "$result" | grep '^MISSING_COMMAND=' | cut -d= -f2)
+MISSING_GUIDELINE=$(echo "$result" | grep '^MISSING_GUIDELINE=' | cut -d= -f2)
+MISSING_CONTRACT=$(echo "$result" | grep '^MISSING_CONTRACT=' | cut -d= -f2)
+
+log "## Router smoke"
+log ""
+log "| Check | Value |"
+log "|---|---:|"
+log "| Total router ids | $TOTAL_IDS (kernel $KERNEL · tier_1 $TIER1 · tier_2 $TIER2) |"
+log "| Broken rule pointers | $MISSING_RULES |"
+log "| routes_to refs | $ROUTES_TO_REFS |"
+log "| missing skill targets | $MISSING_SKILL |"
+log "| missing command targets | $MISSING_COMMAND |"
+log "| missing guideline targets | $MISSING_GUIDELINE |"
+log "| missing contract targets | $MISSING_CONTRACT (locked ≤ $EXPECTED_MISSING_CONTRACTS) |"
+
+fail=0
+if [ "$TOTAL_IDS" -ne "$EXPECTED_TOTAL_IDS" ]; then
+  echo "ℹ️  router id count drifted: $TOTAL_IDS (was $EXPECTED_TOTAL_IDS)"
+fi
+if [ "$MISSING_RULES" -gt 0 ]; then
+  echo "❌ broken rule pointers: $MISSING_RULES"
+  echo "$result" | grep '^  - skill:\|^  - guideline:' || true
+  fail=1
+fi
+if [ "$MISSING_SKILL" -gt 0 ] || [ "$MISSING_COMMAND" -gt 0 ] || [ "$MISSING_GUIDELINE" -gt 0 ]; then
+  echo "❌ broken routes_to targets:"
+  echo "$result" | grep -E '^  - (skill|command|guideline):' || true
+  fail=1
+fi
+if [ "$MISSING_CONTRACT" -gt "$EXPECTED_MISSING_CONTRACTS" ]; then
+  echo "❌ missing contracts: $MISSING_CONTRACT > $EXPECTED_MISSING_CONTRACTS (regression)"
+  echo "$result" | grep '^  - contract:' || true
+  fail=1
+fi
+
+log ""
+echo "BASELINE: $TOTAL_IDS router ids · $MISSING_RULES broken rule pointers · $ROUTES_TO_REFS routes_to refs · $MISSING_CONTRACT missing contracts"
+
+exit $fail

package/src/scripts/smoke/schema.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# scripts/smoke/schema.sh — schema-tier smoke (step-11 Phase 3 Step 4).
+#
+# Runs scripts/skill_linter.py --all over every lintable artefact and
+# asserts:
+#   1. 0 schema FAILs (hard).
+#   2. Warns ≤ EXPECTED_WARNS (regression lock).
+#   3. Total ≥ EXPECTED_MIN_TOTAL (catches accidental skill deletion).
+#
+# v2 schema (step-5) fields are deferred — when step-5 Phase 1 closes,
+# this smoke gains a `model_tier` presence check; Phase 3 adds
+# `schema_version: "2"`. See docs/contracts/smoke-contracts.md § 3.3.
+#
+# Runtime ceiling: 30 s.
+# Output: table by default, baseline line on stdout last; SMOKE_QUIET=1
+# suppresses the table.
+# Contract: docs/contracts/smoke-contracts.md § 3.3
+
+set -euo pipefail
+
+EXPECTED_WARNS=93
+# 6.0.0-D Step 10 moved the command surface out of skill_linter's scan
+# (`artefact_roots()` skills/rules/commands trees) into `src/domains/<pack>/`,
+# which skill_linter does not lint — commands are now guarded by their own
+# gates (command-count-messaging = 150 files / 0 shims, command-verbs,
+# namespace-collision). The skill_linter floor therefore tracks the remaining
+# skill/rule/persona/guideline corpus (≈329), not the pre-move 438 that double-
+# counted commands. This floor still catches accidental skill/rule deletion.
+EXPECTED_MIN_TOTAL=325
+
+quiet="${SMOKE_QUIET:-0}"
+log() { [ "$quiet" = "1" ] || printf '%s\n' "$*"; }
+
+# Run the linter and capture summary
+out=$(python3 src/scripts/skill_linter.py --all --quiet 2>&1 || true)
+summary=$(printf '%s\n' "$out" | grep -E '^Summary: ' | tail -1)
+
+if [ -z "$summary" ]; then
+  echo "❌ skill_linter.py produced no summary line"
+  printf '%s\n' "$out" | tail -5
+  exit 1
+fi
+
+# Parse: "Summary: 346 pass, 92 warn, 0 fail, 438 total"
+pass=$(echo "$summary" | sed -E 's/.*Summary: ([0-9]+) pass.*/\1/')
+warn=$(echo "$summary" | sed -E 's/.*, ([0-9]+) warn.*/\1/')
+fail=$(echo "$summary" | sed -E 's/.*, ([0-9]+) fail.*/\1/')
+total=$(echo "$summary" | sed -E 's/.*, ([0-9]+) total.*/\1/')
+
+log "## Schema smoke"
+log ""
+log "| Check | Value |"
+log "|---|---:|"
+log "| Total artefacts | $total (≥ $EXPECTED_MIN_TOTAL) |"
+log "| Pass | $pass |"
+log "| Warn | $warn (locked ≤ $EXPECTED_WARNS) |"
+log "| Fail | $fail (hard 0) |"
+log "| v2 schema enforcement | deferred (see step-5-schema-rigor.md) |"
+
+exit_code=0
+if [ "$fail" -gt 0 ]; then
+  echo "❌ schema FAILs: $fail (must be 0)"
+  printf '%s\n' "$out" | grep -E '^\[FAIL\]' | head -10 || true
+  exit_code=1
+fi
+if [ "$warn" -gt "$EXPECTED_WARNS" ]; then
+  echo "❌ schema warns: $warn > $EXPECTED_WARNS (regression)"
+  exit_code=1
+fi
+if [ "$total" -lt "$EXPECTED_MIN_TOTAL" ]; then
+  echo "❌ artefact total $total < $EXPECTED_MIN_TOTAL (unexpected deletion?)"
+  exit_code=1
+fi
+
+log ""
+echo "BASELINE: $total lintable artefacts · $fail schema FAIL(s) · $warn warn(s)"
+
+exit $exit_code