tribunal-kit 9.0.0 → 9.0.2

package/skills/i18n-localization/SKILL.md

@@ -0,0 +1,209 @@
+---
+name: i18n-localization
+description: Use when Internationalization (i18n) and localization mastery. Abstracting hardcoded strings, managing JSON/YAML translation dictionaries, bidirectional routing (RTL support for Arabic/Hebrew), Pluralization algorithms, date/currency formatting, and SSR locale detection in Next.js/React. Use when preparing an application for global multilingual scaling.
+version: 5.0.0
+last-updated: 2026-09-13
+skills:
+  - nextjs-react-expert
+  - adapt
+  - baseline-ui
+tools: Read, Grep, Glob, Bash, Edit, Write
+scripts-binding:
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
+---
+
+# i18n & Localization — Global Scale Mastery
+
+## Mandatory Pre-Flight Context Inspection
+
+Before generating, refactoring, or reviewing code in the `i18n-localization` domain, inspect these 5 critical parameters:
+
+1. **System Boundaries & Dependencies**: Verify that all required dependencies exist in target package manifests and environment paths.
+2. **Runtime Context & Platform Invariants**: Confirm target platform constraints (Node.js, Browser, Mobile OS, Edge runtime) before applying APIs.
+3. **Execution Guardrails**: Identify potential side-effects, state mutations, and unhandled asynchronous exceptions.
+4. **Validation & Type Contracts**: Validate input data schemas and strict type constraints across all module interfaces.
+5. **Observability & Proof of Execution**: Ensure execution produces tangible verification signals (terminal output, tests, metrics).
+
+## Activation Boundaries
+
+- **Activate when:** Use when Internationalization (i18n) and localization mastery. Abstracting hardcoded strings, managing JSON/YAML translation dictionaries, bidirectional routing (RTL support for Arabic/Hebrew), Pluralization algorithms, date/currency formatting, and SSR locale detection in Next.js/React. Use when preparing an application for global multilingual scaling.
+- **DO NOT activate when:** The task falls outside the `i18n-localization` domain or is managed by a different dedicated specialist.
+
+## 🔁 Multi-Pass Execution Protocol
+
+Execute all non-trivial tasks through this 7-pass cognitive loop:
+
+| Pass | Phase | Core Action |
+|:---|:---|:---|
+| **Pass 1** | **Understand** | Deconstruct the user's explicit objective, implicit requirements, and platform constraints. |
+| **Pass 2** | **Plan** | Decompose the task into smallest logical steps; map dependencies and required tool calls. |
+| **Pass 3** | **Execute** | Implement the solution with production-grade craft, zero placeholders, and strict typing. |
+| **Pass 4** | **Verify** | Run linters, unit tests, or compiler checks to validate structural correctness. |
+| **Pass 5** | **Attack** | Perform an adversarial review searching for edge-case failures, race conditions, and traps. |
+| **Pass 6** | **Improve** | Eliminate discovered friction, optimize performance, and harden error boundaries. |
+| **Pass 7** | **Quality Gate** | Enforce Verification-Before-Completion (VBC) with concrete terminal proof before finalizing. |
+
+---
+
+## 🛠️ Technical Architecture & Reference Recipes
+
+---
+
+
+## Hallucination Traps (Read First)
+
+- ❌ Concatenating translated strings (`'Hello ' + name`) -> ✅ Use interpolation: `t('greeting', { name })` to handle word order differences
+- ❌ Hardcoding date/number formats -> ✅ Use `Intl.DateTimeFormat` and `Intl.NumberFormat` with the user's locale
+- ❌ Assuming all languages read left-to-right -> ✅ Arabic, Hebrew, Farsi are RTL; use CSS `dir='auto'` and logical properties
+- ❌ Using string length for validation on translated text -> ✅ Translations can be 30-200% longer than English; design for expansion
+
+---
+
+---
+
+## 1. The i18n Architecture (Next.js / React)
+
+Do not hardcode strings inside UI components. Use a standardized library (e.g., `next-intl` or `react-i18next`).
+
+### Step 1: Dictionary Abstraction
+
+```json
+// messages/en.json
+{
+  "Dashboard": {
+    "welcomeMessage": "Welcome back, {name}!",
+    "unreadAlerts": "{count, plural, =0 {No unread alerts} one {You have 1 unread alert} other {You have # unread alerts}}"
+  }
+}
+```
+
+### Step 2: Component Implementation
+
+```tsx
+// ❌ BAD: Hardcoded English text and manual variable interpolation
+export function Header({ user, alertCount }) {
+  return (
+    <h1>
+      Welcome back, {user.name}! You have {alertCount} alerts.
+    </h1>
+  );
+}
+
+// ✅ GOOD: i18n Abstraction (using next-intl)
+import { useTranslations } from 'next-intl';
+
+export function Header({ user, alertCount }) {
+  const t = useTranslations('Dashboard');
+
+  return (
+    <header>
+      <h1>{t('welcomeMessage', { name: user.name })}</h1>
+      <p>{t('unreadAlerts', { count: alertCount })}</p>
+    </header>
+  );
+}
+```
+
+---
+
+## 2. Advanced Native Formatting (`Intl`)
+
+Do not install `moment.js` or write massive regex string parsers to format currencies in Euros vs Dollars. The browser handles this natively with the `Intl` API.
+
+```typescript
+// Data/Currency Formatting correctly tied to the active locale
+const locale = 'de-DE';
+
+// ✅ Currency
+const price = new Intl.NumberFormat(locale, { style: 'currency', currency: 'EUR' }).format(1200.5);
+// Output in Germany: "1.200,50 €"
+
+// ✅ Dates
+const date = new Intl.DateTimeFormat(locale, { dateStyle: 'full' }).format(new Date());
+// Output in Germany: "Freitag, 2. April 2026"
+
+// ✅ Relative Time
+const rtf = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });
+rtf.format(-2, 'day'); // Output: "vorgestern" (the day before yesterday)
+```
+
+---
+
+## 3. Bidirectional Architecture (RTL)
+
+For languages like Arabic and Hebrew, the UI must fundamentally flip horizontally. Right-To-Left (RTL) breaks standard CSS `marginLeft` and `marginRight`.
+
+**The Solution:** Logical CSS Properties.
+Tailwind v4 (and modern CSS) natively supports logical direction.
+
+```css
+/* ❌ BAD: Hardcoded physical space */
+.btn {
+  margin-left: 10px;
+} /* Will break layout in Hebrew */
+
+/* ✅ GOOD: Logical spacing (Tailwind: ms-4, me-4) */
+.btn {
+  margin-inline-start: 10px;
+} /* Automatically flips in RTL mode */
+```
+
+_In React HTML tag:_ `<html lang="ar" dir="rtl">`
+
+---
+
+## 4. Routing and SSR Detection
+
+Users should not face English UI natively in Japan. Detect their browser headers at the edge routing layer.
+
+In Next.js Middleware:
+
+1. Parse the incoming `Accept-Language` header.
+2. Intercept requests to `/dashboard`.
+3. Rewrite URL to the detected locale (e.g., `/ja/dashboard`).
+
+---
+
+## 🚨 Edge-Case & Failure Mode Matrix
+
+| Scenario | Risk | Mitigation Strategy |
+|:---|:---|:---|
+| **Empty or Null Inputs** | Unhandled exception or unexpected rendering collapse | Enforce fallback guards, optional chaining, and explicit empty state handlers |
+| **Network Timeout / Latency** | Hanging operations or duplicate side-effects | Implement bounded abort controllers, exponential backoff, and idempotency keys |
+| **Concurrency / Race Conditions** | Stale state overwrite or inconsistent data mutations | Use atomic transactions, mutex locking, or cancel-on-resubmit controls |
+| **Invalid Schema / Malformed Payload** | Downstream runtime errors or security injection | Validate boundary payloads with Zod/Pydantic schemas prior to execution |
+| **Resource / Memory Saturation** | OOM errors, frame drops, or memory leaks | Clean up listeners, cancel active timers, and enforce pagination/virtualization |
+
+---
+
+## 🤖 LLM-Specific Traps Table
+
+| Anti-Pattern | What AI Commonly Does Wrong | What Is Actually Correct |
+|:---|:---|:---|
+| **Hallucinated Tool Capabilities** | Assuming an external library or CLI command exists without verification | Run a verification check or verify package.json before referencing tools |
+| **Premature Completion Claim** | Declaring a task finished because code was generated without verification | Execute tests, linters, or terminal commands to provide concrete proof |
+| **Context Bloat Dumping** | Pasting entire multi-thousand-line files into prompt context | Extract targeted excerpts, symbols, and signatures to preserve tokens |
+
+---
+
+## 🏛️ Tribunal Verification & Guardrails
+
+**Active Reviewers:** `orchestrator` · `agent-organizer` · `logic-reviewer`
+**Slash Command:** `/review` or `/tribunal-full`
+
+### ✅ Pre-Flight Self-Audit Checklist
+
+```
+✅ Did I deconstruct the root objective before proposing architecture?
+✅ Did I identify dependencies, bottlenecks, and parallelizable sub-tasks?
+✅ Did I avoid over-engineering and select the simplest effective pattern?
+✅ Did I verify assumptions with concrete file reads instead of speculation?
+✅ Did I establish measurable verification criteria before completion?
+```
+
+### 🛑 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 test suites, compiler success, or equivalent operational proof) that your output works as intended.

package/skills/i18n-localization/scripts/i18n_checker.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""
+i18n Checker - Detects hardcoded strings and missing translations.
+Scans for untranslated text in React, Vue, and Python files.
+"""
+import sys
+import re
+import json
+from pathlib import Path
+
+# Fix Windows console encoding for Unicode output
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+except AttributeError:
+    pass  # Python < 3.7
+
+# Patterns that indicate hardcoded strings (should be translated)
+HARDCODED_PATTERNS = {
+    'jsx': [
+        # Text directly in JSX: <div>Hello World</div>
+        r'>\s*[A-Z][a-zA-Z\s]{3,30}\s*</',
+        # JSX attribute strings: title="Welcome"
+        r'(title|placeholder|label|alt|aria-label)="[A-Z][a-zA-Z\s]{2,}"',
+        # Button/heading text
+        r'<(button|h[1-6]|p|span|label)[^>]*>\s*[A-Z][a-zA-Z\s!?.,]{3,}\s*</',
+    ],
+    'vue': [
+        # Vue template text
+        r'>\s*[A-Z][a-zA-Z\s]{3,30}\s*</',
+        r'(placeholder|label|title)="[A-Z][a-zA-Z\s]{2,}"',
+    ],
+    'python': [
+        # print/raise with string literals
+        r'(print|raise\s+\w+)\s*\(\s*["\'][A-Z][^"\']{5,}["\']',
+        # Flask flash messages
+        r'flash\s*\(\s*["\'][A-Z][^"\']{5,}["\']',
+    ]
+}
+
+# Patterns that indicate proper i18n usage
+I18N_PATTERNS = [
+    r't\(["\']',           # t('key') - react-i18next
+    r'useTranslation',     # React hook
+    r'\$t\(',              # Vue i18n
+    r'_\(["\']',           # Python gettext
+    r'gettext\(',          # Python gettext
+    r'useTranslations',    # next-intl
+    r'FormattedMessage',   # react-intl
+    r'i18n\.',             # Generic i18n
+]
+
+def find_locale_files(project_path: Path) -> list:
+    """Find translation/locale files."""
+    patterns = [
+        "**/locales/**/*.json",
+        "**/translations/**/*.json",
+        "**/lang/**/*.json",
+        "**/i18n/**/*.json",
+        "**/messages/*.json",
+        "**/*.po",  # gettext
+    ]
+    
+    files = []
+    for pattern in patterns:
+        files.extend(project_path.glob(pattern))
+    
+    return [f for f in files if 'node_modules' not in str(f)]
+
+def check_locale_completeness(locale_files: list) -> dict:
+    """Check if all locales have the same keys."""
+    issues = []
+    passed = []
+    
+    if not locale_files:
+        return {'passed': [], 'issues': ["[!] No locale files found"]}
+    
+    # Group by parent folder (language)
+    locales = {}
+    for f in locale_files:
+        if f.suffix == '.json':
+            try:
+                lang = f.parent.name
+                content = json.loads(f.read_text(encoding='utf-8'))
+                if lang not in locales:
+                    locales[lang] = {}
+                locales[lang][f.stem] = set(flatten_keys(content))
+            except:
+                continue
+    
+    if len(locales) < 2:
+        passed.append(f"[OK] Found {len(locale_files)} locale file(s)")
+        return {'passed': passed, 'issues': issues}
+    
+    passed.append(f"[OK] Found {len(locales)} language(s): {', '.join(locales.keys())}")
+    
+    # Compare keys across locales
+    all_langs = list(locales.keys())
+    base_lang = all_langs[0]
+    
+    for namespace in locales.get(base_lang, {}):
+        base_keys = locales[base_lang].get(namespace, set())
+        
+        for lang in all_langs[1:]:
+            other_keys = locales.get(lang, {}).get(namespace, set())
+            
+            missing = base_keys - other_keys
+            if missing:
+                issues.append(f"[X] {lang}/{namespace}: Missing {len(missing)} keys")
+            
+            extra = other_keys - base_keys
+            if extra:
+                issues.append(f"[!] {lang}/{namespace}: {len(extra)} extra keys")
+    
+    if not issues:
+        passed.append("[OK] All locales have matching keys")
+    
+    return {'passed': passed, 'issues': issues}
+
+def flatten_keys(d, prefix=''):
+    """Flatten nested dict keys."""
+    keys = set()
+    for k, v in d.items():
+        new_key = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict):
+            keys.update(flatten_keys(v, new_key))
+        else:
+            keys.add(new_key)
+    return keys
+
+def check_hardcoded_strings(project_path: Path) -> dict:
+    """Check for hardcoded strings in code files."""
+    issues = []
+    passed = []
+    
+    # Find code files
+    extensions = {
+        '.tsx': 'jsx', '.jsx': 'jsx', '.ts': 'jsx', '.js': 'jsx',
+        '.vue': 'vue',
+        '.py': 'python'
+    }
+    
+    code_files = []
+    for ext in extensions:
+        code_files.extend(project_path.rglob(f"*{ext}"))
+    
+    code_files = [f for f in code_files if not any(x in str(f) for x in 
+                  ['node_modules', '.git', 'dist', 'build', '__pycache__', 'venv', 'test', 'spec'])]
+    
+    if not code_files:
+        return {'passed': ["[!] No code files found"], 'issues': []}
+    
+    files_with_i18n = 0
+    files_with_hardcoded = 0
+    hardcoded_examples = []
+    
+    for file_path in code_files[:50]:  # Limit
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+            ext = file_path.suffix
+            file_type = extensions.get(ext, 'jsx')
+            
+            # Check for i18n usage
+            has_i18n = any(re.search(p, content) for p in I18N_PATTERNS)
+            if has_i18n:
+                files_with_i18n += 1
+            
+            # Check for hardcoded strings
+            patterns = HARDCODED_PATTERNS.get(file_type, [])
+            hardcoded_found = False
+            
+            for pattern in patterns:
+                matches = re.findall(pattern, content)
+                if matches and not has_i18n:
+                    hardcoded_found = True
+                    if len(hardcoded_examples) < 5:
+                        hardcoded_examples.append(f"{file_path.name}: {str(matches[0])[:40]}...")
+            
+            if hardcoded_found:
+                files_with_hardcoded += 1
+                
+        except:
+            continue
+    
+    passed.append(f"[OK] Analyzed {len(code_files)} code files")
+    
+    if files_with_i18n > 0:
+        passed.append(f"[OK] {files_with_i18n} files use i18n")
+    
+    if files_with_hardcoded > 0:
+        issues.append(f"[X] {files_with_hardcoded} files may have hardcoded strings")
+        for ex in hardcoded_examples:
+            issues.append(f"   → {ex}")
+    else:
+        passed.append("[OK] No obvious hardcoded strings detected")
+    
+    return {'passed': passed, 'issues': issues}
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "."
+    project_path = Path(target)
+    
+    print("\n" + "=" * 60)
+    print("  i18n CHECKER - Internationalization Audit")
+    print("=" * 60 + "\n")
+    
+    # Check locale files
+    locale_files = find_locale_files(project_path)
+    locale_result = check_locale_completeness(locale_files)
+    
+    # Check hardcoded strings
+    code_result = check_hardcoded_strings(project_path)
+    
+    # Print results
+    print("[LOCALE FILES]")
+    print("-" * 40)
+    for item in locale_result['passed']:
+        print(f"  {item}")
+    for item in locale_result['issues']:
+        print(f"  {item}")
+    
+    print("\n[CODE ANALYSIS]")
+    print("-" * 40)
+    for item in code_result['passed']:
+        print(f"  {item}")
+    for item in code_result['issues']:
+        print(f"  {item}")
+    
+    # Summary
+    critical_issues = sum(1 for i in locale_result['issues'] + code_result['issues'] if i.startswith("[X]"))
+    
+    print("\n" + "=" * 60)
+    if critical_issues == 0:
+        print("[OK] i18n CHECK: PASSED")
+        sys.exit(0)
+    else:
+        print(f"[X] i18n CHECK: {critical_issues} issues found")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/skills/impeccable/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: impeccable
+description: Use when Flagship design engineering skill for creating production-grade, anti-generic frontend interfaces with supreme craftsmanship, visual hierarchy, typography, spatial systems, and micro-interactions.
+version: 5.0.0
+last-updated: 2026-09-13
+skills:
+  - better-ui
+  - better-colors
+  - baseline-ui
+tools: Read, Grep, Glob, Bash, Edit, Write
+scripts-binding:
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
+---
+
+# Impeccable — Production-Grade Frontend Craft
+
+## Mandatory Pre-Flight Context Inspection
+
+Before generating, refactoring, or reviewing code in the `impeccable` domain, inspect these 5 critical parameters:
+
+1. **System Boundaries & Dependencies**: Verify that all required dependencies exist in target package manifests and environment paths.
+2. **Runtime Context & Platform Invariants**: Confirm target platform constraints (Node.js, Browser, Mobile OS, Edge runtime) before applying APIs.
+3. **Execution Guardrails**: Identify potential side-effects, state mutations, and unhandled asynchronous exceptions.
+4. **Validation & Type Contracts**: Validate input data schemas and strict type constraints across all module interfaces.
+5. **Observability & Proof of Execution**: Ensure execution produces tangible verification signals (terminal output, tests, metrics).
+
+## Activation Boundaries
+
+- **Activate when:** Use when Flagship design engineering skill for creating production-grade, anti-generic frontend interfaces with supreme craftsmanship, visual hierarchy, typography, spatial systems, and micro-interactions.
+- **DO NOT activate when:** The task falls outside the `impeccable` domain or is managed by a different dedicated specialist.
+
+## 🔁 Multi-Pass Execution Protocol
+
+Execute all non-trivial tasks through this 7-pass cognitive loop:
+
+| Pass | Phase | Core Action |
+|:---|:---|:---|
+| **Pass 1** | **Understand** | Deconstruct the user's explicit objective, implicit requirements, and platform constraints. |
+| **Pass 2** | **Plan** | Decompose the task into smallest logical steps; map dependencies and required tool calls. |
+| **Pass 3** | **Execute** | Implement the solution with production-grade craft, zero placeholders, and strict typing. |
+| **Pass 4** | **Verify** | Run linters, unit tests, or compiler checks to validate structural correctness. |
+| **Pass 5** | **Attack** | Perform an adversarial review searching for edge-case failures, race conditions, and traps. |
+| **Pass 6** | **Improve** | Eliminate discovered friction, optimize performance, and harden error boundaries. |
+| **Pass 7** | **Quality Gate** | Enforce Verification-Before-Completion (VBC) with concrete terminal proof before finalizing. |
+
+---
+
+## 🛠️ Technical Architecture & Reference Recipes
+
+---
+
+
+---
+
+## Core Pillars of Impeccable UI
+
+### 1. Typography & Typographic Rhythm
+
+- **Optical Sizing & Tracking**: Large display headings (32px+) require tight letter-spacing (`letter-spacing: -0.03em`). Small caption text (12px) requires positive tracking (`letter-spacing: +0.01em`).
+- **Tabular Numbers**: Any numeric data that updates, increments, or displays in columns MUST use `font-variant-numeric: tabular-nums` or `font-feature-settings: "tnum"` to prevent visual jitter.
+- **Text Wrapping & Balance**: Headings MUST use `text-wrap: balance` to prevent typographic orphans. Body paragraphs MUST use `text-wrap: pretty` (where supported) or max `65ch` width.
+
+### 2. Color Systems & Gamut Precision
+
+- **OKLCH Color Space**: Prefer `oklch()` over `hsl()` or `hex` for smooth perceptual uniformity across hue and lightness shifts.
+- **Subtle Surface Steps**: Define surface colors with small perceptual lightness steps ($L \pm 2\%$) to create hierarchy without harsh dividers.
+- **Adaptive Contrast**: Text contrast MUST adapt automatically across light/dark themes with high legibility ratios ($\ge 7:1$ for primary, $\ge 4.5:1$ for secondary).
+
+### 3. Motion & Micro-Interactions
+
+- **Intentional Motion**: Animations exist ONLY to convey spatial continuity, provide press feedback, or indicate state changes.
+- **Duration Constraints**: Micro-interactions $\le 160\text{ms}$; dropdowns/popovers $\le 220\text{ms}$; page transitions $\le 300\text{ms}$.
+- **Physically Grounded Entrances**: Elements scale in from `scale(0.96)` and opacity `0`, anchored to their trigger origin.
+- **DOM Entry (@starting-style)**: Use `@starting-style` with `transition-behavior: allow-discrete` for smooth `display: none` to `display: block` entrance animations without JS overhead.
+
+### 4. Layout Mechanics & Spatial Math
+
+- **8px Grid System**: Every margin, padding, gap, and height MUST derive from an 8px grid (or 4px micro-grid).
+- **Asymmetrical Balance**: Avoid cookie-cutter centered layouts for SaaS apps. Use strong left-aligned structural axes with generous negative space.
+- **Container Queries**: Components adjust layout based on container size (`@container`), not viewport size (`@media`), making them context-agnostic.
+- **WCAG 2.2 AA Target Size (SC 2.5.8)**: All interactive targets MUST measure at least `24x24px` CSS pixels (min `44x44px` for touch).
+
+---
+
+## 🚨 Edge-Case & Failure Mode Matrix
+
+| Scenario | Risk | Mitigation Strategy |
+|:---|:---|:---|
+| **Empty or Null Inputs** | Unhandled exception or unexpected rendering collapse | Enforce fallback guards, optional chaining, and explicit empty state handlers |
+| **Network Timeout / Latency** | Hanging operations or duplicate side-effects | Implement bounded abort controllers, exponential backoff, and idempotency keys |
+| **Concurrency / Race Conditions** | Stale state overwrite or inconsistent data mutations | Use atomic transactions, mutex locking, or cancel-on-resubmit controls |
+| **Invalid Schema / Malformed Payload** | Downstream runtime errors or security injection | Validate boundary payloads with Zod/Pydantic schemas prior to execution |
+| **Resource / Memory Saturation** | OOM errors, frame drops, or memory leaks | Clean up listeners, cancel active timers, and enforce pagination/virtualization |
+
+---
+
+## 🤖 LLM-Specific Traps Table
+
+| Anti-Pattern | What AI Commonly Does Wrong | What Is Actually Correct |
+|:---|:---|:---|
+| **Uncontrolled Re-render Loop** | Mutating state inside render bodies or omitting hook dependencies | Wrap effects with explicit deps and isolate reactive derivations in useMemo |
+| **Accessibility Neglect** | Interactive <div> without role="button", tabIndex, or onKeyDown | Use semantic <button> or provide ARIA role, keyboard handlers, and focus ring |
+| **Layout Shift Flash** | Images/dynamic content without aspect-ratio or explicit dimensions | Enforce aspect-ratio or skeleton placeholders to guarantee zero CLS |
+
+---
+
+## 🏛️ Tribunal Verification & Guardrails
+
+**Active Reviewers:** `frontend-reviewer` · `type-safety` · `ui-ux-auditor` · `complexity-reviewer`
+**Slash Command:** `/review` or `/tribunal-full`
+
+### ✅ Pre-Flight Self-Audit Checklist
+
+```
+✅ Are all component props strictly typed with zero implicit "any"?
+✅ Are responsive breakpoints, fluid typography, and optical balance verified?
+✅ Is accessibility (ARIA labels, keyboard focus, contrast) validated?
+✅ Are re-renders minimized and state lifecycles cleanly separated?
+✅ Did I verify all imported UI components and icon sets actually exist?
+```
+
+### 🛑 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 test suites, compiler success, or equivalent operational proof) that your output works as intended.