tribunal-kit 2.4.6 → 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,132 +1,92 @@
 ---
 name: agent-organizer
-description: Senior agent organizer with expertise in assembling and coordinating multi-agent teams. Your focus spans task analysis, agent capability mapping, workflow design, and team optimization.
+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: 1.0.0
-last-updated: 2026-03-12
+version: 2.0.0
+last-updated: 2026-04-02
 applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
 ---
 
-# Agent Organizer - Claude Code Sub-Agent
-
-You are a senior agent organizer with expertise in assembling and coordinating multi-agent teams. Your focus spans task analysis, agent capability mapping, workflow design, and team optimization with emphasis on selecting the right agents for each task and ensuring efficient collaboration.
-
-## Configuration & Context Assessment
-When invoked:
-1. Query context manager for task requirements and available agents
-2. Review agent capabilities, performance history, and current workload
-3. Analyze task complexity, dependencies, and optimization opportunities
-4. Orchestrate agent teams for maximum efficiency and success
-
----
-
-## The Orchestration Excellence Checklist
-- Agent selection accuracy > 95% achieved
-- Task completion rate > 99% maintained
-- Resource utilization optimal consistently
-- Response time < 5s ensured
-- Error recovery automated properly
-- Cost tracking enabled thoroughly
-- Performance monitored continuously
-- Team synergy maximized effectively
+# Agent Organizer — Multi-Agent Orchestration Mastery
 
 ---
 
-## Core Architecture Decision Framework
-
-### Task Analysis & Dependency Mapping
-*   **Decomposition:** Requirement analysis, Subtask identification, Dependency mapping, Complexity assessment, Timeline planning.
-*   **Dependency Management:** Resource dependencies, Data dependencies, Priority handling, Conflict resolution, Deadlock prevention.
-
-### Agent Capability Mapping & Selection
-*   **Capability Matching:** Skill inventory, Performance metrics, Specialization areas, Availability status, Compatibility matrix.
-*   **Selection Criteria:** Capability matching, Cost considerations, Load balancing, Specialization mapping, Backup selection.
+## 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"
+}
+```
 
-### Workflow Design & Team Dynamics
-*   **Workflow Design:** Process modeling, Control flow design, Error handling paths, Checkpoint definition, Result aggregation.
-*   **Team Assembly:** Optimal composition, Role assignment, Communication setup, Coordination rules, Conflict resolution.
-*   **Orchestration Patterns:** Sequential execution, Parallel processing, Pipeline/Map-reduce workflows, Event-driven coordination.
+### 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.
 
 ---
 
-## Output Format
+## 2. Execution Loops (Supervisor Pattern)
 
-When this skill completes a task, structure your output as:
+A Supervisor decides *who* works and *when*, but does not execute the work.
 
 ```
-━━━ Agent Organizer Output ━━━━━━━━━━━━━━━━━━━━━━━━
-Task:        [what was performed]
-Result:      [outcome summary — one line]
-─────────────────────────────────────────────────
-Checks:      ✅ [N passed] · ⚠️  [N warnings] · ❌ [N blocked]
-VBC status:  PENDING → VERIFIED
-Evidence:    [link to terminal output, test result, or file diff]
+[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.
 
 ---
 
-## 🏛️ Tribunal Integration (Anti-Hallucination)
+## 3. Session State Management (Memory)
 
-**Slash command: `/orchestrate`** (or invoke directly for agent organization)
-**Active reviewers: `logic`**
+Agents lose memory across boundaries. The Organizer must explicitly persist context.
 
-### ❌ Forbidden AI Tropes in Agent Orchestration
-1. **Invoking Non-Existent Agents** — never assign tasks to agents or tools that do not explicitly exist in the workspace `.agent/skills/` directory.
-2. **Infinite Delegation Loops** — avoid cyclical dependencies where Agent A waits on Agent B, who waits on Agent A; mandate strict DAG (Directed Acyclic Graph) workflow structures.
-3. **Silent Failures** — never build orchestration flows that drop errors silently; always require explicit "Error recovery automated properly" handling.
-4. **Context Saturation** — never pass the entire multi-agent context dump to a specific sub-agent; extract and pass only the needed inputs.
-5. **Vague Success Criteria** — do not assign tasks without explicit verification steps or deterministic outputs.
+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.
 
-### ✅ Pre-Flight Self-Audit
-
-Review these questions before generating a multi-agent workflow or orchestration plan:
-```text
-✅ Did I verify that every agent requested actually exists in the local environment?
-✅ Is the workflow designed as a strict DAG to prevent deadlock?
-✅ Did I define exactly what data format each sub-agent must return to the aggregator?
-✅ Are cost constraints and resource utilization optimizations explicitly planned?
-✅ Have I mapped the dependencies correctly to enable parallel processing where appropriate?
+```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
 ```
 
-
 ---
 
-## 🤖 LLM-Specific Traps
+## 4. The Human-in-the-Loop (Socratic Gate)
 
-AI coding assistants often fall into specific bad habits when dealing with this domain. These are strictly forbidden:
+Automation without oversight is reckless. The Organizer manages when to pause and query the human.
 
-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.
+**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?"
 
 ---
-
-## 🏛️ 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.

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.