npm - tribunal-kit - Versions diffs - 2.4.6 → 3.0.0 - Mend

tribunal-kit 2.4.6 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (142) hide show

package/.agent/agents/accessibility-reviewer.md +220 -134
package/.agent/agents/ai-code-reviewer.md +233 -129
package/.agent/agents/backend-specialist.md +238 -178
package/.agent/agents/code-archaeologist.md +181 -119
package/.agent/agents/database-architect.md +207 -164
package/.agent/agents/debugger.md +218 -151
package/.agent/agents/dependency-reviewer.md +136 -55
package/.agent/agents/devops-engineer.md +238 -175
package/.agent/agents/documentation-writer.md +221 -137
package/.agent/agents/explorer-agent.md +180 -142
package/.agent/agents/frontend-reviewer.md +194 -80
package/.agent/agents/frontend-specialist.md +237 -188
package/.agent/agents/game-developer.md +52 -184
package/.agent/agents/logic-reviewer.md +149 -78
package/.agent/agents/mobile-developer.md +223 -152
package/.agent/agents/mobile-reviewer.md +195 -79
package/.agent/agents/orchestrator.md +211 -170
package/.agent/agents/penetration-tester.md +174 -131
package/.agent/agents/performance-optimizer.md +203 -139
package/.agent/agents/performance-reviewer.md +211 -108
package/.agent/agents/product-manager.md +162 -108
package/.agent/agents/project-planner.md +162 -142
package/.agent/agents/qa-automation-engineer.md +242 -138
package/.agent/agents/security-auditor.md +194 -170
package/.agent/agents/seo-specialist.md +213 -132
package/.agent/agents/sql-reviewer.md +194 -73
package/.agent/agents/supervisor-agent.md +203 -156
package/.agent/agents/test-coverage-reviewer.md +193 -81
package/.agent/agents/type-safety-reviewer.md +208 -65
package/.agent/scripts/__pycache__/auto_preview.cpython-311.pyc +0 -0
package/.agent/scripts/__pycache__/bundle_analyzer.cpython-311.pyc +0 -0
package/.agent/scripts/__pycache__/checklist.cpython-311.pyc +0 -0
package/.agent/scripts/__pycache__/dependency_analyzer.cpython-311.pyc +0 -0
package/.agent/scripts/__pycache__/security_scan.cpython-311.pyc +0 -0
package/.agent/scripts/__pycache__/session_manager.cpython-311.pyc +0 -0
package/.agent/scripts/__pycache__/skill_integrator.cpython-311.pyc +0 -0
package/.agent/scripts/__pycache__/swarm_dispatcher.cpython-311.pyc +0 -0
package/.agent/scripts/__pycache__/test_runner.cpython-311.pyc +0 -0
package/.agent/scripts/__pycache__/verify_all.cpython-311.pyc +0 -0
package/.agent/skills/agent-organizer/SKILL.md +126 -132
package/.agent/skills/ai-prompt-injection-defense/SKILL.md +155 -66
package/.agent/skills/api-patterns/SKILL.md +289 -257
package/.agent/skills/api-security-auditor/SKILL.md +172 -70
package/.agent/skills/app-builder/templates/chrome-extension/TEMPLATE.md +1 -1
package/.agent/skills/app-builder/templates/electron-desktop/TEMPLATE.md +1 -1
package/.agent/skills/appflow-wireframe/SKILL.md +107 -100
package/.agent/skills/architecture/SKILL.md +331 -200
package/.agent/skills/authentication-best-practices/SKILL.md +168 -67
package/.agent/skills/bash-linux/SKILL.md +154 -215
package/.agent/skills/brainstorming/SKILL.md +104 -210
package/.agent/skills/building-native-ui/SKILL.md +169 -70
package/.agent/skills/clean-code/SKILL.md +360 -206
package/.agent/skills/config-validator/SKILL.md +141 -165
package/.agent/skills/csharp-developer/SKILL.md +528 -107
package/.agent/skills/database-design/SKILL.md +455 -275
package/.agent/skills/deployment-procedures/SKILL.md +145 -188
package/.agent/skills/devops-engineer/SKILL.md +332 -134
package/.agent/skills/devops-incident-responder/SKILL.md +113 -98
package/.agent/skills/edge-computing/SKILL.md +157 -213
package/.agent/skills/extract-design-system/SKILL.md +129 -69
package/.agent/skills/framer-motion-expert/SKILL.md +939 -0
package/.agent/skills/game-design-expert/SKILL.md +105 -0
package/.agent/skills/game-engineering-expert/SKILL.md +122 -0
package/.agent/skills/geo-fundamentals/SKILL.md +124 -215
package/.agent/skills/github-operations/SKILL.md +314 -354
package/.agent/skills/gsap-expert/SKILL.md +901 -0
package/.agent/skills/i18n-localization/SKILL.md +138 -216
package/.agent/skills/intelligent-routing/SKILL.md +127 -139
package/.agent/skills/llm-engineering/SKILL.md +357 -258
package/.agent/skills/local-first/SKILL.md +154 -203
package/.agent/skills/mcp-builder/SKILL.md +118 -224
package/.agent/skills/nextjs-react-expert/SKILL.md +783 -203
package/.agent/skills/nodejs-best-practices/SKILL.md +559 -280
package/.agent/skills/observability/SKILL.md +330 -285
package/.agent/skills/parallel-agents/SKILL.md +122 -181
package/.agent/skills/performance-profiling/SKILL.md +254 -197
package/.agent/skills/plan-writing/SKILL.md +118 -188
package/.agent/skills/platform-engineer/SKILL.md +123 -135
package/.agent/skills/playwright-best-practices/SKILL.md +157 -76
package/.agent/skills/powershell-windows/SKILL.md +146 -230
package/.agent/skills/python-pro/SKILL.md +879 -114
package/.agent/skills/react-specialist/SKILL.md +931 -108
package/.agent/skills/realtime-patterns/SKILL.md +304 -296
package/.agent/skills/rust-pro/SKILL.md +701 -240
package/.agent/skills/seo-fundamentals/SKILL.md +154 -181
package/.agent/skills/server-management/SKILL.md +190 -212
package/.agent/skills/shadcn-ui-expert/SKILL.md +201 -68
package/.agent/skills/sql-pro/SKILL.md +633 -104
package/.agent/skills/swiftui-expert/SKILL.md +171 -70
package/.agent/skills/systematic-debugging/SKILL.md +118 -186
package/.agent/skills/tailwind-patterns/SKILL.md +576 -232
package/.agent/skills/tdd-workflow/SKILL.md +137 -209
package/.agent/skills/testing-patterns/SKILL.md +573 -205
package/.agent/skills/vue-expert/SKILL.md +964 -119
package/.agent/skills/vulnerability-scanner/SKILL.md +269 -316
package/.agent/skills/web-accessibility-auditor/SKILL.md +188 -71
package/.agent/skills/webapp-testing/SKILL.md +145 -236
package/.agent/workflows/api-tester.md +151 -279
package/.agent/workflows/audit.md +138 -168
package/.agent/workflows/brainstorm.md +110 -146
package/.agent/workflows/changelog.md +112 -144
package/.agent/workflows/create.md +124 -139
package/.agent/workflows/debug.md +189 -196
package/.agent/workflows/deploy.md +189 -153
package/.agent/workflows/enhance.md +151 -139
package/.agent/workflows/fix.md +135 -143
package/.agent/workflows/generate.md +157 -164
package/.agent/workflows/migrate.md +160 -163
package/.agent/workflows/orchestrate.md +168 -151
package/.agent/workflows/performance-benchmarker.md +123 -305
package/.agent/workflows/plan.md +173 -151
package/.agent/workflows/preview.md +80 -137
package/.agent/workflows/refactor.md +183 -153
package/.agent/workflows/review-ai.md +129 -140
package/.agent/workflows/review.md +116 -155
package/.agent/workflows/session.md +94 -154
package/.agent/workflows/status.md +79 -125
package/.agent/workflows/strengthen-skills.md +139 -99
package/.agent/workflows/swarm.md +179 -194
package/.agent/workflows/test.md +211 -166
package/.agent/workflows/tribunal-backend.md +113 -111
package/.agent/workflows/tribunal-database.md +115 -132
package/.agent/workflows/tribunal-frontend.md +118 -115
package/.agent/workflows/tribunal-full.md +133 -136
package/.agent/workflows/tribunal-mobile.md +119 -123
package/.agent/workflows/tribunal-performance.md +133 -152
package/.agent/workflows/ui-ux-pro-max.md +143 -171
package/README.md +11 -15
package/package.json +1 -1
package/.agent/skills/dotnet-core-expert/SKILL.md +0 -103
package/.agent/skills/framer-motion-animations/SKILL.md +0 -74
package/.agent/skills/game-development/2d-games/SKILL.md +0 -119
package/.agent/skills/game-development/3d-games/SKILL.md +0 -135
package/.agent/skills/game-development/SKILL.md +0 -236
package/.agent/skills/game-development/game-art/SKILL.md +0 -185
package/.agent/skills/game-development/game-audio/SKILL.md +0 -190
package/.agent/skills/game-development/game-design/SKILL.md +0 -129
package/.agent/skills/game-development/mobile-games/SKILL.md +0 -108
package/.agent/skills/game-development/multiplayer/SKILL.md +0 -132
package/.agent/skills/game-development/pc-games/SKILL.md +0 -144
package/.agent/skills/game-development/vr-ar/SKILL.md +0 -123
package/.agent/skills/game-development/web-games/SKILL.md +0 -150

package/.agent/skills/i18n-localization/SKILL.md CHANGED Viewed

@@ -1,216 +1,138 @@
----
-name: i18n-localization
-description: Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.
-allowed-tools: Read, Write, Edit, Glob, Grep
-version: 1.0.0
-last-updated: 2026-03-12
-applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
----
-# Internationalization & Localization
-> Internationalization (i18n) is preparing code to support multiple languages.
-> Localization (l10n) is the work of adapting to a specific locale.
-> Do i18n once, properly. Do l10n for each market.
----
-## The Core Rule: No Hardcoded Strings
-Every user-visible string in the source code is a localization problem waiting to happen.
-```ts
-// ❌ Hardcoded — untranslatable
-<button>Save Changes</button>
-<p>You have {count} messages</p>
-<p>Error: Invalid email address</p>
-// ✅ Key-referenced — translatable
-<button>{t('common.save')}</button>
-<p>{t('inbox.messageCount', { count })}</p>
-<p>{t('errors.invalidEmail')}</p>
-```
----
-## Translation File Structure
-Organize translation keys hierarchically — flat files become unmaintainable past ~50 keys:
-```json
-// en.json
-{
-  "common": {
-    "save": "Save Changes",
-    "cancel": "Cancel",
-    "loading": "Loading…",
-    "error": "Something went wrong"
-  },
-  "auth": {
-    "login": "Sign In",
-    "logout": "Sign Out",
-    "register": "Create Account",
-    "errors": {
-      "invalidEmail": "Enter a valid email address",
-      "passwordTooShort": "Password must be at least {{min}} characters"
-    }
-  },
-  "inbox": {
-    "messageCount_one": "{{count}} message",
-    "messageCount_other": "{{count}} messages"
-  }
-}
-```
-**Key naming conventions:**
-- `feature.element` or `feature.element.state`
-- Error keys under `.errors`
-- Never use the English text as the key (`"Save Changes": "Save Changes"`)
----
-## Pluralization
-Pluralization rules differ per language. Use your i18n library's plural system — never manual `if count > 1`:
-```ts
-// ❌ Only works for English
-const label = count === 1 ? 'message' : 'messages';
-// ✅ i18next handles per-language plural rules
-t('inbox.messageCount', { count })
-// Translation files handle the variants:
-// English: { "messageCount_one": "{{count}} message", "messageCount_other": "{{count}} messages" }
-// Arabic:  6 plural forms (zero, one, two, few, many, other)
-// Russian: 3 plural forms with complex rules
-```
----
-## Date, Number & Currency Formatting
-Never format these manually. Use the browser's `Intl` API:
-```ts
-// Date
-const date = new Date();
-new Intl.DateTimeFormat('en-US').format(date);  // "2/20/2026"
-new Intl.DateTimeFormat('de-DE').format(date);  // "20.2.2026"
-// Number
-new Intl.NumberFormat('en-US').format(1234567.89);  // "1,234,567.89"
-new Intl.NumberFormat('de-DE').format(1234567.89);  // "1.234.567,89"
-// Currency
-new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(99.99);
-// "$99.99"
-new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(99.99);
-// "99,99 €"
-```
----
-## RTL (Right-to-Left) Support
-Arabic, Hebrew, Persian, Urdu are RTL languages. Supporting them requires more than flipping direction.
-```html
-<!-- Set direction on html element based on locale -->
-<html lang="ar" dir="rtl">
-<!-- Or dynamically -->
-<html lang={locale} dir={isRTL(locale) ? 'rtl' : 'ltr'}>
-```
-```css
-/* Use logical properties — they flip automatically with direction */
-/* ❌ Physical: only works for LTR */
-padding-left: 1rem;
-margin-right: 2rem;
-border-left: 2px solid;
-/* ✅ Logical: works for both LTR and RTL */
-padding-inline-start: 1rem;
-margin-inline-end: 2rem;
-border-inline-start: 2px solid;
-```
----
-## Detecting Hardcoded Strings (Code Audit)
-Look for:
-- JSX text content directly in tags: `<p>some text</p>` (not `<p>{t(...)}</p>`)
-- Template literals with user-facing copy: `` `Welcome, ${name}!` ``
-- Alert/toast calls with string literals: `toast.success('Saved!')`
-- Error messages: `new Error('Invalid input')` shown to users
-- `placeholder`, `aria-label`, `title` attributes hardcoded
----
-## Scripts
-| Script | Purpose | Run With |
-|---|---|---|
-| `scripts/i18n_checker.py` | Scans codebase for hardcoded strings | `python scripts/i18n_checker.py <project_path>` |
----
-## Output Format
-When this skill produces a recommendation or design decision, structure your output as:
-```
-━━━ I18N Localization Recommendation ━━━━━━━━━━━━━━━━
-Decision:    [what was chosen / proposed]
-Rationale:   [why — one concise line]
-Trade-offs:  [what is consciously accepted]
-Next action: [concrete next step for the user]
-─────────────────────────────────────────────────
-Pre-Flight:  ✅ All checks passed
-             or ❌ [blocking item that must be resolved first]
-```
----
-## 🤖 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.
+---
+name: i18n-localization
+description: 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.
+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
+---
+# i18n & Localization — Global Scale Mastery
+> Translating text is easy. Localizing variables, dates, plurals, and reading directions is complex.
+> Do not build your own translation hash-map engine. It will break on Arabic plurals.
+---
+## 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.50);
+// 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`).
+---
+## 🤖 LLM-Specific Traps (i18n)
+1. **Building Custom Maps:** AI writes generic `const dict = { en: "Hello", es: "Hola" }` and queries it via `dict[locale]`. This fundamentally fails for plurals, interpolation, and rich text. Use standard libraries.
+2. **Ignoring Plural Rules:** English has 2 plural forms (singular, plural). Arabic has 6 (zero, one, two, few, many, other). Hallucinating `count === 1 ? 'apple' : 'apples'` logic breaks internationally. Ensure ICU message formatting.
+3. **Physical CSS Layouts:** Writing `ml-4` or `pr-2` (margin-left, padding-right) in Tailwind. Standardize exclusively on `ms-4` (margin-start) and `pe-2` (padding-end) to guarantee RTL flip compliance.
+4. **Hardcoded Date Formats:** AI using `date.toLocaleDateString('en-US')` globally inside an i18n abstraction library, overriding the dynamic user locality entirely.
+5. **Component Cracking for Rich Text:** The AI tries to translate "Click *here* to login" by breaking it into 3 separate translation keys (Start, Link, End). This destroys translator context. Modern libraries support `t.rich('key', { span: (chunks) => <span>{chunks}</span> })`.
+6. **Server vs Client Disconnect:** AI suggests using a React Context `LocaleProvider` heavily in Next.js Server Components. SSR apps must extract locale explicitly from the URL route (`params.locale`), not React Context.
+7. **Dictionary Bloat:** Trying to load a massive 5MB `global.json` translation file on initial boot, completely destroying First Contentful Paint. AI must segment routing into domain namespaces (e.g., `Checkout.json`).
+8. **Locale Fallbacks Missing:** Failing to set `en` as the default fallback logic when a key is missing in the requested language, causing catastrophic `undefined` crashes on runtime rendering.
+9. **Translating Variable Identities:** Accidentally translating JSON mapping keys or CSS classes inside the codebase when attempting to internationalize display text.
+10. **Timezone Blindness:** Assuming formatting a DateTime automatically translates the underlying timezone shift. Timezone and Locale are two distinct configurations. Displaying local time requires tracking client offset via timezone context.
+---
+## 🏛️ Tribunal Integration
+### ✅ Pre-Flight Self-Audit
+```
+✅ Are strings fully abstracted into standard JSON/YAML dictionaries using ICU format?
+✅ Is variable interpolation utilizing standard library bindings rather than raw string concatenation?
+✅ Have pluralization logic been delegated to the i18n engine to support multi-form languages?
+✅ Are physical CSS layouts stripped in favor of Logical Properties (e.g., `start`, `end`, `margin-inline`)?
+✅ Has the `<html dir="rtl">` tag generation been integrated for Right-To-Left language requests?
+✅ Is data formatting (dates, currency, relative time) natively executed via target-aware `Intl` APIs?
+✅ Did I ensure Rich-Text translations (links within blocks) remain unified in one single translation key?
+✅ Is Next.js routing actively leveraging `[locale]` parameters accurately in SSR domains?
+✅ Are JSON translation files segmented logically by namespace to prevent massive client-side bloat?
+✅ Did I enforce strict error-bypassing fallback logic to default language upon missing translation keys?
+```

package/.agent/skills/intelligent-routing/SKILL.md CHANGED Viewed

@@ -1,139 +1,127 @@
----
-name: intelligent-routing
-description: The LLM Pre-Router. Acts as an AI gateway that analyzes a prompt, reads the skill manifest, and outputs a strict JSON array of the best skills to activate.
-allowed-tools: Read, Write, Edit, Glob, Grep
-version: 1.0.0
-last-updated: 2026-03-12
-applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
----
-# 🚦 Intelligent Pre-Router (LLM Gateway)
-> The best specialist response is useless if the wrong specialist shows up.
-> Routing is the first decision — and it affects everything after.
----
-## 🎭 Your Persona: The LLM Gateway
-When you are acting as the `intelligent-routing` agent, **you are a gateway, not an implementer.**
-Your sole purpose is to read the user's prompt, understand their core intent, and figure out which of our specialized agents and skills need to be loaded into context to solve the problem accurately.
-**Rules of the Gateway:**
-1. **Zero Implementation:** You must never write code, propose architectures, or answer the user's technical question directly while functioning as the router.
-2. **Context Minimization:** You do not read every file in the project. You only read the user's prompt and the skill manifest.
----
-## 🗺️ How to Route (The Sequence)
-When activated to route a request, execute this exact sequence:
-1. **Read the Manifest:** Read the file `.agent/skills/intelligent-routing/router-manifest.md`. This contains the condensed index of all 60+ available skills.
-2. **Analyze the Prompt:** Identify the domains (e.g., UI design, database optimization, testing).
-3. **Select Skills:** Choose 1 to 3 relevant skills from the manifest. Do not select more than 3 to avoid context bloating.
-4. **Determine Complexity:**
-    *   If 1 skill is selected: This is a single-domain task.
-    *   If 2+ skills are selected: This is a multi-domain task requiring the `orchestrator`.
-5. **Output the JSON Array:** See the output format below.
----
-## 📤 Required Output Format
-You must output your decision strictly as a JSON array inside a markdown block. Do not add conversational fluff before or after.
-**Example 1: Single Domain Request ("Make this UI match apple's aesthetic")**
-```json
-{
-  "domains": ["UI", "Design"],
-  "selected_skills": ["frontend-design", "ui-ux-researcher"],
-  "requires_orchestrator": false,
-  "rationale": "The user is asking for aesthetic design improvements, requiring specific frontend UI heuristics."
-}
-```
-**Example 2: Multi-Domain Request ("Build a full-stack login page with JWTs")**
-```json
-{
-  "domains": ["Frontend", "Backend", "Security"],
-  "selected_skills": ["frontend-specialist", "backend-specialist", "security-auditor"],
-  "requires_orchestrator": true,
-  "rationale": "Full-stack feature touching React, Express, and authentication."
-}
-```
-Once you output this JSON, the host AI IDE (Cursor, Windsurf, etc.) or CLI will read it and automatically activate those specific `SKILL.md` files for the actual implementation phase.
----
-## 🤖 Router-Specific Anti-Hallucination Guards
-As an AI, you are prone to certain hallucinations when routing tasks. Adhere strictly to these rules:
-1. **No Ghost Skills:** Every string in the `selected_skills` array MUST exactly match a skill directory name found in `router-manifest.md`.
-    *   *❌ AI Trait:* Inventing a skill like `jwt-specialist` because the user asked about JWTs.
-    *   *✅ Correction:* Selecting real skills like `backend-specialist` and `security-auditor`.
-2. **Strict JSON:** If your response contains anything other than the JSON block, downstream parsers will fail. Do not say "Here is the routing decision:". Just output the JSON block.
-3. **Keyword Over-indexing:** Do not blindly match words. If a user says "My API is slow", you need `performance-optimizer` and `backend-specialist`, not just anything that says "API" like `api-tester`.
----
-## Output Format
-When this skill produces a recommendation or design decision, structure your output as:
-```
-━━━ Intelligent Routing Recommendation ━━━━━━━━━━━━━━━━
-Decision:    [what was chosen / proposed]
-Rationale:   [why — one concise line]
-Trade-offs:  [what is consciously accepted]
-Next action: [concrete next step for the user]
-─────────────────────────────────────────────────
-Pre-Flight:  ✅ All checks passed
-             or ❌ [blocking item that must be resolved first]
-```
----
-## 🤖 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.
+---
+name: intelligent-routing
+description: LLM Intent Processing and Gateway Routing mastery. Request classification hierarchies, function routing, confidence scoring, fallback cascades, zero-shot vs few-shot classification patterns, and identifying specialized skills for delegation. Use when parsing raw user input to determine the architectural path of execution.
+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
+---
+# Intelligent Routing — Intent Gateway Mastery
+> Every complex automation starts with a router.
+> If you route the request incorrectly, the subsequent 10 steps of execution will fail flawlessly.
+---
+## 1. Classification Hierarchy (The Gateway)
+When a raw request enters a system, it must be bucketed properly. This is the First Step (Phase 0). Do not attempt to solve the user's problem during the routing phase.
+```typescript
+// The Semantic Intent Schema
+const RouterOutputSchema = z.object({
+  classification: z.enum([
+    "QUESTION",       // User wants explanation, no code execution needed
+    "SURVEY",         // User wants analysis/read-only scan of workspace
+    "SIMPLE_EDIT",    // Isolated file alteration (e.g., "Fix spelling in nav")
+    "COMPLEX_BUILD",  // Multi-file, architectural generation
+    "SECURITY_AUDIT", // Explicit request for OWASP review
+    "UNCLEAR_GIBBERISH" // Prompt injection or incoherent input
+  ]),
+  confidenceScore: z.number().min(0).max(100),
+  suggestedPrimarySkill: z.string().nullable(),
+  requiresHumanClarification: z.boolean(),
+  reasoning: z.string() // Forces the LLM to justify its route before categorizing
+});
+```
+### Zero-Shot vs Few-Shot Classification
+- **Zero-Shot:** Providing definitions and hoping the LLM categorizes the prompt accurately. Error-prone.
+- **Few-Shot (Mandatory for Routers):** Providing explicit paired examples defining the categorical boundaries.
+```text
+## Routing Examples:
+User: "Why is the header blue?"
+Output: {"classification": "QUESTION", "requiresHumanClarification": false}
+User: "Add a user login system"
+Output: {"classification": "COMPLEX_BUILD", "requiresHumanClarification": true}
+Reasoning: "Login systems require multi-file architecture, database hooks, and security implementation."
+```
+---
+## 2. Dynamic Skill Matching (Manifest Analysis)
+A Router isn't just classifying intent—it actively maps tasks to available capabilities.
+If building a system with 50 available agents/skills, pass the Router a localized summary manifest, not the full 50x files.
+```json
+// Example Context Payload passed to Router
+{
+  "available_skills": [
+    {"name": "react-specialist", "desc": "React 19, hooks, component architecture"},
+    {"name": "python-pro", "desc": "FastAPI, async, data processing"},
+    {"name": "vulnerability-scanner", "desc": "OWASP, injections, secret scanning"}
+  ],
+  "user_request": "How do I speed up this data pipeline script?"
+}
+```
+*Router calculates:* `match: python-pro` AND `match: performance-profiling`.
+---
+## 3. Fallback Cascades & Ambiguity
+The AI will encounter prompts it does not understand. The Router is the *only* place where it is safe to halt and ask immediately.
+**The Socratic Yield Rule:**
+If the `confidenceScore` of a categorization is `< 85`, the router MUST yield back to the user with a clarifying question instead of guessing the intent.
+*User:* "Fix the thing."
+*Router Action (Incorrect):* Assume they mean standard linter execution and run scripts.
+*Router Action (Correct):* Halt. "Which file or feature are you referring to?"
+---
+## 4. Bounding the Exploder Pattern
+Certain requests sound simple but require massive execution matrices (The "Exploder" pattern).
+*User:* "Translate my entire app to French."
+The Router must recognize execution scales. If an execution requires touching >10 files, the Router must switch the system into `PLANNING_MODE` to generate an itinerary, rather than attempting an outright sequential execution.
+---
+## 🤖 LLM-Specific Traps (Intelligent Routing)
+1. **Solving in the Router:** An LLM prompted to "Route this coding request" often replies with the actual finalized code rather than selecting the routing node. Stiffly enforce JSON outputs via schema constraint.
+2. **Zero-Shot Halucination:** The router guesses an intent bucket that isn't functionally defined (e.g., returning `classification: "DATABASE_MODE"` when that isn't a valid system enum).
+3. **Skill Name Invention:** Suggesting the invocation of a skill that doesn't exist (`suggestedSkill: "docker-expert"`) instead of matching against the explicitly provided manifest of available internal skills.
+4. **Ignoring Confidence Thresholds:** Proceeding with architectural execution even when the user's prompt is completely ambiguous, resulting in 5 wasted LLM token loops.
+5. **The God-Agent Fallback:** Categorizing complex requests into generic root workflows instead of isolating the exact specialist (e.g., dispatching `app-builder` when `playwright-best-practices` was the explicitly requested optimization).
+6. **No Escapes for Gibberish:** Failing to identify prompt-injections or copy-paste errors, trying to parse random garbled text into a functional execution path instead of instantly rejecting it.
+7. **Scale Blindness:** Treating "Add a console.log" and "Create an authentication system" as identical linear tasks without switching the heavier task into a designated `PLANNING_MODE` phase.
+8. **Missing Reasoning Chain:** Categorizing an intent *before* writing the justification text. Enforcing `reasoning: string` at the *top* of the output schema forces Chain-of-Thought (CoT) and drastically improves routing accuracy.
+9. **Single-Node Assignment:** Assuming a complex goal only requires one skill. High-order tasks require an array of skills (e.g., `[react-specialist, tailwind-patterns, web-accessibility-auditor]`).
+10. **Losing Socratic Contact:** Halting to ask the user a question, but not tracking the context so that when the user replies "Oh I meant the login page", the router forgets the initial objective.
+---
+## 🏛️ Tribunal Integration
+### ✅ Pre-Flight Self-Audit
+```
+✅ Are routing outputs strictly constrained to JSON Enums (Zod / Schema validation)?
+✅ Does the schema demand `reasoning` be printed *before* the definitive classification (CoT)?
+✅ Have explicit Few-Shot examples been provided to anchor the categorical definitions?
+✅ Are available skills mapped correctly using a localized manifest provided to the prompt?
+✅ Does the router explicitly reject or ask for clarity against ambiguous requests?
+✅ Is there a confidence threshold (e.g., < 85%) triggering the Socratic Gate yield?
+✅ Does the router correctly identify 'Exploder' tasks scaling >10 files and force `PLANNING_MODE`?
+✅ Did I prevent the LLM from attempting to solve the underlying code problem directly in the routing stage?
+✅ Can the router match a request to *multiple* synergistic skills rather than just one?
+✅ Are unknown/invented skill invocations automatically rejected before downstream execution?
+```