tribunal-kit 3.0.0 → 3.1.0

package/.agent/skills/game-design-expert/SKILL.md

@@ -1,105 +1,71 @@
----
-name: game-design-expert
-description: Game Design, UX, and Flow State mastery. Replaces fragmented legacy skills. Core gameplay loop design, 3Cs (Character, Camera, Controls), input buffering, coyote time, juice (game feel), telemetry tracking, narrative alignment, and audio spatialization integration. Use when crafting player experience, progression arcs, or systemic balance.
-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
----
-
-# Game Design Expert — Player Experience & Flow Mastery
-
-> A game is not a list of features. It is a psychological loop.
-> Perfect code evaluating a boring gameplay loop is a failed product.
-
----
-
-## 1. The 3Cs (Character, Camera, Controls)
-
-Before designing enemies, levels, or UI, the foundation of the player's interaction MUST feel flawless. If the player cannot intrinsically trust the controls, the entire system collapses.
-
-### Input Buffering
-Humans cannot click buttons flawlessly on the exact required frame.
-If a player presses "Jump" 3 frames *before* they hit the ground, a naïve engine ignores it. A designed engine *buffers* the input in memory for 150ms and instantly executes the jump the millisecond the character's feet touch the dirt.
-
-### Coyote Time
-Named after Wile E. Coyote hovering off a cliff.
-If a player runs off a ledge, a rigid physics engine drops them instantly.
-A forgiving design allows the player to still press 'Jump' for exactly ~100ms *after* walking off the ledge. It prevents extreme frustration on close platforming jumps.
-
----
-
-## 2. The Core Gameplay Loop
-
-Every action a player takes must feed into a reinforcing psychological loop. 
-
-**The Macro Loop (e.g., Destiny, Monster Hunter)**
-1. **Action:** Fight complex monsters.
-2. **Reward:** Collect physical parts and resources.
-3. **Pacing:** Return to base.
-4. **Upgrade:** Convert parts into stronger weapons.
-5. **Goal:** Fight stronger, unkillable monsters (Back to Step 1).
-
-*If step 4 (Upgrading) does not heavily alter step 1 (Fights are now faster, visually different, mechanically superior), the loop is broken and players churn.*
-
----
-
-## 3. "Juice" and Game Feel 
-
-"Juice" is the non-functional audiovisual feedback that makes an interaction feel heavy and satisfying.
-
-1. **Screen Shake:** A minor, mathematically decaying camera displacement when heavy impacts occur. (Needs toggles for accessibility).
-2. **Hitstop (Sleep Frames):** When a sword hits an enemy, freeze the entire game engine for exactly 3 frames (50ms). This creates an immense perceptual illusion of resistance and friction.
-3. **Squash and Stretch:** A character jumping should stretch vertically. A character landing should squash horizontally. It breaks rigidity and infuses life.
-4. **Particle Explosions:** Simple box collisions must be masked by explosive localized particle systems (dust kicks, sparks).
-
----
-
-## 4. Narrative & Audio Synergies
-
-Game design is not segregated from Audio. Audio is the primary vector for temporal feedback.
-
-1. **Spatialization (HRTF):** Sound objects emit audio localized strictly to 3D space, heavily attenuated by environmental occlusions (muffled behind walls).
-2. **Telegraphing State:** If an enemy swings a heavy axe, it MUST have a 300ms audio "wind-up" queue. The player relies on audio rhythm far faster than visual recognition to dodge.
-3. **Dynamic Mixing (Ducking):** Essential dialogue or UI pings must automatically compress (lower the volume of) ambient music underneath to prevent cognitive overload.
-
----
-
-## 5. Telemetry & Analytics Deficiencies
-
-Design is hypotheses. Playtests are the reality.
-
-Never rely on developers "feeling" the game. You must systematically log death coordinates (heatmaps). If 80% of players die at Level 2 Trap B, your design intent (teaching the mechanic) has failed. 
-
----
-
-## 🤖 LLM-Specific Traps (Game Design)
-
-1. **Ignoring Input Buffers:** The AI writes raw `if (Input.GetKeyDown() && isGrounded)` logic. This creates notoriously stiff, frustrating, and unresponsive controls.
-2. **Feature Soup:** A user asks for game ideas, and the AI suggests a survival crafting multiplayer battle-royale with RPG skill trees. This is un-shippable scope creep. Force brutal constraint down to one core mechanic.
-3. **Rigid Math Realism:** Dictating jump metrics strictly conforming to 9.8m/s² real-world gravity. Mario falls 3x faster than he jumps. Realism destroys game feel.
-4. **Punishing Precision:** Missing Coyote Time implementations entirely, punishing the player for 10-millisecond execution errors rather than rewarding the intent.
-5. **No Telegraphing:** AI designs boss attack patterns that instantly execute damage vectors simultaneously with the animation frame, making the attack literally impossible for a human reaction-time algorithm (200ms) to evade.
-6. **The Linear Number Grind:** Proposing "Upgrades" that solely increment numbers (`+5% damage`) instead of altering the fundamental mechanical verbs (`Sword now shoots fireballs horizontally`). Number grinds fail retention tests.
-7. **Dead UI Feedback:** Proposing UI UIs that simply flip variables to green, entirely omitting the requirement for scaling twin-interpolated bouncy animations that provide satisfying interaction juice.
-8. **Constant Intensity Tiring:** Failing to design Pacing. Recommending non-stop constant action loops without enforcing quiet, ambient "Return to Base" reset periods. The human brain numbs to constant intensity within 20 minutes.
-9. **Sound Sourcing Fallacies:** Treating Audio as a global 2D `Play()` function instead of enforcing 3D positional transforms anchored to the exact entity creating the disruption.
-10. **The Wall of Text:** AI proposes delivering lore via explicit text-box dumps at the start of a level, rather than environmental design (blood stains leading to a locked door). Show, do not dump text.
-
----
-
-## 🏛️ Tribunal Integration
-
-### ✅ Pre-Flight Self-Audit
-```
-✅ Are critical player actions protected significantly via Input Buffering and Coyote Time tolerances?
-✅ Does the 'Juice' architecture implement Hitstop, Screen Shake, and impact framing safely?
-✅ Are enemy damage sequences heavily telegraphed visually and auditorily BEFORE execution?
-✅ Is the gameplay loop tightly bound (Action -> Reward -> Meaningful Upgrade -> Action)?
-✅ Has scope creep been aggressively slashed to favor extreme polishing of the single Core Loop?
-✅ Is gravity manipulated artificially (custom fast-fall modifiers) to improve character weight mechanics?
-✅ Have rewards been mapped to change mechanical player verbs, rather than simple stat additions?
-✅ Does the pacing explicitly enforce quiet, non-lethal downtime intervals?
-✅ Is audio spatialized explicitly to the 3D entity geometry rather than firing globally?
-✅ Are narrative/tutorial deliveries handled environmentally or organically instead of monolithic text walls?
-```
+---
+name: game-design-expert
+description: Game Design, UX, and Flow State mastery. Replaces fragmented legacy skills. Core gameplay loop design, 3Cs (Character, Camera, Controls), input buffering, coyote time, juice (game feel), telemetry tracking, narrative alignment, and audio spatialization integration. Use when crafting player experience, progression arcs, or systemic balance.
+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
+---
+
+# Game Design Expert — Player Experience & Flow Mastery
+
+---
+
+## 1. The 3Cs (Character, Camera, Controls)
+
+Before designing enemies, levels, or UI, the foundation of the player's interaction MUST feel flawless. If the player cannot intrinsically trust the controls, the entire system collapses.
+
+### Input Buffering
+Humans cannot click buttons flawlessly on the exact required frame.
+If a player presses "Jump" 3 frames *before* they hit the ground, a naïve engine ignores it. A designed engine *buffers* the input in memory for 150ms and instantly executes the jump the millisecond the character's feet touch the dirt.
+
+### Coyote Time
+Named after Wile E. Coyote hovering off a cliff.
+If a player runs off a ledge, a rigid physics engine drops them instantly.
+A forgiving design allows the player to still press 'Jump' for exactly ~100ms *after* walking off the ledge. It prevents extreme frustration on close platforming jumps.
+
+---
+
+## 2. The Core Gameplay Loop
+
+Every action a player takes must feed into a reinforcing psychological loop. 
+
+**The Macro Loop (e.g., Destiny, Monster Hunter)**
+1. **Action:** Fight complex monsters.
+2. **Reward:** Collect physical parts and resources.
+3. **Pacing:** Return to base.
+4. **Upgrade:** Convert parts into stronger weapons.
+5. **Goal:** Fight stronger, unkillable monsters (Back to Step 1).
+
+*If step 4 (Upgrading) does not heavily alter step 1 (Fights are now faster, visually different, mechanically superior), the loop is broken and players churn.*
+
+---
+
+## 3. "Juice" and Game Feel 
+
+"Juice" is the non-functional audiovisual feedback that makes an interaction feel heavy and satisfying.
+
+1. **Screen Shake:** A minor, mathematically decaying camera displacement when heavy impacts occur. (Needs toggles for accessibility).
+2. **Hitstop (Sleep Frames):** When a sword hits an enemy, freeze the entire game engine for exactly 3 frames (50ms). This creates an immense perceptual illusion of resistance and friction.
+3. **Squash and Stretch:** A character jumping should stretch vertically. A character landing should squash horizontally. It breaks rigidity and infuses life.
+4. **Particle Explosions:** Simple box collisions must be masked by explosive localized particle systems (dust kicks, sparks).
+
+---
+
+## 4. Narrative & Audio Synergies
+
+Game design is not segregated from Audio. Audio is the primary vector for temporal feedback.
+
+1. **Spatialization (HRTF):** Sound objects emit audio localized strictly to 3D space, heavily attenuated by environmental occlusions (muffled behind walls).
+2. **Telegraphing State:** If an enemy swings a heavy axe, it MUST have a 300ms audio "wind-up" queue. The player relies on audio rhythm far faster than visual recognition to dodge.
+3. **Dynamic Mixing (Ducking):** Essential dialogue or UI pings must automatically compress (lower the volume of) ambient music underneath to prevent cognitive overload.
+
+---
+
+## 5. Telemetry & Analytics Deficiencies
+
+Design is hypotheses. Playtests are the reality.
+
+Never rely on developers "feeling" the game. You must systematically log death coordinates (heatmaps). If 80% of players die at Level 2 Trap B, your design intent (teaching the mechanic) has failed. 
+
+---

package/.agent/skills/game-engineering-expert/SKILL.md

@@ -1,122 +1,88 @@
----
-name: game-engineering-expert
-description: Game Engineering and Systems Architecture mastery. Replaces fragmented legacy skills. Entity Component Systems (ECS), Unity (C#) / Godot (GDScript) integration, physics calculations, deterministic engine state, WebGL memory management, multiplayer sync architectures (deterministic lockstep vs traditional authoritative), spatial partitioning, and rendering pipelines.
-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
----
-
-# Game Engineering Expert — Performance & State Mastery
-
-> A web server processes requests asynchronously. A game engine processes reality 60 times a second.
-> Memory allocation inside the update loop is a death sentence for frame rates.
-
----
-
-## 1. Frame Rate Architecture (The Update Loop)
-
-In web development, we await Promises. In game development, we calculate Delta Time continuously.
-
-```csharp
-// ❌ BAD: Frame-rate dependent logic
-// If the game runs at 120 FPS, the character moves twice as fast as on 60 FPS
-void Update() {
-    transform.position += currentSpeed; 
-}
-
-// ✅ GOOD: Frame-independent physics (Unity C# Example)
-void Update() {
-    // DeltaTime is the time elapsed since the last frame
-    transform.position += currentVelocity * Time.deltaTime; 
-}
-```
-
-### FixedUpdate vs Update (The Physics Boundary)
-- `Update()` fires as fast as the GPU/CPU can draw. Used for User Input and visual animation interpolations.
-- `FixedUpdate()` fires at absolute strict mathematical intervals (e.g., 50 times a second exactly). ALL Physics interactions (`AddForce()`, collision sweeps) MUST live here to prevent tearing and tunneling.
-
----
-
-## 2. Memory Pooling (Garbage Collection Death)
-
-In Node.js, V8 cleans up objects eventually. In Game Engines, allocating memory creates "Garbage", which forces the Garbage Collector (GC) to pause the entire game to clean up, causing massive micro-stutters.
-
-```csharp
-// ❌ FATAL (in Update loops): Creating new objects 60x a second
-void Update() {
-    Instantiate(bulletPrefab, gun.position, gun.rotation); // Kills the CPU
-}
-
-// ✅ EFFICIENT: Object Pooling
-// Pre-allocate 100 bullets during the Loading Screen.
-// Then simply toggle their active state natively.
-void Fire() {
-    Bullet b = bulletPool.GetDisabledBullet();
-    b.transform.position = gun.position;
-    b.gameObject.SetActive(true);
-}
-```
-
----
-
-## 3. Entity Component Systems (ECS)
-
-Traditional Object-Oriented Programming (OOP) inheritance hierarchies break down in game engines.
-(e.g., `Enemy` inherits from `Character` which inherits from `Renderable`). What happens when you want a `Renderable` that isn't a `Character` but acts like an `Enemy` (like a deadly spike trap)?
-
-**Use ECS.**
-1. **Entities:** Just a meaningless ID (e.g., `Entity 304`).
-2. **Components:** Pure localized data structs attached to an ID (e.g., `Position {x: 5, y: 10}`, `Health {hp: 100}`).
-3. **Systems:** Logic that maps continuously over structs (e.g., `MovementSystem` iterates over ALL Entities that specifically have both a `Position` AND `Velocity` component).
-
----
-
-## 4. Multiplayer Architectures
-
-Never trust the client. A multiplayer architecture dictates latency fundamentally.
-
-1. **Deterministic Lockstep (RTS / Fighting Games):**
-   - Transmits absolute ZERO game state (coordinates).
-   - Only transmits *inputs* (Player A clicked Coordinate X).
-   - Both machines run the identical physics frame simultaneously.
-   - Extremely bandwidth efficient, but requires identical CPU math output (impossible in JS floating point Math).
-
-2. **Server Authoritative with Client Prediction (Modern FPS/Action):**
-   - The Server runs the "Real" game.
-   - The Client tells the server "I fired."
-   - Because Ping takes 50ms, the Client *predicts* the shot landing locally (optimistic UI) so the player doesn't feel lag.
-   - If the server eventually disagrees, the Client aggressively rewinds and snaps the state to match the Server reality (Rubber-banding).
-
----
-
-## 🤖 LLM-Specific Traps (Game Engineering)
-
-1. **Await Inside Update:** AI suggests `await Task.Delay()` inside a Unity `Update()` loop instead of yielding inside a proper Coroutine, causing thousands of tasks to stack and crash the engine memory instantaneously.
-2. **Missing DeltaTime:** The AI forgets to multiply positional vectors by `Time.deltaTime` (or Godot's `delta`), making games function optimally on developer PCs but hyper-speed glitch on high refresh rate monitors.
-3. **Direct String Lookups:** Executing `GameObject.Find("Player")` inside an `Update()` loop. This forces a recursive string-matching crawl across the entire scene hierarchy 60 times a second. Architect via localized caching/Singleton pattern on boot.
-4. **Trusting the Client State:** Architecting a multiplayer route as `emit('playerDead', { id: targetId })`. An exploiter can forge this payload and kill anyone. The client must emit `('fireWeapon', { aimVector })` and the server decides if targetId dies.
-5. **Physics Tunneling:** The AI moves objects by altering `.position` directly instead of manipulating `RigidBody` velocities. If moved directly, the physics engine cannot calculate intermediate collision sweeps, causing bullets to phase through thin walls blindly.
-6. **OOP Hierarchy Hell:** The AI generating deep, brittle C++ inheritance trees for enemies instead of favoring flat Component composition.
-7. **Allocating In Rendering Loops:** Instantiating new Vector3 structs (`new Vector3()`) continuously inside tight algorithmic loops instead of utilizing strict global allocations or structural re-assignment.
-8. **WebGL Threading Illusions:** Suggesting complex C# multi-threading (System.Threading.Tasks) for a Unity WebGL web-game build. WebGL fundamentally executes single-threaded; multi-threading must be emulated or bypassed entirely via Job Systems.
-9. **Event Spillage (Memory Leaks):** Subscribing to strict engine C# Action events ( `GameManager.OnDeath += Explode;` ) but entirely failing to unsubscribe in the `OnDestroy()` hierarchy, creating immortal zombie objects in RAM forever.
-10. **The Canvas Rebuild:** Altering a single Text element in a massive UI grouping, causing Unity to expensively re-rasterize and bake the entire UI canvas mesh. Segment UI into static and dynamic distinct canvases.
-
----
-
-## 🏛️ Tribunal Integration
-
-### ✅ Pre-Flight Self-Audit
-```
-✅ Are positional equations multiplied universally by `deltaTime` for frame independence?
-✅ Have physics/collision mutations been explicitly restricted to the `FixedUpdate` engine cycles?
-✅ Are memory pools implemented to completely eliminate runtime garbage collection stutter?
-✅ Does the networking architecture explicitly forbid the client from dictating authoritative game state?
-✅ Have `.Find()` string query loops been eliminated from continuous execution pathways?
-✅ Did I rely on Component composition rather than deep, brittle inheritance trees?
-✅ Are `RigidBody` velocities manipulated instead of raw `.position` to prevent quantum wall tunneling?
-✅ Have all event subscriptions (`+=`) been rigidly paired with localized destruction unsubscribe (`-=`) methods?
-✅ Were multi-threading paradigms avoided/recalculated if targeting web browser execution formats?
-✅ Is the UI strictly architected to prevent global canvas rebuilds across minor localized visual changes?
-```
+---
+name: game-engineering-expert
+description: Game Engineering and Systems Architecture mastery. Replaces fragmented legacy skills. Entity Component Systems (ECS), Unity (C#) / Godot (GDScript) integration, physics calculations, deterministic engine state, WebGL memory management, multiplayer sync architectures (deterministic lockstep vs traditional authoritative), spatial partitioning, and rendering pipelines.
+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
+---
+
+# Game Engineering Expert — Performance & State Mastery
+
+---
+
+## 1. Frame Rate Architecture (The Update Loop)
+
+In web development, we await Promises. In game development, we calculate Delta Time continuously.
+
+```csharp
+// ❌ BAD: Frame-rate dependent logic
+// If the game runs at 120 FPS, the character moves twice as fast as on 60 FPS
+void Update() {
+    transform.position += currentSpeed; 
+}
+
+// ✅ GOOD: Frame-independent physics (Unity C# Example)
+void Update() {
+    // DeltaTime is the time elapsed since the last frame
+    transform.position += currentVelocity * Time.deltaTime; 
+}
+```
+
+### FixedUpdate vs Update (The Physics Boundary)
+- `Update()` fires as fast as the GPU/CPU can draw. Used for User Input and visual animation interpolations.
+- `FixedUpdate()` fires at absolute strict mathematical intervals (e.g., 50 times a second exactly). ALL Physics interactions (`AddForce()`, collision sweeps) MUST live here to prevent tearing and tunneling.
+
+---
+
+## 2. Memory Pooling (Garbage Collection Death)
+
+In Node.js, V8 cleans up objects eventually. In Game Engines, allocating memory creates "Garbage", which forces the Garbage Collector (GC) to pause the entire game to clean up, causing massive micro-stutters.
+
+```csharp
+// ❌ FATAL (in Update loops): Creating new objects 60x a second
+void Update() {
+    Instantiate(bulletPrefab, gun.position, gun.rotation); // Kills the CPU
+}
+
+// ✅ EFFICIENT: Object Pooling
+// Pre-allocate 100 bullets during the Loading Screen.
+// Then simply toggle their active state natively.
+void Fire() {
+    Bullet b = bulletPool.GetDisabledBullet();
+    b.transform.position = gun.position;
+    b.gameObject.SetActive(true);
+}
+```
+
+---
+
+## 3. Entity Component Systems (ECS)
+
+Traditional Object-Oriented Programming (OOP) inheritance hierarchies break down in game engines.
+(e.g., `Enemy` inherits from `Character` which inherits from `Renderable`). What happens when you want a `Renderable` that isn't a `Character` but acts like an `Enemy` (like a deadly spike trap)?
+
+**Use ECS.**
+1. **Entities:** Just a meaningless ID (e.g., `Entity 304`).
+2. **Components:** Pure localized data structs attached to an ID (e.g., `Position {x: 5, y: 10}`, `Health {hp: 100}`).
+3. **Systems:** Logic that maps continuously over structs (e.g., `MovementSystem` iterates over ALL Entities that specifically have both a `Position` AND `Velocity` component).
+
+---
+
+## 4. Multiplayer Architectures
+
+Never trust the client. A multiplayer architecture dictates latency fundamentally.
+
+1. **Deterministic Lockstep (RTS / Fighting Games):**
+   - Transmits absolute ZERO game state (coordinates).
+   - Only transmits *inputs* (Player A clicked Coordinate X).
+   - Both machines run the identical physics frame simultaneously.
+   - Extremely bandwidth efficient, but requires identical CPU math output (impossible in JS floating point Math).
+
+2. **Server Authoritative with Client Prediction (Modern FPS/Action):**
+   - The Server runs the "Real" game.
+   - The Client tells the server "I fired."
+   - Because Ping takes 50ms, the Client *predicts* the shot landing locally (optimistic UI) so the player doesn't feel lag.
+   - If the server eventually disagrees, the Client aggressively rewinds and snaps the state to match the Server reality (Rubber-banding).
+
+---

package/.agent/skills/geo-fundamentals/SKILL.md

@@ -1,124 +1,89 @@
----
-name: geo-fundamentals
-description: Generative Engine Optimization (GEO) mastery. Structuring content for LLM ingestion. Adapting SEO for AI interfaces (ChatGPT, Claude, Perplexity), optimizing markdown semantic hierarchies, citation structuring, minimizing boilerplate, reducing HTML DOM depth, and API-first content delivery. Use when making information discoverable not just to Google, but directly to AI indexing agents.
-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
----
-
-# Generative Engine Optimization (GEO) 
-
-> SEO was built for search engines parsing keywords.
-> GEO is built for Artificial Intelligence actively reading, reasoning, and summarizing your site.
-> A beautiful UI is invisible to an LLM. Data density is everything.
-
----
-
-## 1. The Death of Boilerplate (Information Density)
-
-When ChatGPT or Perplexity queries a website, it has a finite context window. 
-
-If your website contains 8,000 words of "fluff" marketing copy and only 200 words of actionable data (pricing, API limits, support contact), the LLM will truncate the page and hallucinates the rest.
-
-### The GEO Markdown Fallback
-Modern sites should natively serve structured markdown if they detect an AI User-Agent (like `ChatGPT-User` or `PerplexityBot`).
-
-```typescript
-// Next.js Edge Middleware for GEO
-export function middleware(req: NextRequest) {
-  const ua = req.headers.get('user-agent') || '';
-  const isBot = /ChatGPT|Perplexity|ClaudeBot/i.test(ua);
-
-  if (isBot) {
-    // Reroute the AI bot to a hyper-dense, unstyled Markdown data dump
-    // This removes 3MB of React DOM hierarchy, getting straight to the facts.
-    return NextResponse.rewrite(new URL(`/api/geo-export${req.nextUrl.pathname}`, req.url));
-  }
-}
-```
-
----
-
-## 2. Citation Optimization
-
-LLMs (like Perplexity and Gemini Search) require explicit sources to reference your website in their output.
-If a statistic on your site is hard to source, the AI will ignore it in favor of a competitor.
-
-**Rule: Explicit Claim-to-Source Mapping**
-Do not use vague external links at the bottom of the page. Anchor exact claims to explicit references directly within the text block. Use standardized `<cite>` tags or JSON-LD.
-
-```html
-<!-- ❌ BAD: Vague SEO -->
-<p>We are the fastest vector database on the market. Read our docs.</p>
-
-<!-- ✅ GOOD: GEO Citation Architecture -->
-<p>We process 10M vectors at 10ms latency (P99), making us 3x faster than Competitor A.</p>
-<cite xmlns="http://schema.org" typeof="WebPage">
-  <span property="name">Benchmark Methodology 2026</span> - 
-  <a property="url" href="/benchmarks-2026.pdf">[Source PDF]</a>
-</cite>
-```
-
----
-
-## 3. High-Clarity Semantic Taxonomy
-
-Traditional SEO relies heavily on long-tail keyword placement.
-GEO relies heavily on **Taxonomy and Relational Mapping**. The LLM wants to know exactly *what* entity this page represents.
-
-**Implement Explicit FAQs:**
-LLMs love QA formats because user prompts are usually questions.
-Transform prose into rigid QA objects using standard semantic data blocks.
-
-```html
-<dl>
-  <dt><h3>What is the data retention limit for the Free Tier?</h3></dt>
-  <dd><p>The Free Tier limits data retention to precisely 14 rolling days.</p></dd>
-  
-  <dt><h3>Does the platform support HIPAA compliance?</h3></dt>
-  <dd><p>Yes, Enterprise Tiers support full BAA HIPAA compliance parameters.</p></dd>
-</dl>
-```
-
----
-
-## 4. API Docs Readability (The Primary AI Target)
-
-When an AI tries to write code using your product, it scrapes your API documentation.
-
-1. **Eliminate Image-Based Architecture:** Highlighting your architecture solely in a PNG graphic is invisible. Describe the system architecture using text or standard Mermaid.js code blocks.
-2. **Provide Concrete Copy-Paste Examples:** The easiest way to get an LLM to use your platform correctly is to ensure your docs contain perfectly working `curl`, `TypeScript`, and `Python` code snippets with zero external dependencies.
-
----
-
-## 🤖 LLM-Specific Traps (GEO)
-
-1. **Confusing GEO with SEO:** Prioritizing `<title>` lengths and stuffing keyword permutations instead of increasing Information-Density and Semantic Clarity.
-2. **The JavaScript Hydration Trap:** Generating intricate React components to render critical data (like Pricing Tables). AI bots generally do not execute/hydrate heavy JS payloads; the pricing data will simply be invisible to them. Serve critical data statically.
-3. **Fluff Generation:** An AI writing content for a site adds 3 paragraphs of "In today's fast-paced digital world..." — this destroys GEO ranking immediately because it dilutes the token value of the actual data payload.
-4. **Hiding Core Answers:** Placing the direct answer to a query behind a massive scroll or an interactive accordion (e.g., `<details>`) wrapper. AI bots do not "click" UI elements to expand text. Content must be universally visible in the initial DOM tree.
-5. **PDF Isolation:** Posting critical documentation exclusively in heavy PDF formats without an associated HTML/Markdown mirror, drastically raising the ingestion cost for rapid-search AI engines.
-6. **No Code Snippets:** Explaining an API operation purely in English without a concrete JSON payload example block. LLMs map patterns mathematically; they require structured syntax to ingest.
-7. **Ignoring Bot-Specific Routing:** Failing to architect conditional User-Agent routing that serves plain Markdown to `PerplexityBot`, wasting bot execution cycles downloading 4MB CSS/JS assets.
-8. **Broken Schema Contexts:** Using unstructured `<div>` blocks for QA formats instead of the semantic Dictionary List (`<dl>`, `<dt>`, `<dd>`) pattern which LLMs easily recognize as Question-Answer pairings.
-9. **Citation Voids:** Making bold factual claims on a web page without immediately adjacent explicit citation tags. Generative engines will drop the claim to avoid adopting hallucination risks.
-10. **The Image Trap:** Stating "See the map above for instructions" instead of generating an actual HTML table mapping the data. AI engines prioritize textual semantic extraction.
-
----
-
-## 🏛️ Tribunal Integration
-
-### ✅ Pre-Flight Self-Audit
-```
-✅ Has marketing 'fluff' been aggressively minimized to maximize dense, actionable data tokens?
-✅ Are critical data interfaces (Pricing, API limits, FAQs) rendered fully static (SSR), bypassing JS hydration?
-✅ Did I rely on semantic Dict-Lists (`<dl>`) to format FAQ structures cleanly for LLM parsing?
-✅ Are factual metrics explicitly tethered to proximate `<cite>` or `<a>` reference sources?
-✅ Has an API-first representation (Markdown mirror) been established for bot User-Agents?
-✅ Ensure that architectural definitions are described in text/code rather than solely raster images.
-✅ Did I include concrete, copy-pasteable JSON/TypeScript examples adjacent to any API definition?
-✅ Have interactive elements (`accordions`, modals) been disabled/expanded for indexing bots?
-✅ Have classic SEO keyword-stuffing patterns been deleted in favor of clear Entity Relationships?
-✅ Has all essential documentation been verified to exist natively in the primary HTML DOM payload?
-```
+---
+name: geo-fundamentals
+description: Generative Engine Optimization (GEO) mastery. Structuring content for LLM ingestion. Adapting SEO for AI interfaces (ChatGPT, Claude, Perplexity), optimizing markdown semantic hierarchies, citation structuring, minimizing boilerplate, reducing HTML DOM depth, and API-first content delivery. Use when making information discoverable not just to Google, but directly to AI indexing agents.
+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
+---
+
+# Generative Engine Optimization (GEO) 
+
+---
+
+## 1. The Death of Boilerplate (Information Density)
+
+When ChatGPT or Perplexity queries a website, it has a finite context window. 
+
+If your website contains 8,000 words of "fluff" marketing copy and only 200 words of actionable data (pricing, API limits, support contact), the LLM will truncate the page and hallucinates the rest.
+
+### The GEO Markdown Fallback
+Modern sites should natively serve structured markdown if they detect an AI User-Agent (like `ChatGPT-User` or `PerplexityBot`).
+
+```typescript
+// Next.js Edge Middleware for GEO
+export function middleware(req: NextRequest) {
+  const ua = req.headers.get('user-agent') || '';
+  const isBot = /ChatGPT|Perplexity|ClaudeBot/i.test(ua);
+
+  if (isBot) {
+    // Reroute the AI bot to a hyper-dense, unstyled Markdown data dump
+    // This removes 3MB of React DOM hierarchy, getting straight to the facts.
+    return NextResponse.rewrite(new URL(`/api/geo-export${req.nextUrl.pathname}`, req.url));
+  }
+}
+```
+
+---
+
+## 2. Citation Optimization
+
+LLMs (like Perplexity and Gemini Search) require explicit sources to reference your website in their output.
+If a statistic on your site is hard to source, the AI will ignore it in favor of a competitor.
+
+**Rule: Explicit Claim-to-Source Mapping**
+Do not use vague external links at the bottom of the page. Anchor exact claims to explicit references directly within the text block. Use standardized `<cite>` tags or JSON-LD.
+
+```html
+<!-- ❌ BAD: Vague SEO -->
+<p>We are the fastest vector database on the market. Read our docs.</p>
+
+<!-- ✅ GOOD: GEO Citation Architecture -->
+<p>We process 10M vectors at 10ms latency (P99), making us 3x faster than Competitor A.</p>
+<cite xmlns="http://schema.org" typeof="WebPage">
+  <span property="name">Benchmark Methodology 2026</span> - 
+  <a property="url" href="/benchmarks-2026.pdf">[Source PDF]</a>
+</cite>
+```
+
+---
+
+## 3. High-Clarity Semantic Taxonomy
+
+Traditional SEO relies heavily on long-tail keyword placement.
+GEO relies heavily on **Taxonomy and Relational Mapping**. The LLM wants to know exactly *what* entity this page represents.
+
+**Implement Explicit FAQs:**
+LLMs love QA formats because user prompts are usually questions.
+Transform prose into rigid QA objects using standard semantic data blocks.
+
+```html
+<dl>
+  <dt><h3>What is the data retention limit for the Free Tier?</h3></dt>
+  <dd><p>The Free Tier limits data retention to precisely 14 rolling days.</p></dd>
+  
+  <dt><h3>Does the platform support HIPAA compliance?</h3></dt>
+  <dd><p>Yes, Enterprise Tiers support full BAA HIPAA compliance parameters.</p></dd>
+</dl>
+```
+
+---
+
+## 4. API Docs Readability (The Primary AI Target)
+
+When an AI tries to write code using your product, it scrapes your API documentation.
+
+1. **Eliminate Image-Based Architecture:** Highlighting your architecture solely in a PNG graphic is invisible. Describe the system architecture using text or standard Mermaid.js code blocks.
+2. **Provide Concrete Copy-Paste Examples:** The easiest way to get an LLM to use your platform correctly is to ensure your docs contain perfectly working `curl`, `TypeScript`, and `Python` code snippets with zero external dependencies.
+
+---