tribunal-kit 1.0.0 → 2.4.2

package/.agent/scripts/session_manager.py

@@ -7,6 +7,10 @@ Usage:
   python .agent/scripts/session_manager.py load
   python .agent/scripts/session_manager.py show
   python .agent/scripts/session_manager.py clear
+  python .agent/scripts/session_manager.py status
+  python .agent/scripts/session_manager.py tag <label>
+  python .agent/scripts/session_manager.py list [--all]
+  python .agent/scripts/session_manager.py export [--stdout]
 """
 
 import os
@@ -20,11 +24,13 @@ STATE_FILE = ".agent_session.json"
 GREEN  = "\033[92m"
 YELLOW = "\033[93m"
 BLUE   = "\033[94m"
+CYAN   = "\033[96m"
 RED    = "\033[91m"
 BOLD   = "\033[1m"
 RESET  = "\033[0m"
 
-VALID_COMMANDS = {"save", "load", "show", "clear"}
+VALID_COMMANDS = {"save", "load", "show", "clear", "status", "tag", "list", "export"}
+LIST_PAGE_SIZE = 10
 
 
 def load_state() -> dict:
@@ -49,6 +55,7 @@ def cmd_save(note: str) -> None:
         "timestamp": datetime.now().isoformat(),
         "note": note,
         "session": len(state.get("history", [])) + 1,
+        "tags": [],
     }
     state.setdefault("history", []).append(entry)
     state["current"] = entry
@@ -64,10 +71,12 @@ def cmd_load() -> None:
     if not current:
         print(f"{YELLOW}No active session — use 'save' first.{RESET}")
         return
+    tags_str = (", ".join(current.get("tags", []))) or "none"
     print(f"{BOLD}Current session:{RESET}")
     print(f"  Session: #{current['session']}")
     print(f"  Time:    {current['timestamp']}")
     print(f"  Note:    {current['note']}")
+    print(f"  Tags:    {tags_str}")
 
 
 def cmd_show() -> None:
@@ -78,7 +87,9 @@ def cmd_show() -> None:
         return
     print(f"{BOLD}Session History ({len(history)} total):{RESET}")
     for entry in reversed(history[-10:]):
-        print(f"\n  {BLUE}#{entry['session']}{RESET} — {entry['timestamp'][:16]}")
+        tags_str = (", ".join(entry.get("tags", []))) or ""
+        tags_display = f"  [{tags_str}]" if tags_str else ""
+        print(f"\n  {BLUE}#{entry['session']}{RESET} — {entry['timestamp'][:16]}{tags_display}")
         print(f"  {entry['note']}")
 
 
@@ -91,9 +102,128 @@ def cmd_clear() -> None:
         print(f"{YELLOW}No session file found — nothing to clear.{RESET}")
 
 
+def cmd_status() -> None:
+    """Print a compact status summary of the last 3 sessions."""
+    state = load_state()
+    history = state.get("history", [])
+    current = state.get("current")
+
+    if not history:
+        print(f"{YELLOW}No session history — use 'save' to start tracking.{RESET}")
+        return
+
+    total = len(history)
+    recent = history[-3:]
+
+    print(f"\n{BOLD}{CYAN}━━━ Session Status ━━━━━━━━━━━━━━━━━━━━━━━━{RESET}")
+    print(f"  Total sessions: {total}")
+    if current:
+        print(f"  Active:         #{current['session']} — {current['note'][:60]}")
+    print(f"\n{BOLD}  Last 3 sessions:{RESET}")
+    for entry in reversed(recent):
+        tags_str = (", ".join(entry.get("tags", []))) or ""
+        tags_display = f"  [{tags_str}]" if tags_str else ""
+        ts = entry["timestamp"][:16]
+        print(f"    {BLUE}#{entry['session']}{RESET} {ts}{tags_display}")
+        print(f"    {entry['note'][:70]}")
+    print(f"{CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━{RESET}\n")
+
+
+def cmd_tag(label: str) -> None:
+    """Add a tag label to the current session entry."""
+    if not label:
+        print(f"{RED}Error: provide a tag label. Example: session_manager.py tag v2-feature{RESET}")
+        sys.exit(1)
+
+    state = load_state()
+    current = state.get("current")
+    if not current:
+        print(f"{YELLOW}No active session — use 'save' first before tagging.{RESET}")
+        sys.exit(1)
+
+    # Tag must be applied to the same entry in history
+    current.setdefault("tags", [])
+    if label in current["tags"]:
+        print(f"{YELLOW}Tag '{label}' already exists on session #{current['session']}.{RESET}")
+        return
+
+    current["tags"].append(label)
+    state["current"] = current
+
+    # Also update the matching entry in history
+    for entry in state.get("history", []):
+        if entry.get("session") == current["session"]:
+            entry.setdefault("tags", [])
+            if label not in entry["tags"]:
+                entry["tags"].append(label)
+            break
+
+    save_state(state)
+    print(f"{GREEN}✅ Tagged session #{current['session']} with '{label}'.{RESET}")
+
+
+def cmd_list(show_all: bool = False) -> None:
+    """Paginated list of all session history."""
+    state = load_state()
+    history = state.get("history", [])
+    if not history:
+        print(f"{YELLOW}No session history.{RESET}")
+        return
+
+    total = len(history)
+    page_size = len(history) if show_all else LIST_PAGE_SIZE
+    recent = list(reversed(history))[:page_size]
+
+    print(f"\n{BOLD}{CYAN}━━━ Session List ({total} total, showing {len(recent)}) ━━━━━━━{RESET}")
+    for entry in recent:
+        tags_str = (", ".join(entry.get("tags", []))) or ""
+        tags_display = f"  [{YELLOW}{tags_str}{RESET}]" if tags_str else ""
+        ts = entry["timestamp"][:16]
+        print(f"\n  {BOLD}{BLUE}#{entry['session']}{RESET} — {ts}{tags_display}")
+        print(f"  {entry['note']}")
+
+    if not show_all and total > page_size:
+        remaining = total - page_size
+        print(f"\n  {YELLOW}... {remaining} older session(s) not shown. Use 'list --all' to see all.{RESET}")
+
+    print(f"{CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━{RESET}\n")
+
+
+def cmd_export(to_stdout: bool = False) -> None:
+    """Export all session history to a Markdown file or stdout."""
+    state = load_state()
+    history = state.get("history", [])
+    if not history:
+        print(f"{YELLOW}No session history to export.{RESET}")
+        return
+
+    lines = ["# Session Export\n"]
+    lines.append(f"Generated: {datetime.now().isoformat()[:16]}\n")
+    lines.append(f"Total sessions: {len(history)}\n\n---\n")
+
+    for entry in reversed(history):
+        session_num = entry.get("session", "?")
+        ts = entry.get("timestamp", "")[:16]
+        note = entry.get("note", "")
+        tags = entry.get("tags", [])
+        tags_str = f"\n**Tags:** {', '.join(tags)}" if tags else ""
+        lines.append(f"## Session #{session_num} — {ts}\n")
+        lines.append(f"{note}{tags_str}\n\n---\n")
+
+    content = "\n".join(lines)
+
+    if to_stdout:
+        print(content)
+    else:
+        export_path = Path("session_export.md")
+        with open(export_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        print(f"{GREEN}✅ Exported {len(history)} sessions to{RESET} {export_path}")
+
+
 def main() -> None:
     if len(sys.argv) < 2:
-        print(f"Usage: session_manager.py [save <note>|load|show|clear]")
+        print(f"Usage: session_manager.py [save <note>|load|show|clear|status|tag <label>|list [--all]|export [--stdout]]")
         sys.exit(1)
 
     cmd = sys.argv[1].lower()
@@ -114,6 +244,17 @@ def main() -> None:
         cmd_show()
     elif cmd == "clear":
         cmd_clear()
+    elif cmd == "status":
+        cmd_status()
+    elif cmd == "tag":
+        label = " ".join(sys.argv[2:]).strip()
+        cmd_tag(label)
+    elif cmd == "list":
+        show_all = "--all" in sys.argv
+        cmd_list(show_all)
+    elif cmd == "export":
+        to_stdout = "--stdout" in sys.argv
+        cmd_export(to_stdout)
 
 
 if __name__ == "__main__":

package/.agent/scripts/skill_integrator.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+skill_integrator.py — Automated Skill-Script Integration Analyzer
+
+This script scans active skills in `.agent/skills/` and maps them to their 
+corresponding executable scripts in `.agent/scripts/`. It helps the Orchestrator
+and other agents know which skills have automated CLI actions available.
+
+Usage:
+  python .agent/scripts/skill_integrator.py
+  python .agent/scripts/skill_integrator.py --skill <skill-name>
+  python .agent/scripts/skill_integrator.py --report
+  python .agent/scripts/skill_integrator.py --verify
+  python .agent/scripts/skill_integrator.py --report --verify
+"""
+
+import ast
+import argparse
+import os
+import re
+import sys
+from datetime import datetime
+from pathlib import Path
+
+# Colors for terminal output
+CYAN    = "\033[96m"
+GREEN   = "\033[92m"
+YELLOW  = "\033[93m"
+RED     = "\033[91m"
+BOLD    = "\033[1m"
+RESET   = "\033[0m"
+
+REPORT_FILE = "skill-integration-report.md"
+
+
+def find_agent_dir(start_path: Path) -> Path:
+    current = start_path.resolve()
+    while current != current.parent:
+        agent_dir = current / '.agent'
+        if agent_dir.exists() and agent_dir.is_dir():
+            return agent_dir
+        current = current.parent
+    return None
+
+
+def get_associated_script(skill_dir: Path, scripts_dir: Path) -> str:
+    """Check if the skill has an explicit frontmatter script or an implicit script file."""
+    skill_name = skill_dir.name
+
+    # 1. Implicit check: does a script with the same name exist?
+    implicit_script = scripts_dir / f"{skill_name}.py"
+    if implicit_script.exists():
+        return f".agent/scripts/{skill_name}.py"
+
+    # 2. Explicit check: does the SKILL.md define 'script:' in its frontmatter?
+    skill_md = skill_dir / "SKILL.md"
+    if skill_md.exists():
+        try:
+            with open(skill_md, "r", encoding="utf-8") as f:
+                content = f.read()
+                match = re.search(r"---(.*?)---", content, re.DOTALL)
+                if match:
+                    frontmatter = match.group(1)
+                    script_match = re.search(r"(?:^|\n)script:\s*([^\n]+)", frontmatter)
+                    if script_match:
+                        return script_match.group(1).strip()
+        except Exception:
+            pass
+
+    return None
+
+
+def scan_all_skills(agent_dir: Path) -> dict:
+    skills_dir = agent_dir / "skills"
+    scripts_dir = agent_dir / "scripts"
+
+    if not skills_dir.exists() or not scripts_dir.exists():
+        print(f"{YELLOW}Warning: '.agent/skills' or '.agent/scripts' directory not found.{RESET}")
+        return {}
+
+    integrated_skills = {}
+
+    for item in sorted(skills_dir.iterdir()):
+        if item.is_dir():
+            script_path = get_associated_script(item, scripts_dir)
+            if script_path:
+                integrated_skills[item.name] = script_path
+
+    return integrated_skills
+
+
+def verify_script(script_path_str: str, workspace_root: Path) -> tuple[bool, str]:
+    """
+    Verify a mapped script exists on disk and has valid Python syntax.
+    Returns (is_valid: bool, message: str).
+    """
+    # Resolve relative path from workspace root
+    script_path = workspace_root / script_path_str
+
+    if not script_path.exists():
+        return False, f"File not found: {script_path}"
+
+    try:
+        source = script_path.read_text(encoding="utf-8")
+        ast.parse(source)
+        return True, "Syntax OK"
+    except SyntaxError as e:
+        return False, f"Syntax error at line {e.lineno}: {e.msg}"
+    except Exception as e:
+        return False, f"Parse error: {e}"
+
+
+def check_skill(skill_name: str, agent_dir: Path) -> None:
+    skill_dir = agent_dir / "skills" / skill_name
+    scripts_dir = agent_dir / "scripts"
+
+    if not skill_dir.exists():
+        print(f"{YELLOW}Skill '{skill_name}' not found in .agent/skills/{RESET}")
+        return
+
+    script_path = get_associated_script(skill_dir, scripts_dir)
+    if script_path:
+        print(f"{GREEN}✓ Associated script found:{RESET} {script_path}")
+        print(f"\nTo execute:\n  python {script_path}")
+    else:
+        print(f"No executable script mapped for '{skill_name}'.")
+
+
+def cmd_report(integrated_skills: dict, workspace_root: Path) -> None:
+    """Write a Markdown integration report to REPORT_FILE."""
+    lines = [
+        "# Skill-Script Integration Report\n",
+        f"Generated: {datetime.now().isoformat()[:16]}\n",
+        f"Integrated skills: {len(integrated_skills)}\n",
+        "\n---\n",
+        "\n| Skill | Script | Exists |\n",
+        "|---|---|---|\n",
+    ]
+
+    for skill, script in sorted(integrated_skills.items()):
+        script_path = workspace_root / script
+        exists = "✅" if script_path.exists() else "❌ Missing"
+        lines.append(f"| `{skill}` | `{script}` | {exists} |\n")
+
+    lines.append("\n---\n")
+    lines.append(f"\n_Run `python .agent/scripts/skill_integrator.py --verify` to validate syntax of all mapped scripts._\n")
+
+    content = "".join(lines)
+    report_path = workspace_root / REPORT_FILE
+    with open(report_path, "w", encoding="utf-8") as f:
+        f.write(content)
+
+    print(f"{GREEN}✅ Report written to:{RESET} {report_path}")
+
+
+def cmd_verify(integrated_skills: dict, workspace_root: Path) -> bool:
+    """
+    Validate each mapped script: check existence and Python syntax.
+    Returns True if all pass, False if any fail.
+    """
+    if not integrated_skills:
+        print(f"{YELLOW}No integrated scripts found to verify.{RESET}")
+        return True
+
+    print(f"\n{BOLD}{CYAN}━━━ Skill-Script Verification ({len(integrated_skills)} scripts) ━━━{RESET}\n")
+
+    all_passed = True
+    for skill, script in sorted(integrated_skills.items()):
+        ok, msg = verify_script(script, workspace_root)
+        if ok:
+            print(f"  {GREEN}✅ PASS{RESET}  {BOLD}{skill}{RESET} → {script}")
+        else:
+            print(f"  {RED}❌ FAIL{RESET}  {BOLD}{skill}{RESET} → {script}")
+            print(f"         {RED}{msg}{RESET}")
+            all_passed = False
+
+    print(f"\n{CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━{RESET}")
+    if all_passed:
+        print(f"{GREEN}All {len(integrated_skills)} mapped scripts passed verification.{RESET}\n")
+    else:
+        failed = sum(1 for s, p in integrated_skills.items() if not verify_script(p, workspace_root)[0])
+        print(f"{RED}{failed} script(s) failed verification. Fix before deploying.{RESET}\n")
+
+    return all_passed
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Skill-Script Integrator")
+    parser.add_argument("--skill",     type=str, help="Validate a specific skill by name")
+    parser.add_argument("--workspace", type=str, default=".", help="Workspace root directory")
+    parser.add_argument("--report",    action="store_true",
+                        help=f"Generate a Markdown integration report ({REPORT_FILE})")
+    parser.add_argument("--verify",    action="store_true",
+                        help="Validate syntax of all mapped scripts (exits 1 on any failure)")
+
+    args = parser.parse_args()
+    workspace_root = Path(args.workspace).resolve()
+
+    agent_dir = find_agent_dir(workspace_root)
+    if not agent_dir:
+        print(f"{YELLOW}Error: Could not find .agent directory starting from {workspace_root}{RESET}")
+        sys.exit(1)
+
+    if args.skill:
+        check_skill(args.skill, agent_dir)
+        return
+
+    integrated_skills = scan_all_skills(agent_dir)
+
+    # --report: always runs first (independent of --verify)
+    if args.report:
+        cmd_report(integrated_skills, workspace_root)
+
+    # --verify: validate all mapped scripts
+    if args.verify:
+        passed = cmd_verify(integrated_skills, workspace_root)
+        if not passed:
+            sys.exit(1)
+        return
+
+    # Default: print to terminal (original behaviour)
+    if not args.report and not args.verify:
+        if not integrated_skills:
+            print("No integrated scripts found for any active skills.")
+        else:
+            print(f"\n{BOLD}{CYAN}--- Skill-Script Integrations ({len(integrated_skills)}) ---{RESET}\n")
+            for skill, script in sorted(integrated_skills.items()):
+                print(f" {BOLD}{skill}{RESET}")
+                print(f"   ↳ {GREEN}{script}{RESET}\n")
+            print(f"{CYAN}To run a skill script, use: python <path>{RESET}\n")
+
+
+if __name__ == "__main__":
+    main()

package/.agent/scripts/strengthen_skills.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+strengthen_skills.py — Appends Tribunal guardrails to SKILL.md files missing them.
+
+Adds the following sections if not already present:
+  - ## 🤖 LLM-Specific Traps
+  - ## 🏛️ Tribunal Integration (Anti-Hallucination)
+    - ❌ Forbidden AI Tropes
+    - ✅ Pre-Flight Self-Audit
+    - 🛑 Verification-Before-Completion (VBC) Protocol
+
+Usage:
+  python .agent/scripts/strengthen_skills.py .
+  python .agent/scripts/strengthen_skills.py . --dry-run
+  python .agent/scripts/strengthen_skills.py . --skill python-pro
+  python .agent/scripts/strengthen_skills.py . --path /custom/skills/dir
+"""
+
+import os
+import sys
+import argparse
+from pathlib import Path
+
+RED    = "\033[91m"
+GREEN  = "\033[92m"
+YELLOW = "\033[93m"
+BLUE   = "\033[94m"
+BOLD   = "\033[1m"
+RESET  = "\033[0m"
+
+# ─── Rich guardrails block ────────────────────────────────────────────────────
+# This is the canonical template appended to skills missing Tribunal sections.
+
+GUARDRAILS_BLOCK = """
+
+---
+
+## 🤖 LLM-Specific Traps
+
+AI coding assistants often fall into specific bad habits when dealing with this domain. These are strictly forbidden:
+
+1. **Over-engineering:** Proposing complex abstractions or distributed systems when a simpler approach suffices.
+2. **Hallucinated Libraries/Methods:** Using non-existent methods or packages. Always `// VERIFY` or check `package.json` / `requirements.txt`.
+3. **Skipping Edge Cases:** Writing the "happy path" and ignoring error handling, timeouts, or data validation.
+4. **Context Amnesia:** Forgetting the user's constraints and offering generic advice instead of tailored solutions.
+5. **Silent Degradation:** Catching and suppressing errors without logging or re-raising.
+
+---
+
+## 🏛️ Tribunal Integration (Anti-Hallucination)
+
+**Slash command: `/review` or `/tribunal-full`**
+**Active reviewers: `logic-reviewer` · `security-auditor`**
+
+### ❌ Forbidden AI Tropes
+
+1. **Blind Assumptions:** Never make an assumption without documenting it clearly with `// VERIFY: [reason]`.
+2. **Silent Degradation:** Catching and suppressing errors without logging or handling.
+3. **Context Amnesia:** Forgetting the user's constraints and offering generic advice instead of tailored solutions.
+
+### ✅ Pre-Flight Self-Audit
+
+Review these questions before confirming output:
+```
+✅ Did I rely ONLY on real, verified tools and methods?
+✅ Is this solution appropriately scoped to the user's constraints?
+✅ Did I handle potential failure modes and edge cases?
+✅ Have I avoided generic boilerplate that doesn't add value?
+```
+
+### 🛑 Verification-Before-Completion (VBC) Protocol
+
+**CRITICAL:** You must follow a strict "evidence-based closeout" state machine.
+- ❌ **Forbidden:** Declaring a task complete because the output "looks correct."
+- ✅ **Required:** You are explicitly forbidden from finalizing any task without providing **concrete evidence** (terminal output, passing tests, compile success, or equivalent proof) that your output works as intended.
+"""
+
+# ─── Detection ───────────────────────────────────────────────────────────────
+
+TRIBUNAL_MARKERS = [
+    "Tribunal Integration",
+    "Tribunal Integration (Anti-Hallucination)",
+]
+
+VBC_MARKERS = [
+    "Verification-Before-Completion",
+    "VBC Protocol",
+]
+
+
+def has_tribunal_block(content: str) -> bool:
+    return any(marker in content for marker in TRIBUNAL_MARKERS)
+
+
+def has_vbc_block(content: str) -> bool:
+    return any(marker in content for marker in VBC_MARKERS)
+
+
+# ─── Output helpers ───────────────────────────────────────────────────────────
+
+def header(title: str) -> None:
+    print(f"\n{BOLD}{BLUE}━━━ {title} ━━━{RESET}")
+
+
+def ok(msg: str) -> None:
+    print(f"  {GREEN}✅ {msg}{RESET}")
+
+
+def skip(msg: str) -> None:
+    print(f"  {YELLOW}⏭️  {msg}{RESET}")
+
+
+def warn(msg: str) -> None:
+    print(f"  {YELLOW}⚠️  {msg}{RESET}")
+
+
+def fail(msg: str) -> None:
+    print(f"  {RED}❌ {msg}{RESET}")
+
+
+# ─── Core ────────────────────────────────────────────────────────────────────
+
+def process_skill(skill_md: Path, dry_run: bool) -> str:
+    """Process a single SKILL.md. Returns 'updated', 'skipped', or 'error'."""
+    skill_name = skill_md.parent.name
+    try:
+        content = skill_md.read_text(encoding="utf-8")
+
+        has_tribunal = has_tribunal_block(content)
+        has_vbc = has_vbc_block(content)
+
+        if has_tribunal and has_vbc:
+            skip(f"{skill_name} — already has Tribunal + VBC blocks")
+            return "skipped"
+
+        missing = []
+        if not has_tribunal:
+            missing.append("Tribunal Integration")
+        if not has_vbc:
+            missing.append("VBC Protocol")
+
+        if dry_run:
+            warn(f"[DRY RUN] {skill_name} — would add: {', '.join(missing)}")
+            return "updated"
+
+        with skill_md.open("a", encoding="utf-8") as f:
+            f.write(GUARDRAILS_BLOCK)
+
+        ok(f"{skill_name} — strengthened ({', '.join(missing)} added)")
+        return "updated"
+
+    except Exception as e:
+        fail(f"{skill_name} — {e}")
+        return "error"
+
+
+# ─── Main ────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Appends Tribunal guardrails (LLM Traps + Pre-Flight + VBC) to skills missing them"
+    )
+    parser.add_argument(
+        "path",
+        nargs="?",
+        default=".",
+        help="Project root directory (default: current directory)"
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Show changes without writing")
+    parser.add_argument("--skill", help="Only strengthen a specific skill by name")
+    parser.add_argument(
+        "--skills-path",
+        help="Override the skills directory path (default: <path>/.agent/skills)"
+    )
+    args = parser.parse_args()
+
+    project_root = Path(args.path).resolve()
+    skills_dir = (
+        Path(args.skills_path).resolve()
+        if args.skills_path
+        else project_root / ".agent" / "skills"
+    )
+
+    if not skills_dir.is_dir():
+        fail(f"Skills directory not found: {skills_dir}")
+        sys.exit(1)
+
+    print(f"{BOLD}Tribunal — strengthen_skills.py{RESET}")
+    if args.dry_run:
+        print(f"  {YELLOW}DRY RUN — no files will be written{RESET}")
+    print(f"Skills dir: {skills_dir}\n")
+
+    counts: dict[str, int] = {"updated": 0, "skipped": 0, "error": 0}
+
+    header("Strengthening Skills")
+    for skill_dir in sorted(skills_dir.iterdir()):
+        if not skill_dir.is_dir():
+            continue
+        if args.skill and skill_dir.name != args.skill:
+            continue
+        skill_md = skill_dir / "SKILL.md"
+        if not skill_md.exists():
+            warn(f"{skill_dir.name} — no SKILL.md found")
+            continue
+        result = process_skill(skill_md, args.dry_run)
+        counts[result] += 1
+
+    print(f"\n{BOLD}━━━ Summary ━━━{RESET}")
+    print(f"  {GREEN}✅ Strengthened: {counts['updated']}{RESET}")
+    print(f"  {YELLOW}⏭️  Skipped:      {counts['skipped']}{RESET}")
+    if counts["error"]:
+        print(f"  {RED}❌ Errors:       {counts['error']}{RESET}")
+    if args.dry_run:
+        print(f"  {YELLOW}(dry-run — nothing written){RESET}")
+
+    sys.exit(1 if counts["error"] > 0 else 0)
+
+
+if __name__ == "__main__":
+    main()