@event4u/agent-config 1.22.0 → 1.23.0

package/scripts/install-hooks.sh

@@ -39,7 +39,9 @@ echo "✅  Pre-push hook installed."
 cat > "$HOOKS_DIR/pre-commit" << 'EOF'
 #!/usr/bin/env bash
 # Pre-commit hook: verify .claude-plugin/marketplace.json lists every skill
-# that exists on disk under .claude/skills/.
+# that exists on disk under .claude/skills/, AND verify
+# agents/roadmaps-progress.md is in sync with the current state of
+# agents/roadmaps/ (roadmap-progress-sync Iron Law).
 
 python3 scripts/lint_marketplace.py
 status=$?
@@ -52,6 +54,22 @@ if [ $status -ne 0 ]; then
     echo "       git commit --no-verify"
     exit 1
 fi
+
+# Roadmap dashboard sync — only fires when staged changes touch a roadmap
+# file or the dashboard itself, so unrelated commits stay fast.
+if git diff --cached --name-only | grep -qE '^agents/roadmaps(-progress\.md|/)'; then
+    python3 .augment/scripts/update_roadmap_progress.py --check
+    rstatus=$?
+    if [ $rstatus -ne 0 ]; then
+        echo ""
+        echo "❌  Commit blocked — agents/roadmaps-progress.md is stale."
+        echo "   Run './agent-config roadmap:progress' (or"
+        echo "   'python3 .augment/scripts/update_roadmap_progress.py'),"
+        echo "   stage agents/roadmaps-progress.md, then re-commit."
+        echo "   To bypass for an unrelated WIP commit: git commit --no-verify"
+        exit 1
+    fi
+fi
 EOF
 
 chmod +x "$HOOKS_DIR/pre-commit"

package/scripts/install.py

@@ -1280,6 +1280,7 @@ def main(argv: list[str]) -> int:
         fail(f"Unsupported profile: {opts.profile}. Supported: {', '.join(SUPPORTED_PROFILES)}")
 
     project_root = Path(opts.project or os.environ.get("PROJECT_ROOT") or os.getcwd()).resolve()
+    is_first_run = not (project_root / SETTINGS_FILE).exists()
 
     if opts.package:
         package_root = Path(opts.package).resolve()
@@ -1335,18 +1336,22 @@ def main(argv: list[str]) -> int:
     if not QUIET:
         print()
         success("Done.")
-        print()
-        print("  Try these 3 prompts with your agent:")
-        print('    1. "Refactor this function"   → agent analyzes first')
-        print('    2. "Add caching to this"      → agent asks instead of guessing')
-        print('    3. "Implement this feature"   → agent respects your codebase')
-        print()
-        print("  Next steps:")
-        print("    • Commit .agent-settings.yml and bridge files to your repo")
-        print("    • New team members just run composer install / npm install — done")
-        print("    • Inspect hook coverage: ./agent-config hooks:status")
-        print("    • Full walkthrough: https://github.com/event4u-app/agent-config/blob/main/docs/getting-started.md")
-        print()
+        if is_first_run:
+            print()
+            print("  Try these 3 prompts with your agent:")
+            print('    1. "Refactor this function"   → agent analyzes first')
+            print('    2. "Add caching to this"      → agent asks instead of guessing')
+            print('    3. "Implement this feature"   → agent respects your codebase')
+            print()
+            print("  Next steps:")
+            print("    • Commit .agent-settings.yml and bridge files to your repo")
+            print("    • New team members just run composer install / npm install — done")
+            print("    • Inspect hook coverage: ./agent-config hooks:status")
+            print("    • Full walkthrough: https://github.com/event4u-app/agent-config/blob/main/docs/getting-started.md")
+            print()
+        else:
+            print("  Re-run complete. Walkthrough: https://github.com/event4u-app/agent-config/blob/main/docs/getting-started.md")
+            print()
     return 0
 
 

package/scripts/install.sh

@@ -693,11 +693,18 @@ install_cli_wrapper() {
 main() {
     parse_args "$@"
 
-    $QUIET || echo "🔧  Syncing agent-config payload..."
-    $QUIET || echo "    Source: $SOURCE_DIR"
-    $QUIET || echo "    Target: $TARGET_DIR"
-    $DRY_RUN && ! $QUIET && echo "    Mode: DRY RUN"
-    echo ""
+    # First-run detection: gate the verbose source/target banner behind the
+    # absence of .agent-settings.yml. Re-runs print a single status line.
+    local is_first_run=false
+    [[ ! -f "$TARGET_DIR/.agent-settings.yml" ]] && is_first_run=true
+
+    if $is_first_run && ! $QUIET; then
+        echo "🔧  Syncing agent-config payload..."
+        echo "    Source: $SOURCE_DIR"
+        echo "    Target: $TARGET_DIR"
+        $DRY_RUN && echo "    Mode: DRY RUN"
+        echo ""
+    fi
 
     # 0. Migrate legacy infra files (root → agents/) before any content sync.
     migrate_legacy_root_infra "$TARGET_DIR"
@@ -737,9 +744,13 @@ main() {
     # 6. Manage .gitignore
     ensure_gitignore "$TARGET_DIR"
 
-    echo ""
-    $QUIET || echo "✅  agent-config payload synced."
-    $QUIET || echo "    Run scripts/install (or python3 scripts/install.py) to render .agent-settings.yml and bridges."
+    if $is_first_run && ! $QUIET; then
+        echo ""
+        echo "✅  agent-config payload synced."
+        echo "    Run scripts/install (or python3 scripts/install.py) to render .agent-settings.yml and bridges."
+    elif ! $QUIET; then
+        echo "✅  agent-config payload synced."
+    fi
 }
 
 main "$@"

package/scripts/lint_examples.py

@@ -15,6 +15,8 @@ import re
 import sys
 from pathlib import Path
 
+QUIET = "--quiet" in sys.argv
+
 REPO_ROOT = Path(__file__).resolve().parent.parent
 DEMO_GLOB = "docs/guidelines/agent-infra/*-demos.md"
 REQUIRED_FM_KEYS = ("demo_for:", "layer: pattern-memory", "prose_delta:")
@@ -86,11 +88,13 @@ def main() -> int:
             for p in problems:
                 print(f"    - {p}", file=sys.stderr)
         else:
-            print(f"✅  {rel}")
+            if not QUIET:
+                print(f"✅  {rel}")
     if failed:
         print(f"\n❌  {failed} demo file(s) failed shape lint", file=sys.stderr)
         return 1
-    print(f"\n✅  {len(demos)} demo file(s) shape-clean")
+    if not QUIET:
+        print(f"\n✅  {len(demos)} demo file(s) shape-clean")
     return 0
 
 

package/scripts/lint_handoffs.py

@@ -24,6 +24,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Iterable
 
+QUIET = "--quiet" in sys.argv
+
 REPO = Path(__file__).resolve().parents[1]
 SKILLS_DIR = REPO / ".agent-src.uncompressed" / "skills"
 
@@ -202,7 +204,8 @@ def main(argv: list[str] | None = None) -> int:
         skills_dir = Path(argv[0]).resolve()
     violations = lint(skills_dir)
     if not violations:
-        print(f"✅  lint_handoffs: no violations under {skills_dir.relative_to(REPO)}")
+        if not QUIET:
+            print(f"✅  lint_handoffs: no violations under {skills_dir.relative_to(REPO)}")
         return 0
     for v in violations:
         print(v.render(REPO))

package/scripts/lint_load_context.py

@@ -19,6 +19,8 @@ from typing import Iterable
 
 import yaml
 
+QUIET = "--quiet" in sys.argv
+
 ROOT = Path(__file__).resolve().parent.parent
 
 SCAN_DIRS = [
@@ -185,7 +187,8 @@ def main() -> int:
         print(f"❌  {e}")
     if errors:
         return 1
-    print(f"✅  load_context schema clean ({len(graph)} declarer(s))")
+    if not QUIET:
+        print(f"✅  load_context schema clean ({len(graph)} declarer(s))")
     return 0
 
 

package/scripts/lint_roadmap_complexity.py

@@ -21,6 +21,8 @@ import re
 import sys
 from pathlib import Path
 
+QUIET = "--quiet" in sys.argv
+
 REPO_ROOT = Path(__file__).resolve().parent.parent
 ROADMAP_GLOB = "agents/roadmaps/*.md"
 LIGHTWEIGHT_LINE_CAP = 600
@@ -107,7 +109,8 @@ def main() -> int:
             for p in problems:
                 print(f"    - {p}", file=sys.stderr)
         else:
-            print(f"✅  {rel}  [{complexity}]")
+            if not QUIET:
+                print(f"✅  {rel}  [{complexity}]")
     print()
     light = sum(1 for _, c in summary if c == "lightweight")
     structural = sum(1 for _, c in summary if c == "structural")
@@ -119,7 +122,8 @@ def main() -> int:
     if failed:
         print(f"\n❌  {failed} roadmap(s) failed complexity lint", file=sys.stderr)
         return 1
-    print(f"\n✅  {len(roadmaps)} roadmap(s) complexity-clean")
+    if not QUIET:
+        print(f"\n✅  {len(roadmaps)} roadmap(s) complexity-clean")
     return 0
 
 

package/scripts/lint_rule_interactions.py

@@ -22,6 +22,8 @@ from pathlib import Path
 
 import yaml
 
+QUIET = "--quiet" in sys.argv
+
 ROOT = Path(__file__).resolve().parent.parent
 MATRIX = ROOT / "docs" / "contracts" / "rule-interactions.yml"
 RULES_DIR = ROOT / ".agent-src.uncompressed" / "rules"
@@ -141,7 +143,8 @@ def main() -> int:
     if errors:
         fail(errors)
 
-    print(f"✅  rule-interactions.yml clean — {len(declared_rules)} rules, {len(pairs)} pairs.")
+    if not QUIET:
+        print(f"✅  rule-interactions.yml clean — {len(declared_rules)} rules, {len(pairs)} pairs.")
     return 0
 
 

package/scripts/lint_rule_tiers.py

@@ -17,6 +17,8 @@ from __future__ import annotations
 import sys
 from pathlib import Path
 
+QUIET = "--quiet" in sys.argv
+
 REPO = Path(__file__).resolve().parents[1]
 RULES_DIR = REPO / ".agent-src.uncompressed" / "rules"
 
@@ -70,7 +72,8 @@ def main() -> int:
         )
         return 1
 
-    print(f"✅  lint_rule_tiers: {len(rules)} rules, all tier values valid")
+    if not QUIET:
+        print(f"✅  lint_rule_tiers: {len(rules)} rules, all tier values valid")
     return 0
 
 

package/scripts/measure_frugality_savings.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""Phase 0 baseline harness for road-to-trim-frugality-canon.
+
+Measures the *current state* of the frugality canon along four
+deterministic axes. Output: JSONL baseline appended to
+agents/.frugality-baseline.jsonl (gitignored).
+
+Metrics:
+  A. footprint    — per-rule char/token count, kernel/tier breakdown
+  B. fillers      — filler-phrase prevalence in chat-history corpus
+                    (heuristic signal, not full transcript)
+  C. compression  — uncompressed → compressed char delta per rule
+  D. redundancy   — cross-ref overlap across "Interactions:" /
+                    "See also" sections in the canon
+
+Trim phases re-run this harness after each PR. Decline condition fires
+if metric B regresses (filler prevalence increases) or metric C drops
+below current baseline by >10% per rule.
+"""
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+CANON_RULES = [
+    ("direct-answers", "kernel"),
+    ("no-cheap-questions", "kernel"),
+    ("ask-when-uncertain", "kernel"),
+    ("user-interaction", "tier_1"),
+    ("caveman-speak", "tier_1"),
+    ("token-efficiency", "tier_2"),
+]
+CHARTER = "frugality-charter"
+
+FILLER_PATTERNS = [
+    r"\bgreat question\b", r"\bfascinating\b", r"\bexcellent point\b",
+    r"\blet me\s+(check|look|find|verify|investigate|see)\b",
+    r"\bnow\s+(i'll|i will|let's)\b",
+    r"\bgoing to\s+(check|run|use|call|invoke)\b",
+    r"\bperfect\b!?", r"\bawesome\b!?",
+    r"\bhere's what i\b", r"\bfound it\b",
+    r"^\s*(ok|okay|alright)[!,.]\s",
+]
+FILLER_RE = re.compile("|".join(FILLER_PATTERNS), re.IGNORECASE | re.MULTILINE)
+
+# Cross-ref section headers to count for redundancy metric
+XREF_HEADERS = re.compile(r"^##\s+(Interactions|See also|Related)\s*$", re.MULTILINE)
+
+
+def _read(path: Path) -> str:
+    return path.read_text() if path.exists() else ""
+
+
+def metric_a_footprint(root: Path) -> dict:
+    """Per-rule char count, tier classification, total kernel %."""
+    rows = []
+    kernel_total = 0
+    tier1_total = 0
+    tier2_total = 0
+    for name, tier in CANON_RULES:
+        compressed = root / ".agent-src" / "rules" / f"{name}.md"
+        chars = len(_read(compressed))
+        tokens = chars // 4  # rough 4-char/token approximation
+        rows.append({"rule": name, "tier": tier, "chars": chars, "tokens_approx": tokens})
+        if tier == "kernel":
+            kernel_total += chars
+        elif tier == "tier_1":
+            tier1_total += chars
+        elif tier == "tier_2":
+            tier2_total += chars
+    charter_chars = len(_read(root / ".agent-src" / "contexts" / "contracts" / f"{CHARTER}.md"))
+    return {
+        "rules": rows,
+        "kernel_total_chars": kernel_total,
+        "tier_1_total_chars": tier1_total,
+        "tier_2_total_chars": tier2_total,
+        "charter_chars": charter_chars,
+        "kernel_budget_chars": 26000,
+        "kernel_pct": round(100 * kernel_total / 26000, 2),
+    }
+
+
+def metric_b_fillers(corpus: Path) -> dict:
+    """Filler-phrase hits per agent turn in chat-history corpus."""
+    if not corpus.exists():
+        return {"corpus_present": False}
+    lines = corpus.read_text().splitlines()
+    agent_turns = 0
+    filler_hits = 0
+    total_chars = 0
+    for ln in lines[1:]:
+        try:
+            d = json.loads(ln)
+        except json.JSONDecodeError:
+            continue
+        if d.get("t") != "agent":
+            continue
+        text = d.get("text", "")
+        agent_turns += 1
+        total_chars += len(text)
+        filler_hits += len(FILLER_RE.findall(text))
+    return {
+        "corpus_present": True,
+        "agent_turns": agent_turns,
+        "filler_hits_total": filler_hits,
+        "filler_hits_per_turn": round(filler_hits / max(agent_turns, 1), 3),
+        "agent_chars_total": total_chars,
+        "patterns_count": len(FILLER_PATTERNS),
+        "note": "chat-history texts are digests, not full transcripts; signal not output volume",
+    }
+
+
+def metric_c_compression(root: Path) -> dict:
+    """Uncompressed → compressed char delta per rule."""
+    rows = []
+    for name, _ in CANON_RULES:
+        un = len(_read(root / ".agent-src.uncompressed" / "rules" / f"{name}.md"))
+        co = len(_read(root / ".agent-src" / "rules" / f"{name}.md"))
+        delta = un - co
+        ratio = round(co / un, 3) if un else 0
+        rows.append({"rule": name, "uncompressed_chars": un, "compressed_chars": co, "delta": delta, "ratio": ratio})
+    return {"rules": rows}
+
+
+def metric_d_redundancy(root: Path) -> dict:
+    """Cross-ref section count + total xref-block size."""
+    rows = []
+    for name, _ in CANON_RULES:
+        path = root / ".agent-src.uncompressed" / "rules" / f"{name}.md"
+        text = _read(path)
+        xref_count = len(XREF_HEADERS.findall(text))
+        # naive: chars after last xref header to EOF
+        m = list(XREF_HEADERS.finditer(text))
+        xref_block_chars = (len(text) - m[-1].start()) if m else 0
+        rows.append({"rule": name, "xref_sections": xref_count, "xref_block_chars": xref_block_chars})
+    return {"rules": rows, "total_xref_chars": sum(r["xref_block_chars"] for r in rows)}
+
+
+def main() -> int:
+    root = Path(__file__).resolve().parent.parent
+    corpus = root / "agents" / ".agent-chat-history"
+
+    record = {
+        "schema_version": 1,
+        "ts": datetime.now(tz=timezone.utc).isoformat(timespec="seconds"),
+        "phase": "phase_0_baseline",
+        "metric_a_footprint": metric_a_footprint(root),
+        "metric_b_fillers": metric_b_fillers(corpus),
+        "metric_c_compression": metric_c_compression(root),
+        "metric_d_redundancy": metric_d_redundancy(root),
+    }
+
+    out = root / "agents" / ".frugality-baseline.jsonl"
+    with out.open("a") as fh:
+        fh.write(json.dumps(record, ensure_ascii=False) + "\n")
+    print(json.dumps(record, indent=2, ensure_ascii=False))
+    print(f"\nappended → {out.relative_to(root)}", flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/runtime_dispatcher.py

@@ -30,6 +30,7 @@ from typing import List, Optional
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from runtime_registry import SkillRuntime, build_registry
 from runtime_handler import ExecutionResult, HandlerError, execute_shell
+from _lib.script_output import resolve_level  # type: ignore[import-not-found]
 
 
 @dataclass
@@ -187,6 +188,16 @@ def _print_execution(result: ExecutionResult, fmt: str) -> None:
     if fmt == "json":
         print(json.dumps(asdict(result), indent=2))
         return
+    level = resolve_level()
+    if level == "silent" and result.is_success:
+        return
+    if level == "minimal" and result.is_success:
+        marker = "✅" if result.is_success else "❌"
+        print(
+            f"{marker}  {result.skill_name} · {result.handler} · "
+            f"exit={result.exit_code} ({result.duration_ms}ms)"
+        )
+        return
     print(f"Skill: {result.skill_name}")
     print(f"Handler: {result.handler}")
     print(f"Command: {' '.join(result.command)}")