tribunal-kit 5.8.5 → 6.0.1

package/.agent/scripts/socratic_gate_policy.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * socratic_gate_policy.js — Adaptive Socratic Gate Evaluator
+ * =============================================================
+ * Determines whether the Socratic Gate should block execution with interactive questions.
+ *
+ * Rules:
+ *   - Tier 0 & Tier 1: Always BYPASS Socratic Gate (0 blocking questions).
+ *   - Tier 2: Bypass UNLESS Ambiguity Score > 0.5 or explicit ambiguities are present.
+ *   - Tier 3: Trigger Socratic Gate unless explicitly overridden with --no-gate or --express.
+ */
+
+"use strict";
+
+const { parseArgs } = require("./_utils");
+
+/**
+ * Evaluates whether the Socratic Gate should be engaged.
+ * @param {Object} opts - Options { tier, ambiguityScore, flags, task }
+ * @returns {Object} { shouldBlock, reason }
+ */
+function evaluateSocraticGate(opts = {}) {
+  const tier = typeof opts.tier === "number" ? opts.tier : 1;
+  const ambiguityScore = typeof opts.ambiguityScore === "number" ? opts.ambiguityScore : 0.2;
+  const flags = opts.flags || {};
+
+  if (flags["no-gate"] || flags.express || flags.force) {
+    return { shouldBlock: false, reason: "Explicit user override (--no-gate / --express)" };
+  }
+
+  if (tier === 0) {
+    return { shouldBlock: false, reason: "Tier 0 Fast-Pass (low impact)" };
+  }
+
+  if (tier === 1) {
+    return { shouldBlock: false, reason: "Tier 1 Express Pass (single component / logic edit)" };
+  }
+
+  if (tier === 2) {
+    if (ambiguityScore > 0.5) {
+      return { shouldBlock: true, reason: `Tier 2 ambiguity exceeds threshold (${ambiguityScore} > 0.5)` };
+    }
+    return { shouldBlock: false, reason: "Tier 2 low-ambiguity edit (gate bypassed)" };
+  }
+
+  // Tier 3
+  return { shouldBlock: true, reason: "Tier 3 Full Gauntlet (high risk / architectural change)" };
+}
+
+if (require.main === module) {
+  const args = parseArgs(process.argv);
+  const result = evaluateSocraticGate({
+    tier: args.tier ? parseInt(args.tier, 10) : 1,
+    ambiguityScore: args.ambiguity ? parseFloat(args.ambiguity) : 0.2,
+    flags: args
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+module.exports = { evaluateSocraticGate };

package/.agent/scripts/token_budget_broker.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * token_budget_broker.js — Token Budget & Persona Optimizer
+ * ============================================================
+ * Calculates and caps context window budgets based on Governance Impact Tiers.
+ *
+ * Tier Budgets:
+ *   - Tier 0: 0 tokens (No LLM call required)
+ *   - Tier 1: Max 2,000 tokens (diff context + 1 skill rule)
+ *   - Tier 2: Max 8,000 tokens (diff + 2 skill rules + context summary)
+ *   - Tier 3: Full budget (up to model context limit)
+ */
+
+"use strict";
+
+const { parseArgs } = require("./_utils");
+
+const TIER_TOKEN_LIMITS = {
+  0: 0,
+  1: 2000,
+  2: 8000,
+  3: 32000
+};
+
+/**
+ * Returns context budget constraints for a given impact tier
+ * @param {number} tier - Governance Impact Tier (0-3)
+ * @returns {Object} { maxTokens, includeFullRepo, maxSkills, maxReviewers }
+ */
+function getTokenBudget(tier = 1) {
+  // Normalize tier to a valid integer in [0, 3]
+  const normalizedTier = (typeof tier === "number" && Number.isFinite(tier))
+    ? Math.max(0, Math.min(3, Math.round(tier)))
+    : 1;
+  const maxTokens = TIER_TOKEN_LIMITS[normalizedTier];
+
+  return {
+    tier: normalizedTier,
+    maxTokens,
+    includeFullRepo: normalizedTier >= 2,
+    maxSkills: normalizedTier === 0 ? 0 : normalizedTier === 1 ? 1 : normalizedTier === 2 ? 3 : 10,
+    maxReviewers: normalizedTier === 0 ? 0 : normalizedTier === 1 ? 1 : normalizedTier === 2 ? 2 : 8
+  };
+}
+
+if (require.main === module) {
+  const args = parseArgs(process.argv);
+  const tier = args.tier ? parseInt(args.tier, 10) : 1;
+  console.log(JSON.stringify(getTokenBudget(tier), null, 2));
+}
+
+module.exports = { getTokenBudget, TIER_TOKEN_LIMITS };

package/.agent/scripts/verify_all.js

@@ -213,6 +213,19 @@ function verifyAll(cwd, skipped) {
     trackSkip("Dependency audit", "skipped by flag");
   }
 
+  console.log(sectionHeader("Rust Core Tests", 7));
+  if (!skipped.includes("rust")) {
+    const cargoToml = path.join(cwd, "crates", "core", "Cargo.toml");
+    if (fs.existsSync(cargoToml)) {
+      if (!run("Rust Core Tests", ["cargo", "test", "--manifest-path", "crates/core/Cargo.toml"], cwd))
+        failures++;
+    } else {
+      trackSkip("Rust Core Tests", "crates/core/Cargo.toml not found in project");
+    }
+  } else {
+    trackSkip("Rust Core Tests", "skipped by flag");
+  }
+
   // ━━━ Summary Table ━━━
   const totalMs = totalTimer();
   console.log(`\n${BOLD}${CYAN}━━━ Verification Summary ━━━${RESET}`);

package/.agent/scripts/visual_audit.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * visual_audit.js — Visual Design & UI Engineering Auditor
+ *
+ * Verifies OKLCH color compliance, surface depth layering (hairline borders, ambient shadows),
+ * and interactive state polish on UI components and style definitions.
+ *
+ * Usage:
+ *   node .agent/scripts/visual_audit.js .
+ *   node .agent/scripts/visual_audit.js --file src/components/Button.tsx
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const {
+  GREEN,
+  YELLOW,
+  BOLD,
+  DIM,
+  RESET,
+  banner,
+  timer,
+  formatMs,
+} = require("./_colors");
+
+const { walkDir, SOURCE_EXTENSIONS } = require("./_utils");
+
+function auditFile(filePath) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return [];
+  }
+
+  const issues = [];
+  const lines = content.split("\n");
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Check for hardcoded hex colors when oklch or CSS variables are expected
+    if (/#([0-9a-fA-F]{3}){1,2}\b/.test(line) && !line.includes("// ignore-color")) {
+      issues.push({
+        line: i + 1,
+        rule: "oklch-color",
+        message: `Hardcoded hex color found: "${line.trim()}". Prefer OKLCH or design token CSS variables.`,
+      });
+    }
+  }
+
+  return issues;
+}
+
+function main() {
+  const cwd = process.cwd();
+  const elapsed = timer();
+
+  console.log(banner("visual_audit.js", { Target: cwd }));
+
+  const files = walkDir(cwd, { extensions: SOURCE_EXTENSIONS });
+  let totalIssues = 0;
+
+  for (const file of files) {
+    const issues = auditFile(file);
+    if (issues.length > 0) {
+      totalIssues += issues.length;
+      const rel = path.relative(cwd, file);
+      console.log(`\n  📄 ${BOLD}${rel}${RESET}`);
+      for (const iss of issues) {
+        console.log(`     ${YELLOW}⚠ line ${iss.line}:${RESET} ${iss.message}`);
+      }
+    }
+  }
+
+  console.log(`\n  ${DIM}Audited ${files.length} files in ${formatMs(elapsed())}${RESET}`);
+
+  if (totalIssues === 0) {
+    console.log(`  ${GREEN}${BOLD}✔ Visual audit complete — zero design violations found.${RESET}\n`);
+  } else {
+    console.log(`  ${YELLOW}${BOLD}⚠ Visual audit completed with ${totalIssues} advisory issue(s).${RESET}\n`);
+  }
+}
+
+module.exports = { auditFile };
+
+if (require.main === module) {
+  main();
+}

package/.agent/skill_topic_map.json

@@ -0,0 +1,218 @@
+{
+  "version": "3.0.0",
+  "total_skills": 183,
+  "description": "Lightweight 2-tier domain routing map for Tribunal Agent Kit v3.0.0",
+  "domain_routes": {
+    "frontend": [
+      "react-specialist",
+      "nextjs-react-expert",
+      "vue-expert",
+      "frontend-design",
+      "better-ui",
+      "baseline-ui",
+      "impeccable",
+      "taste-skill",
+      "gpt-taste",
+      "product-aware-heuristics",
+      "swiss-design",
+      "typeset",
+      "better-colors",
+      "colorize",
+      "delight",
+      "whimsy-injector",
+      "compact-landing",
+      "landing-page",
+      "pricing-page",
+      "company-logos",
+      "ui-reasoning-engine",
+      "ui-skill-packs",
+      "ui-skills-root",
+      "ui-ux-pro-max",
+      "ui-ux-researcher",
+      "critique",
+      "bolder",
+      "quieter",
+      "polish",
+      "harden",
+      "distill",
+      "clarify",
+      "shape",
+      "redesign-skill",
+      "improve-ui",
+      "create-design-md",
+      "extract-design-system",
+      "appflow-wireframe",
+      "apple-design",
+      "shadcn-ui-expert",
+      "tailwind-patterns",
+      "building-native-ui"
+    ],
+    "motion": [
+      "12-principles-of-animation",
+      "60fps-animation",
+      "accessible-animation",
+      "animation-on-scroll",
+      "animation-systems",
+      "framer-motion-expert",
+      "gsap-core",
+      "gsap-frameworks",
+      "gsap-performance",
+      "gsap-plugins",
+      "gsap-react",
+      "gsap-scrolltrigger",
+      "gsap-timeline",
+      "gsap-utils",
+      "lottie-animation",
+      "marquee-loop",
+      "masked-reveal",
+      "micro-interaction",
+      "morphing-icons",
+      "motion-engineering",
+      "page-transition-animation",
+      "progressive-blur",
+      "review-animations",
+      "sounds-on-the-web",
+      "svg-animation",
+      "to-spring-or-not-to-spring",
+      "transitions-dev",
+      "fixing-motion-performance"
+    ],
+    "backend": [
+      "backend-security-expert",
+      "api-patterns",
+      "api-security-auditor",
+      "nodejs-best-practices",
+      "python-pro",
+      "python-patterns",
+      "rust-pro",
+      "csharp-developer",
+      "edge-computing",
+      "browser-native-ai",
+      "llm-engineering",
+      "advanced-rag-pipelines",
+      "generative-ui-expert",
+      "realtime-patterns",
+      "context-engineering-pro",
+      "agentic-workflows-2026"
+    ],
+    "database": [
+      "database-architect",
+      "database-design",
+      "sql-pro",
+      "supabase-postgres-best-practices",
+      "domain-modeling",
+      "data-validation-schemas",
+      "vector-search-pgvector",
+      "duckdb-analytical-sql"
+    ],
+    "mobile": [
+      "mobile-developer",
+      "mobile-design",
+      "swiftui-expert",
+      "expo-router-v4",
+      "edge-ai-mobile"
+    ],
+    "devops": [
+      "devops-engineer",
+      "devops-incident-responder",
+      "platform-engineer",
+      "cloud-architect",
+      "containerization-pro",
+      "server-management",
+      "bash-linux",
+      "powershell-windows",
+      "cicd-pro",
+      "deployment-procedures",
+      "platform-engineering-opentofu",
+      "opentelemetry-observability"
+    ],
+    "security": [
+      "ai-prompt-injection-defense",
+      "frontend-security-expert",
+      "red-team-tactics",
+      "vulnerability-scanner",
+      "web-accessibility-auditor",
+      "fixing-accessibility",
+      "fixing-metadata",
+      "web-design-guidelines",
+      "web-quality-audit",
+      "audit-and-fix",
+      "lint-and-validate",
+      "clean-code",
+      "code-review-checklist",
+      "thermo-nuclear-code-quality-review",
+      "zero-trust-passkeys",
+      "ai-app-hardening"
+    ],
+    "testing": [
+      "testing-patterns",
+      "webapp-testing",
+      "playwright-best-practices",
+      "tdd-workflow",
+      "test-result-analyzer",
+      "playwright-ai-e2e",
+      "property-based-testing"
+    ],
+    "meta": [
+      "agent-organizer",
+      "agentic-patterns",
+      "app-builder",
+      "architecture",
+      "behavioral-modes",
+      "brainstorming",
+      "codebase-design",
+      "fabel-protocol",
+      "harness-protocol",
+      "i18n-localization",
+      "improve-codebase-architecture",
+      "intelligent-routing",
+      "knowledge-graph",
+      "local-first",
+      "local-first-architecture",
+      "mcp-builder",
+      "monorepo-management",
+      "observability",
+      "parallel-agents",
+      "performance-profiling",
+      "plan-writing",
+      "project-idioms",
+      "readme-builder",
+      "seo-fundamentals",
+      "skill-creator",
+      "system-design-pro",
+      "systematic-debugging",
+      "thinking-protocol",
+      "trend-researcher",
+      "typescript-advanced",
+      "webgpu-performance",
+      "workflow-optimizer",
+      "cobejs",
+      "diagnosing-bugs",
+      "antfu-conventions",
+      "documentation-templates",
+      "emil-design-eng",
+      "geo-fundamentals",
+      "git-pro",
+      "github-operations",
+      "design-lab"
+    ]
+  },
+  "file_extensions": {
+    ".tsx": ["react-specialist", "nextjs-react-expert", "frontend-design", "better-ui", "expo-router-v4", "playwright-ai-e2e"],
+    ".ts": ["typescript-advanced", "clean-code", "lint-and-validate", "opentelemetry-observability", "property-based-testing"],
+    ".jsx": ["react-specialist", "frontend-design"],
+    ".js": ["nodejs-best-practices", "clean-code", "opentelemetry-observability"],
+    ".vue": ["vue-expert", "frontend-design"],
+    ".py": ["python-pro", "python-patterns", "duckdb-analytical-sql", "property-based-testing"],
+    ".rs": ["rust-pro"],
+    ".cs": ["csharp-developer"],
+    ".sql": ["sql-pro", "database-architect", "supabase-postgres-best-practices", "vector-search-pgvector", "duckdb-analytical-sql"],
+    ".prisma": ["database-architect", "database-design", "vector-search-pgvector"],
+    ".css": ["frontend-design", "better-colors", "better-typography", "swiss-design"],
+    ".sh": ["bash-linux"],
+    ".ps1": ["powershell-windows"],
+    ".swift": ["swiftui-expert", "mobile-developer", "edge-ai-mobile"],
+    ".tf": ["platform-engineering-opentofu"],
+    ".tofu": ["platform-engineering-opentofu"]
+  }
+}

package/.agent/skills/12-principles-of-animation/SKILL.md

@@ -1,20 +1,29 @@
 ---
 name: 12-principles-of-animation
 description: Application of Disney's 12 Principles of Animation (Squash & Stretch, Anticipation, Staging, Follow Through, Slow In & Slow Out, Arc, Secondary Action, Timing, Exaggeration, Solid Drawing, Appeal) to modern web UI motion.
-version: 1.0.0
-last-updated: 2026-07-22
-applies-to-model: gemini-3-6-flash, claude-3-7-sonnet
-routing:
-  domain: UI Animation Theory & Disney Principles
-  tier: pro
-  co-requires: [emil-design-eng, motion-engineering, 60fps-animation]
-  trigger-signals:
-    strong: [12-principles-of-animation, Disney animation principles, squash and stretch UI, anticipation animation, staging UI motion, follow through web]
-    weak: [animation principles, ui animation theory]
+version: 3.0.0
+last-updated: 2026-07-30
+skills:
+  - motion-engineering
+  - 60fps-animation
+  - accessible-animation
+tools: Read, Grep, Glob, Bash, Edit, Write
+scripts-binding:
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
 ---
 
 # 12 Principles of Animation — Web UI Motion Theory
 
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Before applying animation principles to web components, you MUST inspect:
+1. Target interaction pattern → Identify applicability of Squash & Stretch, Anticipation, Slow In/Out, or Follow Through
+2. Volume-Preservation Rule (Section 26) → Keep UI squash/stretch subtle (max 2%-4%); if height scales to 0.97, width MUST scale to 1.03
+3. Staging Rules (Section 31) → Direct user focus with sequential motion rather than competing simultaneous animations
+
 Translate Disney's 12 classic principles of animation into modern CSS, Web API, and Framer Motion code patterns.
 
 ---

package/.agent/skills/60fps-animation/SKILL.md

@@ -1,20 +1,29 @@
 ---
 name: 60fps-animation
 description: Web animation performance guidance for avoiding layout thrashing, achieving 60/120fps motion, and using GPU compositor-friendly properties (transform, opacity).
-version: 1.0.0
-last-updated: 2026-07-22
-applies-to-model: gemini-3-6-flash, claude-3-7-sonnet
-routing:
-  domain: Animation Performance & GPU Hardware Acceleration
-  tier: pro
-  co-requires: [fixing-motion-performance, framer-motion-expert, gsap-performance]
-  trigger-signals:
-    strong: [60fps-animation, animation performance, layout thrashing, compositor properties, GPU acceleration, 120fps animation, smooth motion]
-    weak: [fast animation, fix laggy animation]
+version: 3.0.0
+last-updated: 2026-07-30
+skills:
+  - motion-engineering
+  - accessible-animation
+  - fixing-motion-performance
+tools: Read, Grep, Glob, Bash, Edit, Write
+scripts-binding:
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
 ---
 
 # 60fps Animation — GPU Compositor & High-Performance Motion
 
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Before writing animation CSS or JS, you MUST inspect:
+1. Target animated properties → Strictly enforce GPU compositor-only properties (`transform`, `opacity`) and ban layout-triggering properties (`width`, `height`, `top`, `left`)
+2. Scale Math Replacement (Section 29) → Use `transform: scaleX(2)` instead of animating `width`
+3. `will-change` VRAM Management (Section 45) → Apply `will-change` dynamically during active animation and remove upon completion
+
 Eliminate jank, layout thrashing, and frame drops to achieve locked 60fps / 120fps UI animations.
 
 ---

package/.agent/skills/accessible-animation/SKILL.md

@@ -1,20 +1,29 @@
 ---
 name: accessible-animation
 description: Tiered reduced-motion patterns for CSS, GSAP, Framer Motion, Lenis, and View Transitions API to ensure full WCAG 2.2 accessibility compliance for motion.
-version: 1.0.0
-last-updated: 2026-07-22
-applies-to-model: gemini-3-6-flash, claude-3-7-sonnet
-routing:
-  domain: Accessible Motion & Reduced Motion Patterns
-  tier: pro
-  co-requires: [web-accessibility-auditor, framer-motion-expert, 60fps-animation]
-  trigger-signals:
-    strong: [accessible-animation, prefers-reduced-motion, accessible motion, WCAG animation, motion accessibility]
-    weak: [disable animation, reduced motion]
+version: 3.0.0
+last-updated: 2026-07-30
+skills:
+  - 60fps-animation
+  - motion-engineering
+  - framer-motion-expert
+tools: Read, Grep, Glob, Bash, Edit, Write
+scripts-binding:
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
 ---
 
 # Accessible Animation — Tiered Reduced-Motion Patterns
 
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Before implementing UI animation code, you MUST inspect:
+1. CSS stylesheets → Verify presence of `@media (prefers-reduced-motion: reduce)` rules
+2. Framer Motion / GSAP components → Query `useReducedMotion()` or `matchMedia('(prefers-reduced-motion: reduce)')`
+3. Vestibular Trigger Replacement (Section 57) → Replace parallax scroll and 3D rotations with instant opacity cross-fades (`0 -> 1`)
+
 Ensure UI motion respects user accessibility preferences (`prefers-reduced-motion: reduce`) without stripping functional state updates.
 
 ---

package/.agent/skills/adapt/SKILL.md

@@ -1,20 +1,29 @@
 ---
 name: adapt
 description: Adapt designs across breakpoints, devices, platform constraints, touch vs mouse input, and container queries. Use when making a UI responsive or optimizing for mobile/tablet.
-version: 1.0.0
-last-updated: 2026-07-22
-applies-to-model: gemini-3-6-flash, claude-3-7-sonnet
-routing:
-  domain: Responsive Design & Cross-Device Adaptation
-  tier: pro
-  co-requires: [mobile-design, building-native-ui]
-  trigger-signals:
-    strong: [adapt, responsive design, container queries, mobile adaptation, responsive layout, touch target size, responsive breakpoints]
-    weak: [mobile friendly, responsive UI]
+version: 3.0.0
+last-updated: 2026-07-30
+skills:
+  - mobile-design
+  - building-native-ui
+  - tailwind-patterns
+tools: Read, Grep, Glob, Bash, Edit, Write
+scripts-binding:
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
 ---
 
 # Adapt — Responsive Adaptation & Container Queries
 
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Before engineering responsive layouts or cross-device UIs, you MUST inspect:
+1. Container Queries (`@container`) over Viewport Media Queries (Section 24) → Adapt component layouts based on parent container width (`container-type: inline-size`)
+2. Touch Target Sizing (Section 39) → Ensure interactive controls meet min `44x44px` target size on touch devices
+3. Fluid Clamp Scaling (Section 45) → Use `clamp()` for smooth fluid typography and spacing without abrupt media query jumps
+
 Architect UIs that adapt fluidly to screen dimensions, container boundaries, input devices (touch vs pointer), and orientation.
 
 ---

package/.agent/skills/advanced-rag-pipelines/SKILL.md

@@ -1,13 +1,31 @@
 ---
 name: advanced-rag-pipelines
 description: Production-grade Retrieval-Augmented Generation (RAG) mastery. Semantic chunking, Hybrid Search (Dense + Sparse/BM25), Cross-Encoder Reranking, and architecture-agnostic vector database management.
-routing:
-  domain: general
-  tier: basic
+tools: Read, Grep, Glob, Bash, Edit, Write
+version: 3.0.0
+last-updated: 2026-07-30
+skills:
+  - llm-engineering
+  - ai-prompt-injection-defense
+  - database-design
+scripts-binding:
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
 ---
 
 # Advanced RAG Pipelines (Production AI Data)
 
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Before building RAG pipelines or vector search components, you MUST inspect:
+1. Hybrid Search Requirement (Section 16) → Always combine Dense Vector Search with Sparse BM25 Search to catch exact keyword matches (IDs, versions)
+2. Two-Stage Reranking Pipeline (Section 29) → Retrieve top ~50 candidate chunks, then rerank with a Cross-Encoder down to top 3-5 before feeding the LLM
+3. Context XML Framing (Section 59) → Wrap retrieved chunks inside explicit `<context>` XML tags in the prompt to prevent indirect prompt injection
+
+# Advanced RAG Pipelines (Production AI Data)
+
 You are an expert in building production-grade Retrieval-Augmented Generation (RAG) data pipelines. You understand that naive RAG (fixed chunking + Cosine similarity) fails in production. You architect systems that retrieve context with high precision using hybrid search, reranking, and semantic strategies.
 
 ## 1. Core Principles

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

@@ -1,15 +1,29 @@
 ---
 name: agent-organizer
 description: Master Agent orchestration framework. Coordination of sub-agents, workflow definitions, delegation patterns, state management across conversations, memory distillation, and execution loops. Use when assembling multi-agent systems or managing complex agent-to-agent architectures.
-allowed-tools: Read, Write, Edit, Glob, Grep
-version: 2.0.0
-last-updated: 2026-04-02
-applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
-routing:
-  domain: general
-  tier: basic
+tools: Read, Grep, Glob, Bash, Edit, Write
+version: 3.0.0
+last-updated: 2026-07-30
+skills:
+  - parallel-agents
+  - fabel-protocol
+  - agentic-patterns
+scripts-binding:
+  - .agent/scripts/swarm_dispatcher.js
+  - .agent/scripts/verify_all.js
 ---
 
+# Agent Organizer — Multi-Agent Orchestration Mastery
+
+---
+
+## Mandatory Pre-Flight Context Inspection
+
+Before dispatching multi-agent tasks, you MUST inspect:
+1. `swarm-worker-registry.md` / `task.md` → Verify target worker agents and global execution state
+2. Context Window Budget rules (Section 1) → Trim worker payload context to max 3 files per dispatch
+3. Handoff state signals (`COMPLETE`, `BLOCKED`, `ERROR`) → Verify terminal status handling rules
+
 ## Hallucination Traps (Read First)
 
 - ❌ Dispatching sub-agents without a context_summary -> ✅ Always send a trimmed context, never the full conversation