@event4u/agent-config 2.18.0 → 2.20.0

package/scripts/smoke/router.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+# scripts/smoke/router.sh — router-tier smoke (step-11 Phase 3 Step 3).
+#
+# Asserts router.json structural integrity:
+#   1. 75 ids = 9 kernel + 24 tier_1 + 42 tier_2 (locked count).
+#   2. Every id resolves to .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=75
+EXPECTED_MISSING_CONTRACTS=2
+
+quiet="${SMOKE_QUIET:-0}"
+log() { [ "$quiet" = "1" ] || printf '%s\n' "$*"; }
+
+result=$(python3 <<'PY'
+import json, os, sys, pathlib
+
+d = json.load(open("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".agent-src/rules/{i}.md")]
+
+# routes_to resolution
+def resolve(ref):
+    if ":" not in ref:
+        return f".agent-src.uncompressed/skills/{ref}/SKILL.md", "skill"
+    kind, rest = ref.split(":", 1)
+    if kind == "skill":
+        return f".agent-src.uncompressed/skills/{rest}/SKILL.md", "skill"
+    if kind == "command":
+        for p in (
+            f".agent-src.uncompressed/commands/{rest}.md",
+            f".agent-src.uncompressed/commands/{rest}/INDEX.md",
+        ):
+            if os.path.exists(p):
+                return p, "command"
+        return f".agent-src.uncompressed/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/scripts/smoke/schema.sh

@@ -0,0 +1,71 @@
+#!/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=92
+EXPECTED_MIN_TOTAL=438
+
+quiet="${SMOKE_QUIET:-0}"
+log() { [ "$quiet" = "1" ] || printf '%s\n' "$*"; }
+
+# Run the linter and capture summary
+out=$(python3 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

package/scripts/smoke/skills.sh

@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+# scripts/smoke/skills.sh — skills-tier smoke (step-11 Phase 3 Step 5).
+#
+# Picks 5 random skills (deterministic seed = epoch day) from
+# .agent-src.uncompressed/skills/*/SKILL.md and asserts:
+#   1. SKILL.md exists.
+#   2. Frontmatter parses + validates against scripts/schemas/skill.schema.json.
+#   3. `name:` field matches the parent directory name.
+#   4. Total skill count ≥ EXPECTED_MIN_SKILLS (regression lock against
+#      accidental directory removal).
+#
+# 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.4
+
+set -euo pipefail
+
+EXPECTED_MIN_SKILLS=205
+SAMPLE_SIZE=5
+
+quiet="${SMOKE_QUIET:-0}"
+log() { [ "$quiet" = "1" ] || printf '%s\n' "$*"; }
+
+result=$(python3 <<'PY'
+import os, sys, time, hashlib, pathlib, glob
+sys.path.insert(0, "scripts")
+from validate_frontmatter import parse_frontmatter, load_schema, validate
+
+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"))
+)
+total = len(skills)
+print(f"TOTAL_SKILLS={total}")
+
+# Deterministic seed = epoch day → same sample within 24h, drifts daily.
+seed = int(time.time() // 86400)
+import random
+rng = random.Random(seed)
+sample = rng.sample(skills, min(5, total))
+
+schema = load_schema("skill")
+
+failures = []
+for name in sample:
+    path = os.path.join(root, name, "SKILL.md")
+    text = open(path, encoding="utf-8").read()
+    fm, _ = parse_frontmatter(text)
+    if fm is None:
+        failures.append(f"{name}: no frontmatter")
+        continue
+    errs = validate(fm, schema)
+    if errs:
+        for e in errs:
+            failures.append(f"{name}: {e.format()}")
+        continue
+    declared = fm.get("name")
+    if declared != name:
+        failures.append(f"{name}: name field='{declared}' ≠ directory='{name}'")
+
+print(f"SAMPLE={','.join(sample)}")
+print(f"SAMPLE_PASS={len(sample) - len([f for f in failures])}")
+print(f"SAMPLE_TOTAL={len(sample)}")
+for f in failures:
+    print(f"  FAIL: {f}")
+PY
+)
+
+TOTAL_SKILLS=$(echo "$result" | grep '^TOTAL_SKILLS=' | cut -d= -f2)
+SAMPLE=$(echo "$result" | grep '^SAMPLE=' | cut -d= -f2)
+SAMPLE_PASS=$(echo "$result" | grep '^SAMPLE_PASS=' | cut -d= -f2)
+SAMPLE_TOTAL=$(echo "$result" | grep '^SAMPLE_TOTAL=' | cut -d= -f2)
+FAILS=$(echo "$result" | grep -c '^  FAIL:' || true)
+
+log "## Skills smoke"
+log ""
+log "| Check | Value |"
+log "|---|---:|"
+log "| Total skills | $TOTAL_SKILLS (≥ $EXPECTED_MIN_SKILLS) |"
+log "| Sample size | $SAMPLE_TOTAL |"
+log "| Sample (epoch-day seed) | $SAMPLE |"
+log "| Sample pass | $SAMPLE_PASS/$SAMPLE_TOTAL |"
+
+exit_code=0
+if [ "$TOTAL_SKILLS" -lt "$EXPECTED_MIN_SKILLS" ]; then
+  echo "❌ skill count $TOTAL_SKILLS < $EXPECTED_MIN_SKILLS (unexpected deletion?)"
+  exit_code=1
+fi
+if [ "$FAILS" -gt 0 ]; then
+  echo "❌ sample failures:"
+  echo "$result" | grep '^  FAIL:'
+  exit_code=1
+fi
+
+log ""
+echo "BASELINE: $TOTAL_SKILLS skills · $SAMPLE_PASS/$SAMPLE_TOTAL random sample passes (seed=epoch-day)"
+
+exit $exit_code