tribunal-kit 6.0.0 → 6.0.1

package/.agent/skills/duckdb-analytical-sql/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: duckdb-analytical-sql
+description: Embedded OLAP analytics, high-speed Parquet/JSON processing, in-memory analytical SQL, and DuckDB integrations in Node.js, Python, and WASM.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/schema_validator.js
+scripts-binding:
+  - .agent/scripts/schema_validator.js
+skills:
+  - sql-pro
+  - database-design
+  - performance-profiling
+---
+
+# DuckDB Analytical SQL — Embedded Analytics
+
+## Mandatory Pre-Flight Context Inspection
+
+Before writing analytical queries:
+1. Direct File Querying → Query Parquet/CSV/JSON directly without importing into a traditional DB
+2. Memory Allocation → Set explicit memory limit (`SET max_memory = '4GB'`) to prevent OOM
+3. Vectorized Engine Usage → Use column-oriented aggregation over line-by-line loops
+
+## Node.js DuckDB Parquet Query Pattern
+
+```typescript
+import { Database } from 'duckdb-async';
+
+export async function runAnalyticalReport(parquetGlobPath: string) {
+  const db = await Database.create(':memory:');
+  
+  // Set memory limits for embedded execution
+  await db.exec("SET max_memory = '2GB'; SET threads = 4;");
+
+  const rows = await db.all(`
+    SELECT 
+        date_trunc('day', timestamp) as event_day,
+        event_type,
+        COUNT(*) as total_count,
+        QUANTILE_CONT(duration_ms, 0.95) as p95_latency
+    FROM read_parquet(?)
+    GROUP BY 1, 2
+    ORDER BY 1 DESC
+    LIMIT 100
+  `, [parquetGlobPath]);
+
+  return rows;
+}
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Verify query execution on sample Parquet dataset without loading entire file into RAM.
+- Benchmark query throughput against memory constraints.

package/.agent/skills/edge-ai-mobile/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: edge-ai-mobile
+description: On-device mobile AI, CoreML, Android NNAPI, ONNX Runtime Web/Mobile, local LLM execution (SLMs), and sub-10ms privacy-first edge inference.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/bundle_analyzer.js
+scripts-binding:
+  - .agent/scripts/bundle_analyzer.js
+skills:
+  - mobile-developer
+  - browser-native-ai
+  - performance-profiling
+---
+
+# Edge AI & On-Device Mobile Machine Learning
+
+## Mandatory Pre-Flight Context Inspection
+
+Before deploying on-device AI models:
+1. Model Quantization → Use 4-bit/8-bit quantized models (GGUF/ONNX) to fit mobile RAM budgets (<500MB)
+2. Hardware Acceleration → Bind inference engine to Apple Neural Engine (ANE) or Android NPU
+3. Fallback Mechanism → Fall back gracefully to cloud LLM API if local inference exceeds latency budget (>200ms)
+
+## Mobile ONNX Edge Inference Pattern
+
+```typescript
+import * as ort from 'onnxruntime-react-native';
+
+export async function runLocalEmbeddings(textTokens: number[]): Promise<Float32Array> {
+  const session = await ort.InferenceSession.create('model_quantized.onnx', {
+    executionProviders: ['cpu'], // Accelerates via ANE/NNAPI internally
+  });
+
+  const tensor = new ort.Tensor('int64', new BigInt64Array(textTokens.map(BigInt)), [1, textTokens.length]);
+  const feeds = { input_ids: tensor };
+
+  const results = await session.run(feeds);
+  return results.embedding.data as Float32Array;
+}
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Verify local memory usage remains under 300MB during active model inference.
+- Measure battery consumption impact.

package/.agent/skills/expo-router-v4/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: expo-router-v4
+description: React Native 0.76+ New Architecture (Fabric/TurboModules), Expo Router v4 typed file-based navigation, native haptics, and biometrics.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/lint_runner.js
+scripts-binding:
+  - .agent/scripts/lint_runner.js
+skills:
+  - mobile-developer
+  - mobile-design
+  - react-specialist
+---
+
+# Expo Router v4 & React Native New Architecture
+
+## Mandatory Pre-Flight Context Inspection
+
+Before building mobile navigation or components:
+1. New Architecture Enforcement → Enable Fabric renderer and TurboModules in `app.json` (`"newArchEnabled": true`)
+2. Typed Routing → Use `expo-router` typed routes for safe navigation
+3. Safe Area & Haptics → Wrap screens in `SafeAreaView` and provide subtle `expo-haptics` feedback
+
+## Layout Navigation Architecture (`app/_layout.tsx`)
+
+```tsx
+import { Stack } from 'expo-router';
+import { StatusBar } from 'expo-status-bar';
+import { SafeAreaProvider } from 'react-native-safe-area-context';
+
+export default function RootLayout() {
+  return (
+    <SafeAreaProvider>
+      <StatusBar style="light" />
+      <Stack
+        screenOptions={{
+          headerStyle: { backgroundColor: '#0f172a' },
+          headerTintColor: '#f8fafc',
+          animation: 'slide_from_right',
+        }}
+      >
+        <Stack.Screen name="index" options={{ title: 'Feed' }} />
+        <Stack.Screen name="modal" options={{ presentation: 'modal' }} />
+      </Stack>
+    </SafeAreaProvider>
+  );
+}
+```
+
+## Native Haptic Touch Button Component
+
+```tsx
+import * as Haptics from 'expo-haptics';
+import { Pressable, Text, PressableProps } from 'react-native';
+
+interface TouchButtonProps extends PressableProps {
+  label: string;
+}
+
+export function TouchButton({ label, onPress, ...props }: TouchButtonProps) {
+  return (
+    <Pressable
+      {...props}
+      onPress={(e) => {
+        Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light);
+        onPress?.(e);
+      }}
+      className="px-5 py-3 bg-indigo-600 rounded-xl active:scale-95 transition-transform"
+    >
+      <Text className="text-white font-medium text-center">{label}</Text>
+    </Pressable>
+  );
+}
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Verify zero bridge warnings during navigation.
+- Ensure safe area insets are respected across iOS notch and Android gesture bars.

package/.agent/skills/opentelemetry-observability/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: opentelemetry-observability
+description: Full-stack distributed tracing, metrics, OpenTelemetry (OTel), Prometheus, Grafana Tempo, and zero-overhead observability instrumentation.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/test_runner.js
+scripts-binding:
+  - .agent/scripts/test_runner.js
+skills:
+  - devops-engineer
+  - observability
+  - performance-profiling
+---
+
+# OpenTelemetry Observability — 2026 Telemetry Standards
+
+## Mandatory Pre-Flight Context Inspection
+
+Before instrumenting applications:
+1. Vendor-Neutral Telemetry → Use standard OpenTelemetry SDKs (OTLP over gRPC/HTTP)
+2. Trace Propagation → Propagate `traceparent` W3C headers across HTTP and message queues
+3. Sampling Policy → Implement head/tail sampling to reduce telemetry storage costs by 80%
+
+## Custom Trace & Meter Instrumentation (TypeScript)
+
+```typescript
+import { trace, metrics } from '@opentelemetry/api';
+
+const tracer = trace.getTracer('user-service', '1.0.0');
+const meter = metrics.getMeter('user-service', '1.0.0');
+
+const loginCounter = meter.createCounter('user_logins_total', {
+  description: 'Counts total user login attempts',
+});
+
+export async function handleLogin(userId: string) {
+  return tracer.startActiveSpan('handleLogin', async (span) => {
+    try {
+      span.setAttribute('user.id', userId);
+      loginCounter.add(1, { status: 'success' });
+      // Business logic...
+      span.setStatus({ code: 1 }); // OK
+    } catch (err: any) {
+      span.recordException(err);
+      span.setStatus({ code: 2, message: err.message }); // Error
+      throw err;
+    } finally {
+      span.end();
+    }
+  });
+}
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Verify traces connect seamlessly from frontend click to DB query.
+- Confirm telemetry exporter overhead adds < 1ms latency to HTTP handlers.

package/.agent/skills/platform-engineering-opentofu/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: platform-engineering-opentofu
+description: Infrastructure as Code (IaC) with OpenTofu/Terraform/Pulumi, automated cloud provisioning, DevSecOps pipelines, and self-service platform engineering.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/verify_all.js
+scripts-binding:
+  - .agent/scripts/security_scan.js
+  - .agent/scripts/verify_all.js
+skills:
+  - devops-engineer
+  - platform-engineer
+  - cloud-architect
+---
+
+# Platform Engineering & OpenTofu IaC
+
+## Mandatory Pre-Flight Context Inspection
+
+Before provisioning cloud infrastructure:
+1. OpenTofu State Locking → Use remote S3/DynamoDB or backend state locking to prevent concurrency collisions
+2. Least Privilege IAM → Enforce strict role-based access control (RBAC) on all cloud resources
+3. Plan Validation → Run `tofu plan` and static security analysis (tfsec/checkov) before `tofu apply`
+
+## Production AWS VPC & ECS Module Blueprint
+
+```hcl
+terraform {
+  required_version = ">= 1.6.0"
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = "~> 5.0"
+    }
+  }
+}
+
+variable "environment" {
+  type    = string
+  default = "production"
+}
+
+resource "aws_vpc" "main" {
+  cidr_block           = "10.0.0.0/16"
+  enable_dns_hostnames = true
+  enable_dns_support   = true
+
+  tags = {
+    Name        = "vpc-${var.environment}"
+    Environment = var.environment
+    ManagedBy   = "OpenTofu"
+  }
+}
+
+resource "aws_subnet" "public_a" {
+  vpc_id                  = aws_vpc.main.id
+  cidr_block              = "10.0.1.0/24"
+  availability_zone       = "us-east-1a"
+  map_public_ip_on_launch = true
+}
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Run `tofu validate` and security scan before applying changes.
+- Ensure rollback plan is explicitly documented.

package/.agent/skills/playwright-ai-e2e/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: playwright-ai-e2e
+description: Modern Playwright 1.45+ E2E web testing, resilient ARIA locators, visual regression testing, network mocking, and AI-assisted flakiness detection.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/test_runner.js
+scripts-binding:
+  - .agent/scripts/test_runner.js
+  - .agent/scripts/visual_audit.js
+skills:
+  - playwright-best-practices
+  - webapp-testing
+  - testing-patterns
+---
+
+# Playwright AI E2E Testing — 2026 Standards
+
+## Mandatory Pre-Flight Context Inspection
+
+Before writing end-to-end web tests:
+1. ARIA Role Locators → Use accessibility roles (`getByRole`, `getByText`) over brittle CSS selectors
+2. Auto-Waiting & Zero Sleep → Avoid `page.waitForTimeout()`; rely on Playwright built-in auto-waiting
+3. Network Interception → Mock external third-party APIs using `page.route()` for deterministic CI runs
+
+## Resilient E2E API Route Mocking & Interaction Test
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('Dashboard Features', () => {
+  test.beforeEach(async ({ page }) => {
+    // Intercept external analytics API to avoid flaky network calls
+    await page.route('**/api/analytics', async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({ visits: 1042, conversions: 88 }),
+      });
+    });
+  });
+
+  test('user views analytics dashboard', async ({ page }) => {
+    await page.goto('/dashboard');
+    
+    // Resilient ARIA locators
+    const heading = page.getByRole('heading', { name: 'Analytics' });
+    await expect(heading).toBeVisible();
+
+    const visitsText = page.getByText('1042');
+    await expect(visitsText).toBeVisible();
+  });
+});
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Run Playwright test suite in headless mode and verify zero flakiness.
+- Ensure all interactive elements rely on resilient locators.

package/.agent/skills/property-based-testing/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: property-based-testing
+description: Generative input invariant testing using fast-check (TS/JS) and hypothesis (Python) to uncover hidden edge cases and boundary failures.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/test_runner.js
+scripts-binding:
+  - .agent/scripts/test_runner.js
+  - .agent/scripts/inner_loop_validator.js
+skills:
+  - testing-patterns
+  - tdd-workflow
+  - clean-code
+---
+
+# Property-Based Testing — Invariant Verification
+
+## Mandatory Pre-Flight Context Inspection
+
+Before writing property tests:
+1. Invariant Identification → Define mathematical properties that must hold true for ALL inputs (e.g. `reverse(reverse(list)) == list`)
+2. Arbitrary Generator Scoping → Constrain generator bounds to domain validity (e.g. non-empty strings, positive integers)
+3. Shrinking & Reproducibility → Store seed values for failing test runs to reproduce minimal failing inputs
+
+## Fast-Check Arbitrary Generator & Vitest Invariant Test
+
+```typescript
+import fc from 'fast-check';
+import { test, expect } from 'vitest';
+
+function parseAmount(currencyStr: string): number | null {
+  const cleaned = currencyStr.replace(/[^0-9.]/g, '');
+  const num = parseFloat(cleaned);
+  return isNaN(num) ? null : num;
+}
+
+test('currency parser invariant: non-negative parsed numbers', () => {
+  fc.assert(
+    fc.property(
+      fc.tuple(fc.string(), fc.double({ min: 0, max: 1000000 })),
+      ([prefix, val]) => {
+        const input = `${prefix}$${val.toFixed(2)}`;
+        const parsed = parseAmount(input);
+        
+        if (parsed !== null) {
+          expect(parsed).toBeGreaterThanOrEqual(0);
+          expect(Number.isFinite(parsed)).toBe(true);
+        }
+      }
+    ),
+    { numRuns: 500 } // Execute 500 generative iterations
+  );
+});
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Run minimum 100 iterations per property test run.
+- Confirm shrinking mechanism isolates minimal failing counter-example on assertion failure.

package/.agent/skills/vector-search-pgvector/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: vector-search-pgvector
+description: Production vector database search using pgvector 0.8.0+, halfvec, sparsevec, Pinecone, Weaviate, hybrid sparse-dense retrieval, and iterative HNSW scanning.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/schema_validator.js
+scripts-binding:
+  - .agent/scripts/schema_validator.js
+skills:
+  - database-architect
+  - sql-pro
+  - advanced-rag-pipelines
+---
+
+# Vector Search & pgvector 0.8.0+ — 2026 Database Standards
+
+## Mandatory Pre-Flight Context Inspection
+
+Before creating vector tables or indexes:
+1. Index Type & Precision → Use `halfvec` (half-precision) for 50% RAM savings on HNSW indexes; use `sparsevec` for high-dimensional sparse vectors
+2. Iterative Index Scans (pgvector 0.8.0+) → Enable iterative scanning to prevent HNSW overfiltering when combining `WHERE` clauses with vector similarity
+3. Hybrid Search Strategy → Combine BM25 full-text search with dense vector similarity via Reciprocal Rank Fusion (RRF)
+
+## High-Performance pgvector 0.8.0+ Schema (`halfvec` + HNSW)
+
+```sql
+CREATE EXTENSION IF NOT EXISTS vector;
+
+CREATE TABLE document_chunks (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    document_id UUID NOT NULL,
+    chunk_index INT NOT NULL,
+    content TEXT NOT NULL,
+    fts_vector tsvector GENERATED ALWAYS AS (to_tsvector('english', content)) STORED,
+    embedding halfvec(1536) NOT NULL  -- 50% memory reduction vs float4 vector
+);
+
+-- HNSW index using halfvec with iterative scanning support (pgvector 0.8.0+)
+CREATE INDEX idx_chunks_embedding_hnsw 
+ON document_chunks USING hnsw (embedding halfvec_cosine_ops)
+WITH (m = 16, ef_construction = 64);
+
+-- Full text search GIN index
+CREATE INDEX idx_chunks_fts ON document_chunks USING gin (fts_vector);
+```
+
+## Hybrid Search Query (pgvector 0.8.0+ Iterative Scan + RRF)
+
+```sql
+-- pgvector 0.8.0+ automatically performs iterative prober scans when filtering
+WITH vector_search AS (
+    SELECT id, content, ROW_NUMBER() OVER (ORDER BY embedding <=> $1::halfvec) as rank
+    FROM document_chunks
+    WHERE document_id = $3  -- Iterative scan prevents overfiltering
+    LIMIT 20
+),
+fts_search AS (
+    SELECT id, content, ROW_NUMBER() OVER (ORDER BY ts_rank(fts_vector, websearch_to_tsquery($2)) DESC) as rank
+    FROM document_chunks
+    WHERE fts_vector @@ websearch_to_tsquery($2) AND document_id = $3
+    LIMIT 20
+)
+SELECT 
+    COALESCE(v.id, f.id) as id,
+    COALESCE(v.content, f.content) as content,
+    COALESCE(1.0 / (60 + v.rank), 0.0) + COALESCE(1.0 / (60 + f.rank), 0.0) as rrf_score
+FROM vector_search v
+FULL OUTER JOIN fts_search f ON v.id = f.id
+ORDER BY rrf_score DESC
+LIMIT 10;
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Verify vector index construction queries pass `EXPLAIN ANALYZE` with `halfvec`.
+- Confirm pgvector extension version is >= 0.8.0 for iterative scanning support.

package/.agent/skills/zero-trust-passkeys/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: zero-trust-passkeys
+description: Modern passwordless authentication using WebAuthn, FIDO2 biometric passkeys, SimpleWebAuthn v13+, Conditional UI (Passkey Autofill), and Zero-Trust security.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/security_scan.js
+scripts-binding:
+  - .agent/scripts/security_scan.js
+skills:
+  - authentication-best-practices
+  - backend-security-expert
+  - frontend-security-expert
+---
+
+# Zero-Trust Passkeys & WebAuthn (SimpleWebAuthn v13+)
+
+## Mandatory Pre-Flight Context Inspection
+
+Before implementing auth flows:
+1. Conditional UI (Passkey Autofill) → Use `useBrowserAutofill: true` and `autocomplete="username webauthn"` for seamless form autofill
+2. Feature Detection & Abort Signals → Check `isConditionalMediationAvailable()` and manage cancellation via `AbortController`
+3. Discoverable Credentials → Ensure `userVerification` and resident key options are enabled on registration
+
+## Client-Side Passkey Autofill Pattern (SimpleWebAuthn v13 Browser)
+
+```typescript
+import { 
+  startAuthentication, 
+  isConditionalMediationAvailable 
+} from '@simplewebauthn/browser';
+
+export async function initConditionalPasskeyAutofill(abortSignal: AbortSignal) {
+  const isAvailable = await isConditionalMediationAvailable();
+  if (!isAvailable) return;
+
+  try {
+    // 1. Fetch options from server
+    const res = await fetch('/api/auth/generate-authentication-options');
+    const options = await res.json();
+
+    // 2. Trigger browser native autofill dropdown
+    const credential = await startAuthentication({
+      optionsJSON: options,
+      useBrowserAutofill: true,
+    });
+
+    // 3. Send response to server for verification
+    await fetch('/api/auth/verify-authentication', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(credential),
+    });
+  } catch (err: any) {
+    if (err.name !== 'AbortError') console.error('Passkey autofill error:', err);
+  }
+}
+```
+
+## Server Verification Pattern (SimpleWebAuthn v13 Server)
+
+```typescript
+import { verifyAuthenticationResponse, generateAuthenticationOptions } from '@simplewebauthn/server';
+
+export async function verifyPasskeyAuth(body: any, expectedChallenge: string, userPublicKey: Uint8Array) {
+  const verification = await verifyAuthenticationResponse({
+    response: body,
+    expectedChallenge,
+    expectedOrigin: process.env.APP_ORIGIN!,
+    expectedRPID: process.env.RP_ID!,
+    credential: {
+      id: body.id,
+      publicKey: userPublicKey,
+      counter: body.counter || 0,
+    },
+  });
+
+  return verification.verified;
+}
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Verify input tags have `autocomplete="username webauthn"`.
+- Test passkey autofill flow with `AbortController` cancellation.

package/.agent/workflows/tribunal-full.md

@@ -47,36 +47,36 @@ Before launching the full 21-reviewer audit, you MUST inspect:
 
 ---
 
-## 21 Reviewers — All Active Simultaneously
+## 21 Reviewers — Stage-Partitioned Execution (3 Waves)
+
+To eliminate context window saturation and reviewer attention dilution, the 21 reviewers execute in 3 partitioned passes:
 
 ```
-Tier 1: Always active (universal concerns)
+Wave 1: Core Integrity & Precedences (Pass 1)
 ├── precedence-reviewer    → Checks local repo Case Law for past rejections
 ├── logic-reviewer         → Hallucinated methods, impossible logic, undefined refs
-├── security-auditor       → OWASP 2025, injection, JWT, SSRF, IDOR
+├── schema-reviewer        → Missing input validation, loose schemas, raw req.body
 └── resilience-reviewer    → Swallowed errors, unhandled rejections, missing retries
 
-Tier 2: Code quality
+Wave 2: Security, Types & Code Quality (Pass 2)
+├── security-auditor       → OWASP 2025, injection, JWT, SSRF, IDOR
 ├── dependency-reviewer    → Fabricated packages, supply chain, version compatibility
 ├── type-safety-reviewer   → 'any' epidemic, Zod parse vs cast, unguarded access
 ├── complexity-reviewer    → Enforces the Dependency Ladder to prevent over-engineering
-├── schema-reviewer        → Missing input validation, loose schemas, raw req.body
 └── sql-reviewer           → Injection, N+1, missing indexes, unscoped mutations
 
-Tier 3: Domain-specific
+Wave 3: Domain, UI & Performance (Pass 3)
 ├── frontend-reviewer      → React 19 APIs, RSC violations, hook rules, hydration
-├── performance-reviewer   → 2026 CWV targets, re-render cascades, memory leaks
+├── performance-reviewer   → Core Web Vitals targets, re-render cascades, memory leaks
 ├── mobile-reviewer        → Reanimated thread safety, FlashList, safe area insets
 ├── ai-code-reviewer       → Model name hallucinations, prompt injection, cost explosion
 ├── test-coverage-reviewer → Happy path only, brittle selectors, missing edge cases
 ├── accessibility-reviewer → WCAG 2.2 AA, ARIA misuse, focus management, live regions
 ├── ui-ux-auditor          → Generic AI aesthetics, missing hover states, contrast
-└── review-animations      → UI animations >300ms, origin-unaware popovers, ease-in
-
-Tier 4: Performance Swarm (token-scoped specialists)
-├── vitals-reviewer        → Frontend CWV depth: Suspense waterfalls, paint jank, animation leaks
-├── db-latency-auditor     → DB layer: N+1, unbounded queries, unindexed WHERE, pool config
-└── throughput-optimizer   → Server runtime: event-loop blocks, serialized awaits, memory leaks
+├── review-animations      → UI animations >300ms, origin-unaware popovers, ease-in
+├── vitals-reviewer        → Frontend CWV depth: Suspense waterfalls, paint jank
+├── db-latency-auditor     → DB layer: N+1, unbounded queries, unindexed WHERE
+└── throughput-optimizer   → Server runtime: event-loop blocks, serialized awaits
 ```
 
 ---