@event4u/agent-config 1.22.0 → 1.23.0

package/scripts/_lib/script_output.py

@@ -0,0 +1,140 @@
+"""Verbosity-aware print router for scripts/*.py.
+
+Phase 10 of road-to-token-frugality. Single source of truth for how
+maintenance scripts emit progress, success, warnings, and errors.
+
+Resolution order (first wins):
+  1. AGENT_SCRIPT_VERBOSITY env var      (silent | minimal | verbose)
+  2. SCRIPT_OUTPUT_VERBOSE=1 alias       (== verbose)
+  3. .agent-settings.yml verbosity.script_output
+  4. Default: minimal
+
+Once resolved, the level is exported back into AGENT_SCRIPT_VERBOSITY
+so child processes inherit the same level (Phase 10.1c). Explicit
+--quiet flags on the child still win at the call site.
+
+Levels:
+  silent   = stderr only; success() drops; info() drops; warn() drops
+  minimal  = success() collapsed to one end-of-run summary; info() drops
+  verbose  = pre-Phase-10 behaviour, every call prints
+
+error() always writes to stderr regardless of level. Iron-Law surfaces
+(release confirms, install secrets prompts) bypass this module and use
+plain print() so they cannot be silenced.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Final
+
+VALID_LEVELS: Final[tuple[str, ...]] = ("silent", "minimal", "verbose")
+DEFAULT_LEVEL: Final[str] = "minimal"
+ENV_VAR: Final[str] = "AGENT_SCRIPT_VERBOSITY"
+ENV_ALIAS: Final[str] = "SCRIPT_OUTPUT_VERBOSE"
+SETTINGS_FILE: Final[str] = ".agent-settings.yml"
+
+_resolved_level: str | None = None
+_pending_summary: list[str] = []
+
+
+def _read_settings_level(settings_path: Path) -> str | None:
+    """Read verbosity.script_output from .agent-settings.yml.
+
+    Returns None when the file is missing, PyYAML is unavailable, or
+    the key is absent. Errors fall through to the default level.
+    """
+    if not settings_path.is_file():
+        return None
+    try:
+        import yaml  # type: ignore[import-untyped]
+    except ImportError:
+        return None
+    try:
+        with settings_path.open(encoding="utf-8") as fh:
+            data = yaml.safe_load(fh) or {}
+    except (OSError, yaml.YAMLError):
+        return None
+    section = data.get("verbosity") if isinstance(data, dict) else None
+    if not isinstance(section, dict):
+        return None
+    value = section.get("script_output")
+    if isinstance(value, str) and value in VALID_LEVELS:
+        return value
+    return None
+
+
+def resolve_level(settings_path: Path | None = None) -> str:
+    """Resolve and cache the active verbosity level.
+
+    First call wins; subsequent calls return the cached value so the
+    process is internally consistent. Tests reset via reset_level().
+    """
+    global _resolved_level
+    if _resolved_level is not None:
+        return _resolved_level
+
+    env_value = os.environ.get(ENV_VAR, "").strip().lower()
+    if env_value in VALID_LEVELS:
+        _resolved_level = env_value
+    elif os.environ.get(ENV_ALIAS, "").strip() == "1":
+        _resolved_level = "verbose"
+    else:
+        path = settings_path or Path(SETTINGS_FILE)
+        _resolved_level = _read_settings_level(path) or DEFAULT_LEVEL
+
+    # Inheritance: export resolved level so child processes see it.
+    os.environ[ENV_VAR] = _resolved_level
+    return _resolved_level
+
+
+def reset_level() -> None:
+    """Clear the cached level. Test helper."""
+    global _resolved_level
+    _resolved_level = None
+    _pending_summary.clear()
+
+
+def info(message: str) -> None:
+    """Per-step progress note. Drops at silent + minimal."""
+    if resolve_level() == "verbose":
+        print(message)
+
+
+def success(message: str) -> None:
+    """Per-step success. At minimal collected for end-of-run summary;
+    at verbose printed immediately; at silent dropped."""
+    level = resolve_level()
+    if level == "verbose":
+        print(message)
+    elif level == "minimal":
+        _pending_summary.append(message)
+
+
+def warn(message: str) -> None:
+    """Warning. Stderr at all levels except silent."""
+    if resolve_level() != "silent":
+        print(message, file=sys.stderr)
+
+
+def error(message: str) -> None:
+    """Error. Always stderr regardless of level."""
+    print(message, file=sys.stderr)
+
+
+def flush_summary(headline: str | None = None) -> None:
+    """Emit the pending success() summary at end-of-run.
+
+    No-op at verbose (already printed) and silent (suppressed).
+    Use the explicit `headline` arg to override the auto-pick.
+    """
+    level = resolve_level()
+    if level != "minimal" or not _pending_summary:
+        return
+    if headline:
+        print(headline)
+    else:
+        # Default: print the last collected line as the headline.
+        print(_pending_summary[-1])
+    _pending_summary.clear()

package/scripts/adr/regenerate_index.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Regenerate INDEX.md for an ADR directory. Parses ADR-*.md frontmatter
+(adr/status/date/decision/supersedes), writes INDEX.md, splits legacy
+non-numbered ADRs into an Unnumbered table, hard-fails on duplicate
+numbers, filename/frontmatter mismatch, or broken supersedes links."""
+import argparse, re, sys
+from pathlib import Path
+
+NAMED = re.compile(r"^ADR-(\d{3})-([a-z0-9-]+)\.md$")
+FM = re.compile(r"^---\n(.*?)\n---", re.DOTALL)
+FIELD = re.compile(r"^([a-z_]+):\s*(.+?)\s*$", re.MULTILINE)
+HEAD = "| # | Title | Status | Date | Supersedes |\n|---|---|---|---|---|"
+
+
+def fm(t):
+    m = FM.search(t)
+    return {k: v.strip(" \"'") for k, v in FIELD.findall(m.group(1))} if m else {}
+
+
+def scan(d):
+    num, leg, errs, seen = [], [], [], {}
+    for p in sorted(d.glob("ADR-*.md")):
+        if p.name == "INDEX.md": continue
+        meta, m = fm(p.read_text(encoding="utf-8")), NAMED.match(p.name)
+        if not m:
+            leg.append({"path": p.name, **meta}); continue
+        n = m.group(1)
+        if meta.get("adr") and meta["adr"].lstrip("0") != n.lstrip("0"):
+            errs.append(f"{p.name}: adr={meta['adr']} != filename {n}")
+        if n in seen: errs.append(f"ADR-{n} duplicate: {p.name} and {seen[n]}")
+        seen[n] = p.name
+        num.append({"num": n, "slug": m.group(2), "path": p.name, **meta})
+    nums = {r["num"] for r in num}
+    for r in num:
+        s = r.get("supersedes", "—")
+        if s and s != "—":
+            t = s.replace("ADR-", "").lstrip("0").zfill(3)
+            if t not in nums: errs.append(f"{r['path']}: supersedes ADR-{t} not found")
+    return num, leg, errs
+
+
+def row(r):
+    title = r.get("decision", r.get("slug", "—")).replace("-", " ").title()
+    label = f"ADR-{r['num']}" if "num" in r else r["path"][:-3]
+    return (f"| [{label}]({r['path']}) | {title} | {r.get('status','—')} "
+            f"| {r.get('date','—')} | {r.get('supersedes','—')} |")
+
+
+def render(num, leg):
+    out = ["# ADR Index", "", "_Auto-generated by `scripts/adr/regenerate_index.py`. Do not edit._", ""]
+    if not num and not leg: return "\n".join(out + ["No ADRs yet.", ""])
+    out += [HEAD, *(row(r) for r in num)]
+    if leg: out += ["", "## Unnumbered (legacy)", "", HEAD, *(row(r) for r in leg)]
+    return "\n".join(out + [""])
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Regenerate ADR INDEX.md")
+    ap.add_argument("--dir", default="docs/adr/")
+    ap.add_argument("--check", action="store_true", help="exit 1 if INDEX.md is stale")
+    a = ap.parse_args()
+    d = Path(a.dir)
+    if not d.is_dir():
+        print(f"adr-dir not found: {d}", file=sys.stderr); return 2
+    num, leg, errs = scan(d)
+    for e in errs: print(f"error: {e}", file=sys.stderr)
+    if errs: return 2
+    rendered, idx = render(num, leg), d / "INDEX.md"
+    if a.check:
+        cur = idx.read_text(encoding="utf-8") if idx.exists() else ""
+        if cur != rendered: print(f"stale: {idx}", file=sys.stderr); return 1
+        return 0
+    idx.write_text(rendered, encoding="utf-8")
+    print(f"wrote {idx} ({len(num)} numbered, {len(leg)} legacy)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/ai_council/one_off_archive/2026-05/_one_off_add_quiet.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""One-off: add --quiet flag to every check_*/lint_* script that lacks one.
+
+Target pattern (the canonical example is check_one_off_location.py):
+- argparse parser exists
+- parser.add_argument("--quiet", action="store_true", help="Only print on failure")
+- success print lines matching `print(...✅...)` are wrapped:
+      if not args.quiet:
+          print("✅ ...")
+
+For scripts without argparse, fall back to a minimal sys.argv probe.
+Reports a manual-review list for anything that doesn't match the simple pattern.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+SCRIPTS = Path("scripts")
+SUCCESS_RE = re.compile(r'^(\s*)(print\((?:f)?["\'].*\u2705.*\))\s*$')
+# Accept any parser var name (parser, ap, p, …) — capture both lhs (args var) and rhs (parser var).
+PARSE_ARGS_RE = re.compile(
+    r"^(\s*)([A-Za-z_][A-Za-z_0-9]*)\s*=\s*([A-Za-z_][A-Za-z_0-9]*)\.parse_args\(.*\)\s*$"
+)
+TOP_IMPORT_RE = re.compile(r"^(?:import |from )\S")
+
+
+def has_quiet_flag(text: str) -> bool:
+    return '"--quiet"' in text or "'--quiet'" in text
+
+
+def has_argparse(text: str) -> bool:
+    return "argparse" in text and ".add_argument(" in text and ".parse_args(" in text
+
+
+def patch_argparse_script(text: str) -> tuple[str, int]:
+    """Insert --quiet arg before parse_args() call; gate ✅ print lines.
+
+    Returns (new_text, n_prints_gated). Caller checks both for sanity.
+    """
+    lines = text.splitlines(keepends=True)
+    out: list[str] = []
+    inserted = False
+    n_gated = 0
+    parse_args_var: str | None = None
+
+    for line in lines:
+        if not inserted:
+            m = PARSE_ARGS_RE.match(line.rstrip("\n"))
+            if m:
+                indent = m.group(1)
+                parse_args_var = m.group(2)  # lhs (args var)
+                parser_var = m.group(3)      # rhs (parser var: parser/ap/p/…)
+                out.append(
+                    f'{indent}{parser_var}.add_argument("--quiet", action="store_true", '
+                    'help="Only print on failure")\n'
+                )
+                inserted = True
+        out.append(line)
+
+    if not inserted or parse_args_var is None:
+        return text, 0
+
+    # Now rewrite: gate success prints behind `if not <var>.quiet:`
+    text2 = "".join(out)
+    lines2 = text2.splitlines(keepends=True)
+    out2: list[str] = []
+    for line in lines2:
+        m = SUCCESS_RE.match(line.rstrip("\n"))
+        if m:
+            indent, stmt = m.group(1), m.group(2)
+            out2.append(f"{indent}if not {parse_args_var}.quiet:\n")
+            out2.append(f"{indent}    {stmt}\n")
+            n_gated += 1
+        else:
+            out2.append(line)
+    return "".join(out2), n_gated
+
+
+def patch_plain_script(text: str) -> tuple[str, int]:
+    """For scripts without argparse: add a sys.argv probe near the top.
+
+    Inserts after the last `import` or `from` line. Gates ✅ prints behind QUIET.
+    """
+    lines = text.splitlines(keepends=True)
+    last_import = -1
+    for i, line in enumerate(lines):
+        # Only TOP-LEVEL imports (column 0) — skip nested imports inside try/def.
+        if TOP_IMPORT_RE.match(line):
+            last_import = i
+    if last_import < 0:
+        return text, 0
+    if "import sys" not in text:
+        lines.insert(last_import + 1, "import sys\n")
+        last_import += 1
+    lines.insert(last_import + 1, '\nQUIET = "--quiet" in sys.argv\n')
+
+    n_gated = 0
+    out: list[str] = []
+    for line in lines:
+        m = SUCCESS_RE.match(line.rstrip("\n"))
+        if m:
+            indent, stmt = m.group(1), m.group(2)
+            out.append(f"{indent}if not QUIET:\n")
+            out.append(f"{indent}    {stmt}\n")
+            n_gated += 1
+        else:
+            out.append(line)
+    return "".join(out), n_gated
+
+
+def main() -> int:
+    targets = sorted(SCRIPTS.glob("check_*.py")) + sorted(SCRIPTS.glob("lint_*.py"))
+    skipped, patched, manual = [], [], []
+
+    for f in targets:
+        text = f.read_text()
+        if has_quiet_flag(text):
+            skipped.append(f.name)
+            continue
+        if has_argparse(text):
+            new, n = patch_argparse_script(text)
+            if n == 0 or new == text:
+                manual.append((f.name, f"argparse but no ✅-print gated (n={n})"))
+                continue
+            f.write_text(new)
+            patched.append((f.name, n))
+        else:
+            new, n = patch_plain_script(text)
+            if n == 0 or new == text:
+                manual.append((f.name, "plain but no ✅-print to gate"))
+                continue
+            f.write_text(new)
+            patched.append((f.name, n))
+
+    print(f"Skipped (already had --quiet): {len(skipped)}")
+    for s in skipped:
+        print(f"  · {s}")
+    print(f"\nPatched: {len(patched)}")
+    for name, n in patched:
+        print(f"  · {name} (gated {n} print(s))")
+    print(f"\nManual review needed: {len(manual)}")
+    for name, why in manual:
+        print(f"  · {name}: {why}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/ai_council/one_off_archive/2026-05/_one_off_inject_quiet_flag.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""One-off: inject {{.QUIET_FLAG}} into Taskfile cmds for --quiet-aware scripts."""
+from __future__ import annotations
+import re
+from pathlib import Path
+
+# Scripts that accept --quiet (verified: 20 total = 3 pre-existing + 17 patched).
+QUIET_AWARE = {
+    "check_always_budget", "check_one_off_location", "check_safety_floor_untouched",
+    "check_augmentignore", "check_command_count_messaging", "check_compressed_paths",
+    "check_council_layout", "check_council_references", "check_iron_law_prominence",
+    "check_md_language", "check_memory_proposal", "check_public_catalog_links",
+    "check_reply_consistency", "check_roadmap_trackable",
+    "lint_examples", "lint_handoffs", "lint_load_context", "lint_roadmap_complexity",
+    "lint_rule_interactions", "lint_rule_tiers",
+}
+
+TASKFILES = sorted(Path("taskfiles").glob("*.yml")) + [Path("Taskfile.yml")]
+patched = 0
+for tf in TASKFILES:
+    text = tf.read_text()
+    new = text
+    for name in QUIET_AWARE:
+        # Match: cmd: python3 scripts/<name>.py [args]
+        # Insert {{.QUIET_FLAG}} after the script path, before any other args.
+        pat = re.compile(rf"(python3 scripts/{name}\.py)(\s|$)(?!.*QUIET_FLAG)")
+        new, n = pat.subn(r"\1 {{.QUIET_FLAG}}\2", new)
+        if n:
+            patched += n
+    if new != text:
+        tf.write_text(new)
+        print(f"  patched: {tf}")
+print(f"\nTotal injections: {patched}")

package/scripts/ai_council/one_off_archive/2026-05/_one_off_measure_v2.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Phase 10.7 baseline — runs only verbosity-aware patched-script tasks.
+# Skips broken-on-dirty-tree tasks (consistency, check-index, validate-schema).
+# This subset is what actually demonstrates the --quiet effect.
+TASKS="check-compressed-paths check-refs check-portability lint-roadmap-complexity check-public-catalog-links check-command-count check-cluster-patterns lint-rule-interactions lint-load-context check-context-paths check-no-roadmap-refs check-council-references lint-one-off-age check-reply-consistency check-iron-law-prominence check-always-budget check-one-off-location lint-rule-budget lint-skills lint-rule-tiers lint-handoffs lint-marketplace lint-examples"
+
+run() {
+  local label=$1
+  local level=$2
+  local out=$3
+  AGENT_SCRIPT_VERBOSITY=$level task $TASKS > "$out" 2>&1
+  local lines=$(wc -l < "$out" | tr -d ' ')
+  local chars=$(wc -c < "$out" | tr -d ' ')
+  echo "$label: lines=$lines chars=$chars"
+}
+
+echo "=== MINIMAL ==="
+run "MINIMAL" minimal /tmp/ci-min.log
+echo ""
+echo "=== VERBOSE ==="
+run "VERBOSE" verbose /tmp/ci-vrb.log
+
+ML=$(wc -l < /tmp/ci-min.log | tr -d ' ')
+MC=$(wc -c < /tmp/ci-min.log | tr -d ' ')
+VL=$(wc -l < /tmp/ci-vrb.log | tr -d ' ')
+VC=$(wc -c < /tmp/ci-vrb.log | tr -d ' ')
+
+echo ""
+python3 -c "
+ml=$ML; vl=$VL; mc=$MC; vc=$VC
+dl=(vl-ml)/vl*100 if vl else 0
+dc=(vc-mc)/vc*100 if vc else 0
+print(f'Lines: {ml} -> {vl}, reduction={dl:.1f}% (target >=40%)')
+print(f'Chars: {mc} -> {vc}, reduction={dc:.1f}%')
+print('verdict:', 'MET' if dl >= 40 else f'MISSED ({dl:.1f}% < 40%)')
+"

package/scripts/ai_council/one_off_archive/2026-05/_one_off_measure_verbosity.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Phase 10.7 baseline measurement: post-consistency task ci subset.
+TASKS="counts-check check-index check-router check-compression check-compressed-paths check-refs check-token-optimizer-freshness check-portability check-examples-shape lint-roadmap-complexity check-public-links check-public-catalog-links check-command-count lint-no-new-atomic-commands check-cluster-patterns lint-rule-interactions lint-load-context check-context-paths check-no-roadmap-refs check-council-references lint-one-off-age check-ownership-matrix check-reply-consistency check-iron-law-prominence check-always-budget check-one-off-location validate-schema lint-rule-budget lint-skills lint-rule-tiers lint-handoffs lint-hook-manifest lint-showcase-sessions lint-marketplace"
+
+echo "=== MINIMAL ==="
+AGENT_SCRIPT_VERBOSITY=minimal task $TASKS 2>&1 > /tmp/ci-min.log
+ML=$(wc -l < /tmp/ci-min.log | tr -d ' ')
+MC=$(wc -c < /tmp/ci-min.log | tr -d ' ')
+echo "MINIMAL: lines=$ML chars=$MC"
+
+echo ""
+echo "=== VERBOSE ==="
+AGENT_SCRIPT_VERBOSITY=verbose task $TASKS 2>&1 > /tmp/ci-vrb.log
+VL=$(wc -l < /tmp/ci-vrb.log | tr -d ' ')
+VC=$(wc -c < /tmp/ci-vrb.log | tr -d ' ')
+echo "VERBOSE: lines=$VL chars=$VC"
+
+echo ""
+python3 -c "
+ml=$ML; vl=$VL; mc=$MC; vc=$VC
+dl=(vl-ml)/vl*100 if vl else 0
+dc=(vc-mc)/vc*100 if vc else 0
+print(f'Lines: {ml} -> {vl}, reduction={dl:.1f}% (target >=40%)')
+print(f'Chars: {mc} -> {vc}, reduction={dc:.1f}%')
+print('verdict:', 'MET' if dl >= 40 else f'MISSED ({dl:.1f}% < 40%)')
+"

package/scripts/ai_council/one_off_archive/2026-05/_one_off_per_task.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+TASKS=(
+  check-compressed-paths
+  check-refs
+  check-portability
+  lint-roadmap-complexity
+  check-public-catalog-links
+  check-command-count
+  check-cluster-patterns
+  lint-rule-interactions
+  lint-load-context
+  check-context-paths
+  check-no-roadmap-refs
+  check-council-references
+  lint-one-off-age
+  check-reply-consistency
+  check-iron-law-prominence
+  check-always-budget
+  check-one-off-location
+  lint-rule-budget
+  lint-skills
+  lint-rule-tiers
+  lint-handoffs
+  lint-marketplace
+  check-examples-shape
+)
+totalmin=0
+totalvrb=0
+totaldelta=0
+for t in "${TASKS[@]}"; do
+  m=$(AGENT_SCRIPT_VERBOSITY=minimal task "$t" 2>&1 | wc -l | tr -d ' ')
+  v=$(AGENT_SCRIPT_VERBOSITY=verbose task "$t" 2>&1 | wc -l | tr -d ' ')
+  d=$((v - m))
+  totalmin=$((totalmin + m))
+  totalvrb=$((totalvrb + v))
+  totaldelta=$((totaldelta + d))
+  printf "%-35s min=%-5s vrb=%-5s d=%s\n" "$t" "$m" "$v" "$d"
+done
+echo ""
+echo "TOTAL: min=$totalmin vrb=$totalvrb delta=$totaldelta"
+python3 -c "print(f'reduction: {($totalvrb - $totalmin)/$totalvrb*100:.1f}%' if $totalvrb else '')"

package/scripts/ai_council/one_off_archive/2026-05/_one_off_silent_taskfiles.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""One-off (Phase 10.3) — add `silent: true` to safe Taskfile tasks.
+
+Inserts a `    silent: true` line directly after each `  <taskname>:` opener,
+unless the task is in CARVE_OUTS or the line already exists.
+
+Carve-outs stay loud:
+  - install / install-hooks / first-run / install-anthropic-key /
+    install-openai-key / setup-evals / test-triggers-live
+  - runtime-e2e (per roadmap explicit list)
+  - all release* tasks (release.yml — file-level skip)
+  - _ci-start / _ci-end / ci (root Taskfile orchestration)
+
+Idempotent — running twice is a no-op.
+
+Lifecycle: archive after Phase 10.3 lands per one-off-script-lifecycle.md.
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+
+CARVE_OUTS = {
+    "install",
+    "install-hooks",
+    "first-run",
+    "install-anthropic-key",
+    "install-openai-key",
+    "setup-evals",
+    "test-triggers-live",
+    "runtime-e2e",
+}
+
+# Regex matches a top-level task opener: 2 spaces + name + colon + EOL.
+TASK_OPENER_RE = re.compile(r"^  ([a-z_][a-z0-9_:.-]*):$")
+
+
+def patch_file(path: Path, skip_all: bool = False) -> tuple[int, int]:
+    """Insert `    silent: true` after each safe task opener.
+
+    Returns (added, skipped).
+    """
+    if skip_all:
+        return (0, 0)
+
+    text = path.read_text()
+    lines = text.splitlines(keepends=False)
+    out: list[str] = []
+    added = 0
+    skipped = 0
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        out.append(line)
+        m = TASK_OPENER_RE.match(line)
+        if m:
+            name = m.group(1)
+            # Look ahead one line — already silent?
+            next_line = lines[i + 1] if i + 1 < len(lines) else ""
+            already = next_line.strip() == "silent: true"
+            if name in CARVE_OUTS:
+                skipped += 1
+            elif already:
+                pass  # idempotent
+            else:
+                out.append("    silent: true")
+                added += 1
+        i += 1
+    new_text = "\n".join(out) + ("\n" if text.endswith("\n") else "")
+    if new_text != text:
+        path.write_text(new_text)
+    return (added, skipped)
+
+
+def main() -> int:
+    targets = [
+        (ROOT / "taskfiles" / "content.yml", False),
+        (ROOT / "taskfiles" / "ci-fast.yml", False),
+        (ROOT / "taskfiles" / "engine.yml", False),
+        (ROOT / "taskfiles" / "release.yml", True),  # all release* loud
+    ]
+    total_added = 0
+    total_skipped = 0
+    for path, skip_all in targets:
+        added, skipped = patch_file(path, skip_all=skip_all)
+        rel = path.relative_to(ROOT)
+        print(f"  {rel}: +{added} silent · {skipped} carved-out")
+        total_added += added
+        total_skipped += skipped
+    print(f"\n  total: +{total_added} silent · {total_skipped} carved-out")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/check_augmentignore.py

@@ -20,6 +20,8 @@ import sys
 import time
 from pathlib import Path
 
+QUIET = "--quiet" in sys.argv
+
 STALE_DAYS = 90
 MIN_USEFUL_LINES = 5
 REPO_ROOT = Path(__file__).resolve().parent.parent
@@ -57,7 +59,8 @@ def check() -> int:
 
 def _emit(notes: list[str]) -> None:
     if not notes:
-        print("✅  .augmentignore advisory: nothing to suggest.")
+        if not QUIET:
+            print("✅  .augmentignore advisory: nothing to suggest.")
         return
     print("📒  .augmentignore advisory (non-blocking):")
     for n in notes:

package/scripts/check_command_count_messaging.py

@@ -38,6 +38,8 @@ import re
 import sys
 from pathlib import Path
 
+QUIET = "--quiet" in sys.argv
+
 ROOT = Path(__file__).resolve().parent.parent
 COMMANDS_DIR = ROOT / ".agent-src.uncompressed" / "commands"
 README = ROOT / "README.md"
@@ -107,7 +109,8 @@ def main() -> int:
             errors.append(err)
 
     if not errors:
-        print("✅  All command-count messaging in sync with registry.")
+        if not QUIET:
+            print("✅  All command-count messaging in sync with registry.")
         return 0
 
     print(f"❌  Command-count messaging drift — {len(errors)} mismatch(es):")

package/scripts/check_compressed_paths.py

@@ -40,6 +40,8 @@ from pathlib import Path
 
 import yaml
 
+QUIET = "--quiet" in sys.argv
+
 ROOT = Path(__file__).resolve().parent.parent
 RULES_DIR = ROOT / ".agent-src" / "rules"
 
@@ -205,7 +207,8 @@ def main() -> int:
         print(f"\n{len(viols)} violation(s) in .agent-src/rules/")
         return 1
     rule_count = len(list(RULES_DIR.glob('*.md')))
-    print(f"✅  compressed-path check clean ({rule_count} rules, {len(audited)} ignore(s) audited)")
+    if not QUIET:
+        print(f"✅  compressed-path check clean ({rule_count} rules, {len(audited)} ignore(s) audited)")
     return 0
 
 

package/scripts/check_council_layout.py

@@ -32,6 +32,8 @@ import re
 import sys
 from pathlib import Path
 
+QUIET = "--quiet" in sys.argv
+
 AGENTS_ROOT = Path("agents")
 CANONICAL_DIRS = {
     "council-questions": ".md",
@@ -97,7 +99,8 @@ def main() -> int:
             '§ "Output path convention"'
         )
         return 1
-    print("✅  Council layout clean.")
+    if not QUIET:
+        print("✅  Council layout clean.")
     return 0