tribunal-kit 3.0.0 → 4.0.0

package/.agent/scripts/consolidate_skills.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+consolidate_skills.py
+Merges all sub-files in skill directories into the main SKILL.md.
+Strips: verbose intros, output format blocks, run scripts tables,
+        mandatory read tables, empty headers, redundant boilerplate.
+Keeps:  all code blocks, hallucination traps, checklist items.
+
+Usage:
+  python .agent/scripts/consolidate_skills.py [skill_name]
+  python .agent/scripts/consolidate_skills.py               # all skills
+"""
+
+import os, re, sys
+
+BASE = '.agent/skills'
+
+# These patterns are global (GEMINI.md) — strip from sub-files before merge
+STRIP_PATTERNS = [
+    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)^## Output Format\b.*?(?=^## |\Z)',
+    r'(?ms)^## 🔧 Runtime Scripts.*?(?=^## |\Z)',
+    r'(?ms)^## 🔴 MANDATORY.*?(?=^## |\Z)',
+    r'(?ms)^## ⚠️ CRITICAL: ASK BEFORE ASSUMING.*?(?=^## |\Z)',
+    r'(?ms)^## 📝 CHECKPOINT \(MANDATORY.*?(?=^## |\Z)',
+    r'(?ms)^## Output Format.*?```\n[^`]*```\n?(?=^## |\Z)',
+    r'(?ms)^\*\*Execute these for validation.*?---\n',
+    r'(?ms)^\*\*VBC \(Verification-Before-Completion\).*?\n',
+    # MANDATORY read tables
+    r'(?ms)^\*\*⛔ DO NOT start.*?---\n?',
+    r'(?ms)^> 🧠 \*\*mobile-design.*?\n',
+    r'(?ms)^> \*\*STOP.*?\n',
+]
+
+# Heading level adjustment (sub-files use H1 — convert to H2 in merged output)
+def adjust_headings(content, offset=1):
+    """Promote headings by adding # chars"""
+    lines = content.split('\n')
+    out = []
+    for line in lines:
+        m = re.match(r'^(#{1,5}) ', line)
+        if m:
+            level = len(m.group(1))
+            new_level = min(level + offset, 6)
+            line = '#' * new_level + line[level:]
+        out.append(line)
+    return '\n'.join(out)
+
+def clean_content(content):
+    """Apply strip patterns"""
+    for p in STRIP_PATTERNS:
+        content = re.sub(p, '', content)
+    content = re.sub(r'\n{3,}', '\n\n', content)
+    return content.strip()
+
+def extract_frontmatter(content):
+    """Return (frontmatter_dict_str, body)"""
+    m = re.match(r'^---\n(.*?)\n---\n', content, re.DOTALL)
+    if m:
+        return m.group(1), content[m.end():]
+    return '', content
+
+def get_sub_title(content):
+    """Get first H1 from a sub-file"""
+    m = re.search(r'^# (.+)', content, re.MULTILINE)
+    return m.group(1) if m else None
+
+def consolidate(skill_dir):
+    skill_name = os.path.basename(skill_dir)
+    main_path = os.path.join(skill_dir, 'SKILL.md')
+    if not os.path.exists(main_path):
+        return False
+
+    # Find sub-files (non-SKILL.md markdown files)
+    sub_files = sorted([
+        f for f in os.listdir(skill_dir)
+        if f.endswith('.md') and f != 'SKILL.md'
+    ])
+
+    if not sub_files:
+        return False
+
+    print(f'\n  → Consolidating: {skill_name} ({len(sub_files)} sub-files)')
+
+    # Read main SKILL.md
+    main_content = open(main_path, 'r', encoding='utf-8', errors='ignore').read()
+    frontmatter, main_body = extract_frontmatter(main_content)
+
+    # Clean & update frontmatter version
+    fm_lines = frontmatter.split('\n')
+    new_fm = []
+    for line in fm_lines:
+        if line.startswith('version:'):
+            new_fm.append('version: 3.1.0')
+        elif line.startswith('last-updated:'):
+            new_fm.append('last-updated: 2026-04-06')
+        else:
+            new_fm.append(line)
+    frontmatter = '\n'.join(new_fm)
+
+    # Clean main body
+    main_body = clean_content(main_body)
+
+    # Remove MANDATORY read table from main body
+    # (links like [file.md](file.md) in tables)
+    main_body = re.sub(r'\|.*?\.md.*?\|.*?\|.*?\|\n', '', main_body)
+    main_body = re.sub(r'^\|[-| ]+\|\n', '', main_body, flags=re.MULTILINE)
+    main_body = re.sub(r'\n{3,}', '\n\n', main_body)
+
+    # Merge sub-files
+    merged_sections = []
+    for fname in sub_files:
+        fpath = os.path.join(skill_dir, fname)
+        raw = open(fpath, 'r', encoding='utf-8', errors='ignore').read()
+        _, body = extract_frontmatter(raw)
+        body = clean_content(body)
+        # Adjust headings: H1→H2, H2→H3, etc.
+        body = adjust_headings(body, offset=1)
+        if body.strip():
+            merged_sections.append(body.strip())
+
+    # Build final output
+    combined = f'---\n{frontmatter}\n---\n\n{main_body}'
+    if merged_sections:
+        combined += '\n\n---\n\n' + '\n\n---\n\n'.join(merged_sections)
+
+    # Final cleanup
+    combined = re.sub(r'\n{3,}', '\n\n', combined)
+    combined = combined.strip() + '\n'
+
+    # Measure savings
+    total_sub_bytes = sum(os.path.getsize(os.path.join(skill_dir, f)) for f in sub_files)
+    print(f'     Sub-files total: {total_sub_bytes//1024}KB')
+
+    # Write consolidated SKILL.md
+    with open(main_path, 'w', encoding='utf-8') as f:
+        f.write(combined)
+
+    new_size = os.path.getsize(main_path)
+    print(f'     New SKILL.md:    {new_size//1024}KB  (from {len(main_content)//1024}KB main + {total_sub_bytes//1024}KB subs → {new_size//1024}KB)')
+
+    # Delete sub-files
+    for fname in sub_files:
+        os.remove(os.path.join(skill_dir, fname))
+        print(f'     Deleted: {fname}')
+
+    return True
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else None
+
+    total_saved = 0
+    processed = 0
+
+    for skill_name in os.listdir(BASE):
+        skill_dir = os.path.join(BASE, skill_name)
+        if not os.path.isdir(skill_dir):
+            continue
+        if target and skill_name != target:
+            continue
+        if consolidate(skill_dir):
+            processed += 1
+
+    if processed == 0:
+        print('No skills with sub-files found (or target not matched).')
+    else:
+        print(f'\n✅ Consolidated {processed} skills.')
+
+if __name__ == '__main__':
+    main()

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