@event4u/agent-config 1.21.0 → 1.23.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/migrate_command_suggestions.py

@@ -29,7 +29,7 @@ INELIGIBLE: dict[str, str] = {
     "copilot-agents-init": "Project init — only deliberately during onboarding.",
     "copilot-agents-optimize": "Maintenance refactor; only when the maintainer chooses to run it.",
     "do-and-judge": "Subagent orchestration — overlaps /work and judge skills; keep explicit.",
-    "do-in-steps": "Subagent orchestration — overlaps /work and /roadmap-execute; keep explicit.",
+    "do-in-steps": "Subagent orchestration — overlaps /work and /roadmap:process-*; keep explicit.",
     "fix-portability": "Package-internal — only the event4u/agent-config repo runs this.",
     "fix-references": "Package-internal — only the event4u/agent-config repo runs this.",
     "judge": "Sibling of /review-changes — eligibility routed there; keep this explicit.",
@@ -89,7 +89,7 @@ ELIGIBLE: dict[str, tuple[str, str]] = {
     "review-changes": ("self-review my changes, judge this diff before PR", "uncommitted or staged changes pre-PR"),
     "review-routing": ("who should review this, suggest reviewers for this PR", "PR open without assigned reviewers"),
     "roadmap-create": ("create a roadmap for X, plan this work as a roadmap", "multi-phase work without an existing agents/roadmaps/*.md"),
-    "roadmap-execute": ("execute the roadmap, work through the roadmap step by step", "existing agents/roadmaps/*.md referenced in the prompt"),
+    "roadmap-execute": ("process the roadmap, work through the roadmap autonomously, finish this phase", "existing agents/roadmaps/*.md referenced in the prompt"),
     "rule-compliance-audit": ("audit my rules, check rule trigger quality", "maintainer working on .augment/rules/ files"),
     "tests-create": ("write tests for these changes, add tests for this branch", "code changes on the branch without matching test changes"),
     "tests-execute": ("run the tests, execute the test suite", "code changes pending verification"),

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)}")

package/scripts/schemas/command.schema.json

@@ -49,6 +49,11 @@
       "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$",
       "description": "Semver release in which this command became a shim (e.g. '1.15.0')."
     },
+    "council_depth": {
+      "type": "string",
+      "enum": ["deep"],
+      "description": "Optional reasoning-depth marker for AI Council invocations triggered by this command. The only accepted value is 'deep'; omit the key for default depth (setting 'standard' is rejected — every frontmatter byte counts against the context window, and 'standard' is the implicit default). 'deep' instructs the host agent to pass --depth deep to council_cli, which floors rounds at max(ai_council.deep_min_rounds, ai_council.min_rounds). Use for architecture, refactoring, or bug-diagnosis commands. See .agent-src.uncompressed/skills/ai-council/SKILL.md."
+    },
     "suggestion": {
       "type": "object",
       "additionalProperties": false,

package/scripts/schemas/rule.schema.json

@@ -47,6 +47,11 @@
       "enum": ["1", "2a", "2b", "3", "safety-floor", "mechanical-already", "kernel", "tier-1", "tier-2"],
       "description": "Hardening tier. Legacy values (1/2a/2b/3/safety-floor/mechanical-already) accepted; new router-canonical values (kernel/tier-1/tier-2) introduced by road-to-kernel-and-router.md Phase 4."
     },
+    "council_depth": {
+      "type": "string",
+      "enum": ["deep"],
+      "description": "Optional reasoning-depth marker for AI Council invocations triggered while this rule is active. The only accepted value is 'deep'; omit the key for default depth (setting 'standard' is rejected — every frontmatter byte counts against the context window, and 'standard' is the implicit default). 'deep' instructs the host agent to pass --depth deep to council_cli, which floors rounds at max(ai_council.deep_min_rounds, ai_council.min_rounds). Use for rules that gate architecture, refactoring, or bug-diagnosis flows. See .agent-src.uncompressed/skills/ai-council/SKILL.md."
+    },
     "triggers": {
       "type": "array",
       "items": {

package/scripts/schemas/skill.schema.json

@@ -42,6 +42,11 @@
       "enum": ["senior"],
       "description": "Optional tier marker. `senior` opts the skill into the Senior-Tier Required Structure check (Context-First lead, Related Skills, Proactive Triggers, Output Artifacts) per .agent-src.uncompressed/rules/skill-quality.md."
     },
+    "council_depth": {
+      "type": "string",
+      "enum": ["deep"],
+      "description": "Optional reasoning-depth marker for AI Council invocations triggered by this skill. The only accepted value is 'deep'; omit the key for default depth (setting 'standard' is rejected — every frontmatter byte counts against the context window, and 'standard' is the implicit default). 'deep' instructs the host agent to pass --depth deep to council_cli, which floors rounds at max(ai_council.deep_min_rounds, ai_council.min_rounds). Use for architecture, refactoring, or bug-diagnosis skills. See .agent-src.uncompressed/skills/ai-council/SKILL.md."
+    },
     "execution": {
       "type": "object",
       "additionalProperties": false,