tribunal-kit 2.4.2 → 2.4.4

package/.agent/patterns/generator.md

@@ -0,0 +1,9 @@
+# Generator Pattern
+
+**Purpose**: Produce structured output by filling a reusable template governed by quality rules.
+
+## Protocol
+When a skill inherits this pattern, the agent is tasked with producing a specific formatted artifact (like a configuration file, documentation page, or scaffolding code).
+1. **Template Retrieval**: Locate and strictly adhere to the provided template structure (the "assets") defined by the specific skill.
+2. **Constraint Application**: Apply all quality rules and constraints (the "references") required by the skill while fleshing out the template.
+3. **No Halucination Formatting**: Do not invent new sections, alter the required Markdown/JSON structure, or add unauthorized commentary unless it fits directly into the predefined template slots.

package/.agent/patterns/inversion.md

@@ -0,0 +1,12 @@
+# Inversion Pattern
+
+**Purpose**: Interview the user before taking action.
+
+## Protocol
+When a skill inherits this pattern, you MUST NOT proceed with execution immediately. Instead, rely on the "Socratic Gate". You must pause and ask the user questions using the following structured phases:
+1. **Identify Missing Context**: Evaluate the user's prompt against what is absolutely necessary to execute the skill.
+2. **Phase 1 (Goal & Constraints)**: Ask the user about the real outcome and any hard constraints.
+3. **Phase 2 (Out of Scope)**: Confirm what should explicitly NOT be done.
+4. **Phase 3 (Done Condition)**: Verify how you will know the task is completed.
+
+You must receive explicit answers or a "do your best" override before writing code or executing substantive actions.

package/.agent/patterns/pipeline.md

@@ -0,0 +1,9 @@
+# Pipeline Pattern
+
+**Purpose**: Link multiple execution steps together with explicit validation gates between them.
+
+## Protocol
+When a skill inherits this pattern, the agent must execute its instructions sequentially and rigidly.
+1. **Step-by-Step Execution**: You must not skip steps or combine multiple distinct phases into a single massive generative output.
+2. **Validation Gates**: After completing Step N, you must validate that the output of Step N meets its success criteria before moving to Step N+1.
+3. **Halting**: If any gate fails validation, you must HALT the pipeline and either initiate an Error Recovery Protocol or report the failure to the user. Do not proceed with subsequent steps with broken inputs.

package/.agent/patterns/reviewer.md

@@ -0,0 +1,13 @@
+# Reviewer Pattern
+
+**Purpose**: Evaluate code or content against a strict external checklist.
+
+## Protocol
+When a skill inherits this pattern, the agent assumes the role of an evaluator. Do NOT generate novel content or fix the problem automatically unless explicitly instructed.
+1. **Checklist Enforcement**: You must read the evaluation checklist provided in the specific skill.
+2. **Review Output**: For every item in the checklist, determine if it passes or fails.
+3. **Severity Grading**: Group all findings by severity:
+   - **Critical**: Must fix before proceeding (e.g. security violations, build errors)
+   - **Warning**: Should fix (e.g. best practice violations, performance risks)
+   - **Info**: Stylistic or minor suggestions
+4. **Separation of Concerns**: Only evaluate the "what" (the checklist) based on the "how" (this standard format). Do not blur your own opinions into the checklist constraints.

package/.agent/patterns/tool-wrapper.md

@@ -0,0 +1,9 @@
+# Tool Wrapper Pattern
+
+**Purpose**: Package an external library's or CLI tool's conventions as on-demand, executable knowledge.
+
+## Protocol
+When a skill inherits this pattern, the agent MUST NOT guess how to use the target tool. You are acting strictly as a wrapper for this specific utility.
+1. **Consult References**: Read the provided documentation, usage examples, or reference notes in the skill definitions BEFORE issuing any commands.
+2. **Strict Adherence**: Follow the rules defined in the skill exactly as written. Do not improvise flags, parameters, or endpoints that are not explicitly authorized by the reference.
+3. **Command Execution**: If the tool is a CLI command or Python script (e.g. `test_runner.py`), construct the command accurately based solely on the referenced conventions, execute it, and report the direct output.

package/.agent/scripts/patch_skills_meta.py

@@ -1,177 +1,177 @@
-#!/usr/bin/env python3
-"""
-patch_skills_meta.py — Injects version/freshness metadata into SKILL.md frontmatter.
-
-Adds the following fields to YAML frontmatter if missing:
-  version: 1.0.0
-  last-updated: 2026-03-12
-  applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
-
-Usage:
-  python .agent/scripts/patch_skills_meta.py .
-  python .agent/scripts/patch_skills_meta.py . --dry-run
-  python .agent/scripts/patch_skills_meta.py . --skill python-pro
-"""
-
-import os
-import sys
-import argparse
-import re
-from pathlib import Path
-
-RED    = "\033[91m"
-GREEN  = "\033[92m"
-YELLOW = "\033[93m"
-BLUE   = "\033[94m"
-BOLD   = "\033[1m"
-RESET  = "\033[0m"
-
-META_FIELDS = {
-    "version":           "1.0.0",
-    "last-updated":      "2026-03-12",
-    "applies-to-model":  "gemini-2.5-pro, claude-3-7-sonnet",
-}
-
-
-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}")
-
-
-def patch_frontmatter(content: str) -> tuple[str, list[str]]:
-    """
-    Parse the YAML frontmatter block and inject missing meta fields.
-    Returns (patched_content, list_of_added_fields).
-    If no frontmatter is found, injects a minimal one.
-    """
-    added: list[str] = []
-
-    # Match frontmatter block: starts and ends with ---
-    fm_pattern = re.compile(r"^---\r?\n(.*?)\r?\n---", re.DOTALL)
-    match = fm_pattern.match(content)
-
-    if not match:
-        # No frontmatter — prepend a minimal block
-        new_fm_lines = ["---"]
-        for key, value in META_FIELDS.items():
-            new_fm_lines.append(f"{key}: {value}")
-            added.append(key)
-        new_fm_lines.append("---")
-        new_fm = "\n".join(new_fm_lines)
-        return new_fm + "\n\n" + content, added
-
-    fm_text = match.group(1)
-    fm_end = match.end()
-
-    # Parse existing lines preserving order
-    existing_keys = set()
-    for line in fm_text.splitlines():
-        m = re.match(r"^([a-zA-Z0-9_-]+)\s*:", line)
-        if m:
-            existing_keys.add(m.group(1))
-
-    # Build new frontmatter
-    new_fm_lines = fm_text.rstrip().splitlines()
-    for key, value in META_FIELDS.items():
-        if key not in existing_keys:
-            new_fm_lines.append(f"{key}: {value}")
-            added.append(key)
-
-    if not added:
-        return content, []
-
-    new_fm_block = "---\n" + "\n".join(new_fm_lines) + "\n---"
-    patched = new_fm_block + content[fm_end:]
-    return patched, added
-
-
-def process_skill(skill_path: Path, dry_run: bool) -> str:
-    """Process a single SKILL.md. Returns 'updated', 'skipped', or 'error'."""
-    try:
-        content = skill_path.read_text(encoding="utf-8")
-        patched, added = patch_frontmatter(content)
-
-        skill_name = skill_path.parent.name
-
-        if not added:
-            skip(f"{skill_name} — all meta fields present")
-            return "skipped"
-
-        field_list = ", ".join(added)
-        if dry_run:
-            warn(f"[DRY RUN] {skill_name} — would add: {field_list}")
-            return "updated"
-
-        skill_path.write_text(patched, encoding="utf-8")
-        ok(f"{skill_name} — added: {field_list}")
-        return "updated"
-
-    except Exception as e:
-        fail(f"{skill_path.parent.name} — {e}")
-        return "error"
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Injects version/freshness metadata into SKILL.md frontmatter"
-    )
-    parser.add_argument("path", help="Project root directory")
-    parser.add_argument("--dry-run", action="store_true", help="Show changes without writing")
-    parser.add_argument("--skill", help="Only patch a specific skill by name")
-    args = parser.parse_args()
-
-    project_root = Path(args.path).resolve()
-    skills_dir = 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 — patch_skills_meta.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 = {"updated": 0, "skipped": 0, "error": 0}
-
-    header("Patching Frontmatter")
-    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}✅ Updated:  {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()
+#!/usr/bin/env python3
+"""
+patch_skills_meta.py — Injects version/freshness metadata into SKILL.md frontmatter.
+
+Adds the following fields to YAML frontmatter if missing:
+  version: 1.0.0
+  last-updated: 2026-03-12
+  applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
+
+Usage:
+  python .agent/scripts/patch_skills_meta.py .
+  python .agent/scripts/patch_skills_meta.py . --dry-run
+  python .agent/scripts/patch_skills_meta.py . --skill python-pro
+"""
+
+import os
+import sys
+import argparse
+import re
+from pathlib import Path
+
+RED    = "\033[91m"
+GREEN  = "\033[92m"
+YELLOW = "\033[93m"
+BLUE   = "\033[94m"
+BOLD   = "\033[1m"
+RESET  = "\033[0m"
+
+META_FIELDS = {
+    "version":           "1.0.0",
+    "last-updated":      "2026-03-12",
+    "applies-to-model":  "gemini-2.5-pro, claude-3-7-sonnet",
+}
+
+
+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}")
+
+
+def patch_frontmatter(content: str) -> tuple[str, list[str]]:
+    """
+    Parse the YAML frontmatter block and inject missing meta fields.
+    Returns (patched_content, list_of_added_fields).
+    If no frontmatter is found, injects a minimal one.
+    """
+    added: list[str] = []
+
+    # Match frontmatter block: starts and ends with ---
+    fm_pattern = re.compile(r"^---\r?\n(.*?)\r?\n---", re.DOTALL)
+    match = fm_pattern.match(content)
+
+    if not match:
+        # No frontmatter — prepend a minimal block
+        new_fm_lines = ["---"]
+        for key, value in META_FIELDS.items():
+            new_fm_lines.append(f"{key}: {value}")
+            added.append(key)
+        new_fm_lines.append("---")
+        new_fm = "\n".join(new_fm_lines)
+        return new_fm + "\n\n" + content, added
+
+    fm_text = match.group(1)
+    fm_end = match.end()
+
+    # Parse existing lines preserving order
+    existing_keys = set()
+    for line in fm_text.splitlines():
+        m = re.match(r"^([a-zA-Z0-9_-]+)\s*:", line)
+        if m:
+            existing_keys.add(m.group(1))
+
+    # Build new frontmatter
+    new_fm_lines = fm_text.rstrip().splitlines()
+    for key, value in META_FIELDS.items():
+        if key not in existing_keys:
+            new_fm_lines.append(f"{key}: {value}")
+            added.append(key)
+
+    if not added:
+        return content, []
+
+    new_fm_block = "---\n" + "\n".join(new_fm_lines) + "\n---"
+    patched = new_fm_block + content[fm_end:]
+    return patched, added
+
+
+def process_skill(skill_path: Path, dry_run: bool) -> str:
+    """Process a single SKILL.md. Returns 'updated', 'skipped', or 'error'."""
+    try:
+        content = skill_path.read_text(encoding="utf-8")
+        patched, added = patch_frontmatter(content)
+
+        skill_name = skill_path.parent.name
+
+        if not added:
+            skip(f"{skill_name} — all meta fields present")
+            return "skipped"
+
+        field_list = ", ".join(added)
+        if dry_run:
+            warn(f"[DRY RUN] {skill_name} — would add: {field_list}")
+            return "updated"
+
+        skill_path.write_text(patched, encoding="utf-8")
+        ok(f"{skill_name} — added: {field_list}")
+        return "updated"
+
+    except Exception as e:
+        fail(f"{skill_path.parent.name} — {e}")
+        return "error"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Injects version/freshness metadata into SKILL.md frontmatter"
+    )
+    parser.add_argument("path", help="Project root directory")
+    parser.add_argument("--dry-run", action="store_true", help="Show changes without writing")
+    parser.add_argument("--skill", help="Only patch a specific skill by name")
+    args = parser.parse_args()
+
+    project_root = Path(args.path).resolve()
+    skills_dir = 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 — patch_skills_meta.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 = {"updated": 0, "skipped": 0, "error": 0}
+
+    header("Patching Frontmatter")
+    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}✅ Updated:  {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()