tribunal-kit 3.0.0 → 3.1.0

package/.agent/scripts/deep_compress.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+deep_compress.py - Deep surgical compression for .agent/ markdown files (skills, agents, workflows).
+Targets: repetitive boilerplate, verbose code comments, redundant example sections.
+Safe: never removes H1/H2 headers, never removes HALLUCINATION TRAP lines, never removes code blocks entirely.
+"""
+
+import os, re, sys
+
+BASE_DIRS = ['.agent/skills', '.agent/agents', '.agent/workflows']
+
+# ─── SECTION REMOVAL ─────────────────────────────────────────────────────────
+# These are globally covered by GEMINI.md — strip from all files
+
+REMOVE_SECTIONS = [
+    r'(?ms)^## 🏛️ Tribunal Integration.*?(?=^## |\Z)',
+    r'(?ms)^## Tribunal Integration.*?(?=^## |\Z)',
+    r'(?ms)^### ✅ Pre-Flight Self-Audit.*?(?=^### |^## |\Z)',
+    r'(?ms)^## Pre-Flight Self-Audit.*?(?=^## |\Z)',
+    r'(?ms)^## Cross-Workflow Navigation.*?(?=^## |\Z)',
+    r'(?ms)^## LLM Traps.*?(?=^## |\Z)',
+    r'(?ms)^## VBC Protocol.*?(?=^## |\Z)',
+    r'(?ms)^## Output Format\n```[\s\S]*?```\n',
+    r'(?ms)^## 🤖 LLM-Specific Traps.*?(?=^## |\Z)',    # covered in GEMINI.md
+]
+
+# ─── VERBOSE COMMENT REMOVAL IN CODE BLOCKS ──────────────────────────────────
+# Removes lines that just restate the concept being shown — pure padding
+
+VERBOSE_COMMENT_PATTERNS = [
+    # e.g. "// Any HTML or SVG element can be prefixed with `motion.`"
+    r"(?m)^(\s*)//\s*(?:Any HTML or SVG element|motion\.div, motion\.span|The MAGIC of|This is the key performance|The pattern that|Compound components share|Note that children|The action receives|Children inherit the|Import first|Parent controls when|It's always motion)\b[^\n]*\n",
+    # e.g. "# TypedDict gives you autocomplete..."
+    r"(?m)^(\s*)#\s*(?:TypedDict gives you|Usage:|Note:|Return user|Return None|Automatically)\b[^\n]*\n",
+    # Obvious standalone "// Usage:" label inside code blocks
+    r"(?m)^\s*//\s*Usage:\s*\n(?=\s*[<{])",
+    r"(?m)^\s*#\s*Usage:\s*\n(?=\s*[{])",
+    # "// When server responds..." style obvious follow-on comment
+    r"(?m)^\s*//\s*When (?:server responds|a component|React can interrupt|the React Compiler)[^\n]*\n",
+]
+
+# ─── CHATTY SENTENCE REMOVAL BEFORE FIRST CODE BLOCK ─────────────────────────
+# Removes motivational opener sentences: "X is a paradigm shift. If you..."
+
+def strip_chatty_openers(content):
+    """Remove 2-3 sentence filler paragraphs between H1 and first ---"""
+    return re.sub(
+        r'(^# .+\n)\n.{60,}\n.{30,}\n(?:\n---)',
+        r'\1\n---',
+        content,
+        flags=re.MULTILINE
+    )
+
+# ─── COLLAPSE NESTED IDENTICAL EXAMPLES ──────────────────────────────────────
+# Many files have "// Legacy" vs "// Modern" comments — compress to 1 block
+
+def compress_legacy_modern_blocks(content):
+    """Convert // LEGACY + // MODERN dual examples into compact diff-style"""
+    # Pattern: code block with ❌ LEGACY followed immediately by ✅ MODERN
+    pattern = re.compile(
+        r'```(\w+)\n((?:.*\n)*?.*// ❌ LEGACY[^\n]*\n(?:.*\n)*?)```\n\n```\w+\n((?:.*\n)*?.*// ✅ MODERN[^\n]*\n(?:.*\n)*?)```',
+        re.MULTILINE
+    )
+    # Only compress if the whole block is < 30 lines total
+    def compress(m):
+        total_lines = m.group(2).count('\n') + m.group(3).count('\n')
+        if total_lines > 28:
+            return m.group(0)  # too big to safely merge — leave alone
+        lang = m.group(1)
+        legacy = m.group(2).strip()
+        modern = m.group(3).strip()
+        return f'```{lang}\n// ❌ LEGACY\n{legacy}\n\n// ✅ MODERN\n{modern}\n```'
+    return pattern.sub(compress, content)
+
+# ─── STRIP EMPTY COMMENT LINES ───────────────────────────────────────────────
+def strip_empty_comments(content):
+    """Remove lines that are ONLY // or #"""
+    content = re.sub(r'(?m)^\s*//\s*$\n', '', content)
+    content = re.sub(r'(?m)^\s*#\s*$\n', '', content)
+    return content
+
+# ─── TRIM REPEATED RULES (dedup consecutive bullet points in same section) ───
+def dedup_bullet_points(content):
+    """Remove exact duplicate bullet point lines (often copy-pasted across sections)."""
+    lines = content.split('\n')
+    seen_bullets = {}
+    output = []
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped.startswith(('✅', '❌', '- ✅', '- ❌')):
+            if stripped in seen_bullets and i - seen_bullets[stripped] < 80:
+                continue  # skip duplicate within 80 lines
+            seen_bullets[stripped] = i
+        output.append(line)
+    return '\n'.join(output)
+
+# ─── COLLAPSE BLANKS ─────────────────────────────────────────────────────────
+def collapse_blanks(content):
+    return re.sub(r'\n{3,}', '\n\n', content)
+
+# ─── REMOVE REDUNDANT IMPORTS IN COMMENTS ────────────────────────────────────
+# Some files have // import { x } from "y" repeated in every example
+
+def compress_import_repetition(content):
+    """If same import line appears in 3+ separate code blocks, add a note and strip repetitions."""
+    import_line = re.compile(r'import \{[^}]+\} from "[^"]+";')
+    matches = import_line.findall(content)
+    freq = {}
+    for m in matches:
+        freq[m] = freq.get(m, 0) + 1
+    
+    for imp, count in freq.items():
+        if count >= 4:
+            # First occurrence: keep it. Subsequent ones: replace with comment
+            first_done = [False]
+            def replacer(m, imp=imp, first_done=first_done):
+                if m.group(0) == imp:
+                    if not first_done[0]:
+                        first_done[0] = True
+                        return m.group(0)
+                    return f'// {imp}  ← (already imported above)'
+                return m.group(0)
+            content = import_line.sub(replacer, content)
+    return content
+
+# ─── MAIN PIPELINE ──────────────────────────────────────────────────────────
+
+def compress_file(path):
+    with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+        original = f.read()
+    
+    content = original
+    
+    # 1. Strip global boilerplate sections
+    for pattern in REMOVE_SECTIONS:
+        content = re.sub(pattern, '', content)
+    
+    # 2. Strip chatty openers
+    content = strip_chatty_openers(content)
+    
+    # 3. Compress legacy/modern dual blocks
+    content = compress_legacy_modern_blocks(content)
+    
+    # 4. Verbose inline code comment removal
+    for pattern in VERBOSE_COMMENT_PATTERNS:
+        content = re.sub(pattern, '', content)
+    
+    # 5. Strip empty comment lines
+    content = strip_empty_comments(content)
+    
+    # 6. Deduplicate bullet points
+    content = dedup_bullet_points(content)
+    
+    # 7. Collapse 3+ blank lines
+    content = collapse_blanks(content)
+    
+    # Write back only if changed
+    if content.strip() != original.strip():
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(content.strip() + '\n')
+    
+    return len(original), len(content)
+
+def main():
+    total_orig = 0
+    total_new = 0
+    file_results = []
+    
+    for base in BASE_DIRS:
+        if not os.path.exists(base):
+            continue
+        for root, _, files in os.walk(base):
+            for fname in files:
+                if fname.endswith('.md'):
+                    path = os.path.join(root, fname)
+                    orig, new = compress_file(path)
+                    total_orig += orig
+                    total_new += new
+                    saved = orig - new
+                    if saved > 200:
+                        rel = os.path.relpath(path, '.')
+                        file_results.append((saved, rel))
+    
+    file_results.sort(reverse=True)
+    
+    saved_total = total_orig - total_new
+    pct = saved_total / total_orig * 100 if total_orig else 0
+    
+    print(f"\n{'='*58}")
+    print(f"  Deep Compression Complete")
+    print(f"{'='*58}")
+    print(f"  Original : {total_orig:,} bytes ({total_orig//1024}KB)")
+    print(f"  After    : {total_new:,} bytes ({total_new//1024}KB)")
+    print(f"  Saved    : {saved_total:,} bytes ({saved_total//1024}KB) — {pct:.1f}%")
+    print(f"\n  Top savings:")
+    for saved, path in file_results[:20]:
+        skill = '/'.join(path.replace('\\','/').split('/')[-2:])
+        print(f"    -{saved//1024:2}KB  {skill}")
+    print()
+
+if __name__ == '__main__':
+    main()

package/.agent/scripts/minify_context.py

@@ -0,0 +1,80 @@
+import os
+import re
+
+def minify_markdown(file_path):
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    original_len = len(content)
+
+    # 1. Strip repetitive Output Format templates (These are huge and the LLM already knows how to output the Tribunal format from GEMINI.md)
+    content = re.sub(r'## Output Format\n\n```[\s\S]*?```\n', '', content)
+
+    # 2. Convert bloated Cross-Workflow Navigation tables to dense YAML lists
+    # Find tables under Cross-Workflow Navigation
+    def replace_table_with_list(match):
+        table_text = match.group(0)
+        lines = table_text.strip().split('\n')
+        out = []
+        for line in lines:
+            if line.startswith('|') and not line.startswith('|:') and not line.startswith('| After'):
+                parts = [p.strip() for p in line.split('|') if p.strip()]
+                if len(parts) >= 2:
+                    out.append(f"- {parts[0]} -> {parts[1]}")
+        return "\n".join(out) + "\n"
+
+    content = re.sub(r'## Cross-Workflow Navigation\n\n\|.*?\|[\s\S]*?(?=\n## |\Z)', lambda m: '## Cross-Workflow Navigation\n' + replace_table_with_list(m), content)
+
+    # 3. Collapse multiple empty lines into a single one
+    content = re.sub(r'\n{3,}', '\n\n', content)
+
+    # 4. Remove padding from remaining tables to save space tokens
+    def unpad_table(match):
+        line = match.group(0)
+        # remove spaces around |
+        line = re.sub(r'\s+\|\s+', '|', line)
+        line = re.sub(r'\|\s+', '|', line)
+        line = re.sub(r'\s+\|', '|', line)
+        return line
+    content = re.sub(r'^\|.+|$', unpad_table, content, flags=re.MULTILINE)
+
+    # 5. Remove conversational blockquotes > if they don't contain WARNING/NOTE/IMPORTANT
+    def remove_conversational_quotes(match):
+        text = match.group(0)
+        if '⚠️' in text or 'WARNING' in text or 'CRITICAL' in text or '!' in text:
+            return text
+        # Otherwise just return the text without quote
+        return text.replace('> ', '').replace('>', '')
+    content = re.sub(r'^>.*$', remove_conversational_quotes, content, flags=re.MULTILINE)
+
+    # 6. Dense Examples (convert ❌ Bad: and ✅ Good: blocks to single lines)
+    content = content.replace('\n❌ Bad:', ' ❌')
+    content = content.replace('\n✅ Good:', ' ✅')
+
+    with open(file_path, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+    return original_len, len(content)
+
+def main():
+    agent_dir = os.path.join('.agent')
+    total_original = 0
+    total_new = 0
+
+    for root, _, files in os.walk(agent_dir):
+        for file in files:
+            if file.endswith('.md'):
+                file_path = os.path.join(root, file)
+                orig, new = minify_markdown(file_path)
+                total_original += orig
+                total_new += new
+
+    saved = total_original - total_new
+    percent = (saved / total_original * 100) if total_original > 0 else 0
+    print(f"Minification Complete.")
+    print(f"Original size: {total_original} bytes")
+    print(f"New size: {total_new} bytes")
+    print(f"Saved: {saved} bytes ({percent:.1f}%)")
+
+if __name__ == '__main__':
+    main()

package/.agent/scripts/security_scan.py

@@ -32,7 +32,7 @@ BOLD = "\033[1m"
 RESET = "\033[0m"
 
 SOURCE_EXTENSIONS = {".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".java", ".rb"}
-SKIP_DIRS = {"node_modules", ".git", "dist", "build", "__pycache__", ".agent", ".next", "vendor"}
+SKIP_DIRS = {"node_modules", ".git", "dist", "build", "__pycache__", ".agent", ".next", "vendor", "coverage", "lcov-report", ".nyc_output", "test-results", ".jest-cache"}
 
 
 @dataclass

package/.agent/scripts/strip_tribunal.py

@@ -0,0 +1,41 @@
+import os
+import re
+
+def strip_boilerplate(file_path):
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    original_len = len(content)
+
+    # Regex to find everything from "## 🏛️ Tribunal Integration" (or without emojis) to the end of the file or next major H1
+    # Often it appears at the end of agents
+    content = re.sub(r'## 🏛️ Tribunal Integration[\s\S]*?(?=\n# |\Z)', '', content)
+    content = re.sub(r'## Tribunal Integration[\s\S]*?(?=\n# |\Z)', '', content)
+    
+    # Strip Cross-Workflow Navigation since GEMINI.md has global handling
+    content = re.sub(r'## Cross-Workflow Navigation[\s\S]*?(?=\n# |\Z)', '', content)
+
+    # Strip What the Maker Is Not Allowed to Do (it's in GEMINI.md)
+    content = re.sub(r'## What the Maker Is Not Allowed to Do[\s\S]*?(?=\n# |\Z)', '', content)
+
+    with open(file_path, 'w', encoding='utf-8') as f:
+        f.write(content.strip() + '\n')
+
+    return original_len, len(content)
+
+def main():
+    dirs_to_check = ['.agent/agents', '.agent/workflows']
+    total_stripped = 0
+
+    for d in dirs_to_check:
+        if not os.path.exists(d): continue
+        for file in os.listdir(d):
+            if file.endswith('.md'):
+                file_path = os.path.join(d, file)
+                orig, new = strip_boilerplate(file_path)
+                total_stripped += (orig - new)
+
+    print(f"Stripped {total_stripped} bytes of repetitive boilerplate.")
+
+if __name__ == '__main__':
+    main()

package/.agent/skills/agent-organizer/SKILL.md

@@ -1,126 +1,92 @@
----
-name: agent-organizer
-description: Master Agent orchestration framework. Coordination of sub-agents, workflow definitions, delegation patterns, state management across conversations, memory distillation, and execution loops. Use when assembling multi-agent systems or managing complex agent-to-agent architectures.
-allowed-tools: Read, Write, Edit, Glob, Grep
-version: 2.0.0
-last-updated: 2026-04-02
-applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
----
-
-# Agent Organizer — Multi-Agent Orchestration Mastery
-
-> A single monolithic agent degrades as context grows.
-> Multi-agent architectures succeed through strict encapsulation, clear interfaces, and context-budgeting.
-
----
-
-## 1. The Delegation Sub-Agent Pattern
-
-Agents should defer specific domain problems to specialized sub-agents.
-
-```json
-// Define the payload contract the Worker Agent expects
-{
-  "taskId": "task-auth-migration-01",
-  "workerRole": "api-security-auditor",
-  "isolatedContext": {
-    "filesToScan": ["src/login.ts", "src/middleware.ts"],
-    "objective": "Identify unprotected mass assignments"
-  },
-  "requiredOutputFormat": "json_list"
-}
-```
-
-### Delegation Rules:
-1. **Never pass full histories:** Do not pass the entire conversation history to a worker sub-agent. Extract only the exact files and goal context required. (Context Window Budgeting).
-2. **Clear Boundaries:** If the worker is fixing CSS, it must not invent logic for the database.
-3. **Structured Handoff:** The parent agent requests JSON from the worker, parses it, and then acts. Let machines talk to machines through syntax, not prose.
-
----
-
-## 2. Execution Loops (Supervisor Pattern)
-
-A Supervisor decides *who* works and *when*, but does not execute the work.
-
-```
-[User Request: "Add OAuth and secure it"]
-       |
-[Supervisor Agent analyzing required skills...]
-       |
-       ├─> [Dispatches: authentication-best-practices]
-       |         (Worker builds OAuth implementation)
-       |
-       ├─> [Dispatches: api-security-auditor]
-       |         (Worker reviews implementation against OWASP)
-       |
-[Supervisor Agent synthesizes findings]
-       |
-[Action Executed / Git Commit]
-```
-
-### Handoff Signals
-A worker must return definitive state signals when yielding control:
-- `COMPLETE`: Goal achieved. Final diff generated.
-- `BLOCKED`: Missing context (e.g., "I need the `.env` schema").
-- `ERROR`: Script failed, requires manual Supervisor intervention.
-
----
-
-## 3. Session State Management (Memory)
-
-Agents lose memory across boundaries. The Organizer must explicitly persist context.
-
-1. **Short-Term Context:** Maintained natively in the active LLM context window.
-2. **Task State:** Maintained locally in `task.md`. Workers check-in and check-out checkboxes.
-3. **Long-Term Memory:** "Knowledge Items" (KIs). Distilling massive conversations down into a single `learnings.json` file injected on subsequent startups.
-
-```markdown
-<!-- task.md (The Global Execution State) -->
-# Current Objective: Build Chat Feature
-- [x] Initialize websocket connection
-- [/] (Worker: frontend-specialist) Build Chat UI component
-- [ ] (Worker: realtime-patterns) Implement presence sync
-```
-
----
-
-## 4. The Human-in-the-Loop (Socratic Gate)
-
-Automation without oversight is reckless. The Organizer manages when to pause and query the human.
-
-**Mandatory Gates:**
-1. **Approval Gate (Before Execution):** "I have drafted the architecture plan. Do you approve execution?"
-2. **Recovery Gate (After 3 Failures):** "The database migration script has failed 3 times. I am halting. How would you like to proceed?"
-
----
-
-## 🤖 LLM-Specific Traps (Agent Organization)
-
-1. **The Context Dump:** Sending highly-specialized worker agents the entire chat transcript. Workers become confused by the broader goals instead of focusing on their localized task.
-2. **Infinite Loops:** Having two agents argue with each other (e.g., Code Generator vs Linter) infinitely. The Organizer MUST implement a hard limit (e.g., max 3 iterations) before halting and escalating to the human.
-3. **God-Agent Regression:** The Organizer attempting to write the code itself instead of actively routing the request to the designated `python-pro` or `react-specialist`.
-4. **Vague Instructions:** Delegating tasks with "Fix the UI" instead of "Review `src/Header.tsx` and adjust padding to standard 4px increments."
-5. **Loss of Task Tracking:** Delegating multiple tasks in parallel and forgetting to update the central tracking `task.md` file, leading to redundant work or dropped constraints.
-6. **Premature Completion:** The Supervisor telling the user the workflow is finished before the individual worker agents have successfully returned positive exit signals.
-7. **Ignoring Worker Feedback:** A worker agent returns `BLOCKED` due to missing dependencies, and the Supervisor blindly continues executing the next dependent step in the workflow.
-8. **Format Mixing:** Expecting natural language responses from a worker, but feeding it into a CLI script that expects structured JSON parameters.
-9. **No Fallback State:** Dispatching a worker to modify files without snapshotting/branching. If the worker hallucinates, there is no easy rollback.
-10. **Bypassing the Socratic Gate:** Autonomous agents deciding on major architectural pivots without seeking explicit human confirmation first.
-
----
-
-## 🏛️ Tribunal Integration
-
-### ✅ Pre-Flight Self-Audit
-```
-✅ Are instructions sent to worker agents localized, stripped of unnecessary global context?
-✅ Has a strict maximum-iteration limit been defined to prevent infinite agent argument loops?
-✅ Is the global state properly documented and maintained within the `task.md` file?
-✅ Did the Organizer strictly act as a router rather than assuming execution duties?
-✅ Are worker agent responses processed using strict formatting (e.g., JSON schemas)?
-✅ Have human-in-the-loop Approval Gates been enforced prior to destructive actions?
-✅ Are dependencies formally mapped (e.g., Backend Worker must finish before Frontend Worker begins)?
-✅ Are worker failure states (`BLOCKED`, `ERROR`) explicitly caught and handled by the Supervisor?
-✅ Does the system gracefully halt and explicitly prompt the user after 3 sequential execution failures?
-✅ Did I ensure the worker relies on explicitly designated skills/manifests rather than generalized knowledge?
-```
+---
+name: agent-organizer
+description: Master Agent orchestration framework. Coordination of sub-agents, workflow definitions, delegation patterns, state management across conversations, memory distillation, and execution loops. Use when assembling multi-agent systems or managing complex agent-to-agent architectures.
+allowed-tools: Read, Write, Edit, Glob, Grep
+version: 2.0.0
+last-updated: 2026-04-02
+applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
+---
+
+# Agent Organizer — Multi-Agent Orchestration Mastery
+
+---
+
+## 1. The Delegation Sub-Agent Pattern
+
+Agents should defer specific domain problems to specialized sub-agents.
+
+```json
+// Define the payload contract the Worker Agent expects
+{
+  "taskId": "task-auth-migration-01",
+  "workerRole": "api-security-auditor",
+  "isolatedContext": {
+    "filesToScan": ["src/login.ts", "src/middleware.ts"],
+    "objective": "Identify unprotected mass assignments"
+  },
+  "requiredOutputFormat": "json_list"
+}
+```
+
+### Delegation Rules:
+1. **Never pass full histories:** Do not pass the entire conversation history to a worker sub-agent. Extract only the exact files and goal context required. (Context Window Budgeting).
+2. **Clear Boundaries:** If the worker is fixing CSS, it must not invent logic for the database.
+3. **Structured Handoff:** The parent agent requests JSON from the worker, parses it, and then acts. Let machines talk to machines through syntax, not prose.
+
+---
+
+## 2. Execution Loops (Supervisor Pattern)
+
+A Supervisor decides *who* works and *when*, but does not execute the work.
+
+```
+[User Request: "Add OAuth and secure it"]
+       |
+[Supervisor Agent analyzing required skills...]
+       |
+       ├─> [Dispatches: authentication-best-practices]
+       |         (Worker builds OAuth implementation)
+       |
+       ├─> [Dispatches: api-security-auditor]
+       |         (Worker reviews implementation against OWASP)
+       |
+[Supervisor Agent synthesizes findings]
+       |
+[Action Executed / Git Commit]
+```
+
+### Handoff Signals
+A worker must return definitive state signals when yielding control:
+- `COMPLETE`: Goal achieved. Final diff generated.
+- `BLOCKED`: Missing context (e.g., "I need the `.env` schema").
+- `ERROR`: Script failed, requires manual Supervisor intervention.
+
+---
+
+## 3. Session State Management (Memory)
+
+Agents lose memory across boundaries. The Organizer must explicitly persist context.
+
+1. **Short-Term Context:** Maintained natively in the active LLM context window.
+2. **Task State:** Maintained locally in `task.md`. Workers check-in and check-out checkboxes.
+3. **Long-Term Memory:** "Knowledge Items" (KIs). Distilling massive conversations down into a single `learnings.json` file injected on subsequent startups.
+
+```markdown
+<!-- task.md (The Global Execution State) -->
+# Current Objective: Build Chat Feature
+- [x] Initialize websocket connection
+- [/] (Worker: frontend-specialist) Build Chat UI component
+- [ ] (Worker: realtime-patterns) Implement presence sync
+```
+
+---
+
+## 4. The Human-in-the-Loop (Socratic Gate)
+
+Automation without oversight is reckless. The Organizer manages when to pause and query the human.
+
+**Mandatory Gates:**
+1. **Approval Gate (Before Execution):** "I have drafted the architecture plan. Do you approve execution?"
+2. **Recovery Gate (After 3 Failures):** "The database migration script has failed 3 times. I am halting. How would you like to proceed?"
+
+---

package/.agent/skills/agentic-patterns/SKILL.md

@@ -9,9 +9,6 @@ applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
 
 # Agentic Patterns
 
-> An agent is a loop. A good agent is a loop with clear termination conditions and a human override.
-> An agent without guardrails is a liability, not a feature.
-
 ---
 
 ## The Agent Loop
@@ -265,71 +262,4 @@ VBC status:  PENDING → VERIFIED
 Evidence:    [link to terminal output, test result, or file diff]
 ```
 
-
----
-
-## 🏛️ Tribunal Integration (Anti-Hallucination)
-
-**Slash command: `/review-ai`**
-**Active reviewers: `logic` · `security` · `ai-code-reviewer`**
-
-### ❌ Forbidden AI Tropes in Agentic Systems
-
-1. **Infinite loops** — any agent loop without `MAX_STEPS` will spin until context limit or cost limit is hit. Always define a hard cap.
-2. **No human override** — agents operating on user data with no human gate for destructive or irreversible actions.
-3. **Trusting tool output as ground truth** — tool results can be wrong, stale, or injected. Always validate before acting on them.
-4. **Overly broad tool permissions** — an agent that can "run any shell command" or "access any database table" violates least privilege.
-5. **No cost cap** — `Promise.all(100 tasks × $0.10 each)` = $10 surprise bill per trigger. Set cost limits at the session level.
-
-### ✅ Pre-Flight Self-Audit
-
-```
-✅ Is there a hard MAX_STEPS limit on every agent loop?
-✅ Are irreversible actions gated behind human approval?
-✅ Are tool results validated before being acted upon?
-✅ Does each agent follow least-privilege tool access (not "all tools")?
-✅ Is there a per-session token and cost cap?
-✅ Is there an output guardrail checking for hallucinated citations or schema violations?
-```
-
-
----
-
-## 🤖 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.