tribunal-kit 9.0.0 → 9.0.2

package/.agent/skills/ai-prompt-injection-defense/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: ai-prompt-injection-defense
-description: Prompt Injection and Jailbreak defense mastery. Mitigation strategies for direct injection, indirect injection via data poisoning, delimiter separation, XML framing, output validation, and LLM circuit breakers. Use when building AI systems that process untrusted user input or fetch external data.
-tools: Read, Grep, Glob, Bash, Edit, Write
-version: 4.0.0
-last-updated: 2026-09-07
+description: Use when Prompt Injection and Jailbreak defense mastery. Mitigation strategies for direct injection, indirect injection via data poisoning, delimiter separation, XML framing, output validation, and LLM circuit breakers. Use when building AI systems that process untrusted user input or fetch external data.
+version: 5.0.0
+last-updated: 2026-09-13
 skills:
   - backend-security-expert
   - vulnerability-scanner
   - llm-engineering
+tools: Read, Grep, Glob, Bash, Edit, Write
 scripts-binding:
   - .agent/scripts/lint_runner.js
   - .agent/scripts/verify_all.js
@@ -15,21 +15,41 @@ scripts-binding:
 
 # Prompt Injection Defense — AI Security Mastery
 
----
-
 ## Mandatory Pre-Flight Context Inspection
 
-Before engineering LLM prompts or processing untrusted user input, you MUST inspect:
+Before generating, refactoring, or reviewing code in the `ai-prompt-injection-defense` domain, inspect these 5 critical parameters:
 
-1. Message Role Isolation → Place user input exclusively in `role: "user"` messages; never concatenate user input into `role: "system"`
-2. Random Nonce Delimiters → Frame untrusted third-party or user input inside unique XML nonces (`<untrusted_data id="x7f9a2">`) to prevent escape attacks
-3. Dual-LLM Architecture for Untrusted Content → Process untrusted web/file content using an unprivileged reader LLM before feeding distilled output to the tool-calling agent
-4. Tool Call Argument Schema Validation → Validate all arguments emitted by LLM function calls with strict schemas before execution
+1. **System Boundaries & Dependencies**: Verify that all required dependencies exist in target package manifests and environment paths.
+2. **Runtime Context & Platform Invariants**: Confirm target platform constraints (Node.js, Browser, Mobile OS, Edge runtime) before applying APIs.
+3. **Execution Guardrails**: Identify potential side-effects, state mutations, and unhandled asynchronous exceptions.
+4. **Validation & Type Contracts**: Validate input data schemas and strict type constraints across all module interfaces.
+5. **Observability & Proof of Execution**: Ensure execution produces tangible verification signals (terminal output, tests, metrics).
 
 ## Activation Boundaries
 
-- **Activate when:** Building LLM integrations, prompt engineering, agent tool calling pipelines, RAG ingestion, and auditing AI security against prompt injection.
-- **DO NOT activate when:** Writing standard deterministic backend algorithms without LLM inference.
+- **Activate when:** Use when Prompt Injection and Jailbreak defense mastery. Mitigation strategies for direct injection, indirect injection via data poisoning, delimiter separation, XML framing, output validation, and LLM circuit breakers. Use when building AI systems that process untrusted user input or fetch external data.
+- **DO NOT activate when:** The task falls outside the `ai-prompt-injection-defense` domain or is managed by a different dedicated specialist.
+
+## 🔁 Multi-Pass Execution Protocol
+
+Execute all non-trivial tasks through this 7-pass cognitive loop:
+
+| Pass | Phase | Core Action |
+|:---|:---|:---|
+| **Pass 1** | **Understand** | Deconstruct the user's explicit objective, implicit requirements, and platform constraints. |
+| **Pass 2** | **Plan** | Decompose the task into smallest logical steps; map dependencies and required tool calls. |
+| **Pass 3** | **Execute** | Implement the solution with production-grade craft, zero placeholders, and strict typing. |
+| **Pass 4** | **Verify** | Run linters, unit tests, or compiler checks to validate structural correctness. |
+| **Pass 5** | **Attack** | Perform an adversarial review searching for edge-case failures, race conditions, and traps. |
+| **Pass 6** | **Improve** | Eliminate discovered friction, optimize performance, and harden error boundaries. |
+| **Pass 7** | **Quality Gate** | Enforce Verification-Before-Completion (VBC) with concrete terminal proof before finalizing. |
+
+---
+
+## 🛠️ Technical Architecture & Reference Recipes
+
+---
+
 
 ## 2026 AI Prompt Injection & Sandboxing Invariants
 
@@ -173,37 +193,45 @@ Many injections occur because the LLM includes malicious data in its output, whi
 
 ---
 
+## 🚨 Edge-Case & Failure Mode Matrix
+
+| Scenario | Risk | Mitigation Strategy |
+|:---|:---|:---|
+| **Empty or Null Inputs** | Unhandled exception or unexpected rendering collapse | Enforce fallback guards, optional chaining, and explicit empty state handlers |
+| **Network Timeout / Latency** | Hanging operations or duplicate side-effects | Implement bounded abort controllers, exponential backoff, and idempotency keys |
+| **Concurrency / Race Conditions** | Stale state overwrite or inconsistent data mutations | Use atomic transactions, mutex locking, or cancel-on-resubmit controls |
+| **Invalid Schema / Malformed Payload** | Downstream runtime errors or security injection | Validate boundary payloads with Zod/Pydantic schemas prior to execution |
+| **Resource / Memory Saturation** | OOM errors, frame drops, or memory leaks | Clean up listeners, cancel active timers, and enforce pagination/virtualization |
+
 ---
 
-AI coding assistants often fall into specific bad habits when dealing with this domain. These are strictly forbidden:
+## 🤖 LLM-Specific Traps Table
 
-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.
+| Anti-Pattern | What AI Commonly Does Wrong | What Is Actually Correct |
+|:---|:---|:---|
+| **Hardcoded Secret Pattern** | Committing API keys, tokens, or private salts into source code | Load credentials strictly via runtime environment variables and secret stores |
+| **Prompt Injection Surface** | Directly concatenating untrusted user input into LLM system prompts | Wrap user content in isolated delimiters and strip injection control sequences |
+| **Missing Authorization Check** | Relying only on authentication token presence without checking tenant/object RBAC | Verify user permissions against the specific target record ID before mutation |
 
 ---
 
 ## 🏛️ Tribunal Verification & Guardrails
 
-**Slash command: `/review` or `/tribunal-full`**
-**Active reviewers: `logic-reviewer` · `security-auditor`**
+**Active Reviewers:** `security-auditor` · `penetration-tester` · `backend-security-expert`
+**Slash Command:** `/review` or `/tribunal-full`
 
-### ❌ 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 Checklist
 
-### ✅ Pre-Flight Self-Audit
 ```
-✅ 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?
+✅ Are user inputs sanitized and treated as untrusted at system boundaries?
+✅ Are secrets loaded strictly via environment variables with zero hardcoding?
+✅ Is least-privilege enforcement active on APIs, tokens, and storage buckets?
+✅ Are prompt-injection delimiters and sanitizers wrapped around LLM inputs?
+✅ Did I verify encryption in transit and at rest for sensitive customer data?
 ```
 
 ### 🛑 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.
+- ✅ **Required:** You are explicitly forbidden from finalizing any task without providing **concrete evidence** (terminal output, passing test suites, compiler success, or equivalent operational proof) that your output works as intended.

package/.agent/skills/animation-on-scroll/SKILL.md

@@ -1,89 +1,199 @@
 ---
 name: animation-on-scroll
-description: Intentional scroll-driven motion using modern CSS scroll-timeline, view-timeline, or GSAP ScrollTrigger without scroll jank or performance degradation.
-version: 4.0.0
-last-updated: 2026-09-07
+description: Use when building performant scroll-driven animations, CSS scroll-timeline, view-timeline reveals, GSAP ScrollTrigger scrollytelling, or Framer Motion scroll indicators without scroll jank or layout thrashing.
+version: 5.0.0
+last-updated: 2026-09-13
 skills:
   - motion-engineering
   - 60fps-animation
   - accessible-animation
+  - review-animations
 tools: Read, Grep, Glob, Bash, Edit, Write
 scripts-binding:
   - .agent/scripts/lint_runner.js
   - .agent/scripts/verify_all.js
 ---
 
-# Animation On Scroll — Intentional Scroll Motion
+# Animation On Scroll — Precision Scroll-Driven Architecture & Scrollytelling
+
+## Mandatory Pre-Flight Context Inspection
+
+Before generating, refactoring, or reviewing code in the `animation-on-scroll` domain, inspect these 5 critical parameters:
+
+1. **System Boundaries & Dependencies**: Verify that all required dependencies exist in target package manifests and environment paths.
+2. **Runtime Context & Platform Invariants**: Confirm target platform constraints (Node.js, Browser, Mobile OS, Edge runtime) before applying APIs.
+3. **Execution Guardrails**: Identify potential side-effects, state mutations, and unhandled asynchronous exceptions.
+4. **Validation & Type Contracts**: Validate input data schemas and strict type constraints across all module interfaces.
+5. **Observability & Proof of Execution**: Ensure execution produces tangible verification signals (terminal output, tests, metrics).
+
+## Activation Boundaries
+
+- **Activate when:** Use when building performant scroll-driven animations, CSS scroll-timeline, view-timeline reveals, GSAP ScrollTrigger scrollytelling, or Framer Motion scroll indicators without scroll jank or layout thrashing.
+- **DO NOT activate when:** The task falls outside the `animation-on-scroll` domain or is managed by a different dedicated specialist.
+
+## 🔁 Multi-Pass Execution Protocol
+
+Execute all non-trivial tasks through this 7-pass cognitive loop:
+
+| Pass | Phase | Core Action |
+|:---|:---|:---|
+| **Pass 1** | **Understand** | Deconstruct the user's explicit objective, implicit requirements, and platform constraints. |
+| **Pass 2** | **Plan** | Decompose the task into smallest logical steps; map dependencies and required tool calls. |
+| **Pass 3** | **Execute** | Implement the solution with production-grade craft, zero placeholders, and strict typing. |
+| **Pass 4** | **Verify** | Run linters, unit tests, or compiler checks to validate structural correctness. |
+| **Pass 5** | **Attack** | Perform an adversarial review searching for edge-case failures, race conditions, and traps. |
+| **Pass 6** | **Improve** | Eliminate discovered friction, optimize performance, and harden error boundaries. |
+| **Pass 7** | **Quality Gate** | Enforce Verification-Before-Completion (VBC) with concrete terminal proof before finalizing. |
 
 ---
 
-## Mandatory Pre-Flight Context Inspection
+## 🛠️ Technical Architecture & Reference Recipes
 
-Before implementing scroll-driven animations, you MUST inspect:
+Scroll motion connects physical gesture with dynamic interface reveals. Poorly engineered scroll animations hijack the native scroll wheel, introduce frame drops by calculating `getBoundingClientRect()` inside unthrottled scroll listeners, or cause pin spacers to collapse layouts. Master-grade scroll architecture executes directly on the browser compositor layer using native CSS `animation-timeline` when possible, leverages GSAP `ScrollTrigger` with subpixel pinning offsets for complex timelines, and strictly obeys the Anti-Scrolljacking rule.
 
-1. Target browser support → Prefer pure CSS `animation-timeline: view()` / `scroll()` when possible
-2. Pinning & Scrubbing rules (Section 45) → Use `scrub: 1` in GSAP ScrollTrigger timelines for smooth inertia
-3. Anti-Scrolljacking rule (Section 88) → Never hijack native scroll wheel momentum or override browser scrolling velocity
+---
 
-Architect performant scroll-linked motion and scrollytelling sequences that feel natural, fluid, and non-intrusive.
 
+---
 
-## Activation Boundaries
 
-- **Activate when:** Operating in tasks requiring Intentional scroll-driven motion using modern CSS scroll-timeline, view-timeline, or GSAP ScrollTrigger without scroll jank or performance degradation..
-- **DO NOT activate when:** The task falls strictly outside animation-on-scroll domain or belongs to a different dedicated specialist.
+---
+
 
 ---
 
-## 3 Scroll-Driven Architecture Patterns
+## 🛠️ Technical Architecture & Reference Recipes
+
+### 1. Engine Selection Matrix
 
-### 1. Modern Pure CSS `view-timeline` (No JavaScript Required)
+| Use Case | Recommended Engine | Rationale |
+|:---|:---|:---|
+| **Single-Element Entrance Wipe** | Pure CSS `animation-timeline: view()` | 0 KB JS overhead, executes on GPU compositor thread |
+| **Page-Top Progress Indicator** | Pure CSS `animation-timeline: scroll()` | Zero re-renders, zero layout shifts |
+| **Multi-Stage Pinned Scrollytelling** | GSAP `ScrollTrigger` | Pin spacer mechanics, scrubbing interpolation, timeline nesting |
+| **React Component State Scrubbing** | Framer Motion `useScroll` + `useTransform` | Declarative hook integration with React rendering lifecycle |
+
+---
+
+### 2. Four Production-Grade Implementation Recipes
+
+#### Recipe 1: Modern Pure CSS `view-timeline` Card Entrance
 
 ```css
-@keyframes reveal-on-scroll {
-  from {
+@keyframes card-scrub-reveal {
+  0% {
     opacity: 0;
-    transform: translateY(32px) scale(0.96);
+    transform: translateY(48px) scale(0.94);
   }
-  to {
+  100% {
     opacity: 1;
     transform: translateY(0) scale(1);
   }
 }
 
 .scroll-reveal-card {
-  animation: reveal-on-scroll linear both;
-  animation-timeline: view();
-  animation-range: entry 10% cover 30%;
+  /* Fallback for browsers without animation-timeline support */
+  opacity: 1;
+  transform: none;
+}
+
+@supports (animation-timeline: view()) {
+  .scroll-reveal-card {
+    view-timeline-name: --card-timeline;
+    view-timeline-axis: block;
+    animation: card-scrub-reveal ease-out both;
+    animation-timeline: --card-timeline;
+    /* Triggers when card enters bottom 10% of viewport and finishes at 35% */
+    animation-range: entry 10% cover 35%;
+  }
 }
 ```
 
-### 2. Sticky Canvas / Section Pinned Storytelling (GSAP ScrollTrigger)
+---
+
+#### Recipe 2: Sticky Pinned Scrollytelling Sequence (GSAP ScrollTrigger)
 
-```javascript
-import { gsap } from 'gsap';
+```typescript
+import gsap from 'gsap';
 import { ScrollTrigger } from 'gsap/ScrollTrigger';
 
 gsap.registerPlugin(ScrollTrigger);
 
-gsap
-  .timeline({
+export function initScrollytelling(container: HTMLElement) {
+  const steps = container.querySelectorAll('.story-step');
+
+  const tl = gsap.timeline({
     scrollTrigger: {
-      trigger: '.story-container',
+      trigger: container,
       start: 'top top',
-      end: '+=200%',
+      end: () => `+=${steps.length * 100}%`,
       pin: true,
-      scrub: 1, // Smooth scrub delay
+      anticipatePin: 1,
+      scrub: 0.8, // Smooth momentum scrub
+      invalidateOnRefresh: true, // Recalibrate on window resize
     },
-  })
-  .to('.story-step-1', { opacity: 0, y: -20 })
-  .from('.story-step-2', { opacity: 0, y: 20 });
+  });
+
+  steps.forEach((step, index) => {
+    if (index === 0) return;
+    tl.to(steps[index - 1], { opacity: 0, y: -30, duration: 0.4 })
+      .fromTo(step, { opacity: 0, y: 40 }, { opacity: 1, y: 0, duration: 0.6 }, '-=0.2');
+  });
+
+  return () => {
+    tl.kill();
+    ScrollTrigger.getAll().forEach(t => t.kill());
+  };
+}
+```
+
+---
+
+#### Recipe 3: Framer Motion Reactive Scrubbing with Spring Damping
+
+```tsx
+import React, { useRef } from 'react';
+import { motion, useScroll, useTransform, useSpring } from 'framer-motion';
+
+export function ParallaxHeroCard() {
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  const { scrollYProgress } = useScroll({
+    target: containerRef,
+    offset: ['start end', 'end start'],
+  });
+
+  // Apply spring physics to prevent jerky scroll jumps on trackpads
+  const smoothProgress = useSpring(scrollYProgress, {
+    stiffness: 280,
+    damping: 35,
+    restDelta: 0.001,
+  });
+
+  const scale = useTransform(smoothProgress, [0, 0.5, 1], [0.85, 1, 0.95]);
+  const y = useTransform(smoothProgress, [0, 1], [60, -60]);
+  const opacity = useTransform(smoothProgress, [0, 0.25, 0.75, 1], [0, 1, 1, 0]);
+
+  return (
+    <div ref={containerRef} className="relative min-h-[140vh] flex items-center justify-center">
+      <motion.div
+        style={{ scale, y, opacity }}
+        className="sticky top-24 w-full max-w-2xl p-8 rounded-3xl bg-neutral-900 border border-neutral-800 shadow-2xl"
+      >
+        <h2 className="text-2xl font-semibold text-white">Fluid Reactive Scrubbing</h2>
+        <p className="mt-2 text-neutral-400">Zero unthrottled scroll listeners. Offloaded to motion GPU pipeline.</p>
+      </motion.div>
+    </div>
+  );
+}
 ```
 
-### 3. Scroll Progress Indicator Bar
+---
+
+#### Recipe 4: Hardware-Accelerated Progress Indicator (CSS `scroll()`)
 
 ```css
-@keyframes grow-progress {
+@keyframes scale-progress {
   from {
     transform: scaleX(0);
   }
@@ -92,40 +202,66 @@ gsap
   }
 }
 
-.scroll-progress-bar {
+.scroll-progress-line {
   position: fixed;
   top: 0;
   left: 0;
   right: 0;
   height: 3px;
-  background: var(--primary);
+  background: linear-gradient(90deg, #6366f1, #a855f7);
   transform-origin: 0% 50%;
-  animation: grow-progress linear;
-  animation-timeline: scroll();
+  will-change: transform;
+}
+
+@supports (animation-timeline: scroll()) {
+  .scroll-progress-line {
+    animation: scale-progress linear both;
+    animation-timeline: scroll(root block);
+  }
 }
 ```
 
 ---
 
+## 🚨 Edge-Case & Failure Mode Matrix
+
+| Scenario | Risk | Mitigation Strategy |
+|:---|:---|:---|
+| **Empty or Null Inputs** | Unhandled exception or unexpected rendering collapse | Enforce fallback guards, optional chaining, and explicit empty state handlers |
+| **Network Timeout / Latency** | Hanging operations or duplicate side-effects | Implement bounded abort controllers, exponential backoff, and idempotency keys |
+| **Concurrency / Race Conditions** | Stale state overwrite or inconsistent data mutations | Use atomic transactions, mutex locking, or cancel-on-resubmit controls |
+| **Invalid Schema / Malformed Payload** | Downstream runtime errors or security injection | Validate boundary payloads with Zod/Pydantic schemas prior to execution |
+| **Resource / Memory Saturation** | OOM errors, frame drops, or memory leaks | Clean up listeners, cancel active timers, and enforce pagination/virtualization |
+
+---
+
+## 🤖 LLM-Specific Traps Table
+
+| Anti-Pattern | What AI Commonly Does Wrong | What Is Actually Correct |
+|:---|:---|:---|
+| **The Instant Pop Trap** | Conditionally unmounting elements without animated interpolation | Use AnimatePresence or coordinate morphs with continuous geometry |
+| **Layout Thrashing** | Animating width, height, top, or left inside animation loops | Animate composite-only transform (translate3d, scale) and opacity |
+| **Sluggish Duration** | Setting micro-interaction transitions to 600ms+ causing interface lag | Cap interactive feedback at 160ms–240ms with snappy ease-out curves |
+
+---
+
 ## 🏛️ Tribunal Verification & Guardrails
 
-**Slash command: `/review` or `/tribunal-full`**
-**Active reviewers: `logic-reviewer` · `security-auditor`**
+**Active Reviewers:** `frontend-reviewer` · `motion-reviewer` · `ui-ux-auditor`
+**Slash Command:** `/review` or `/tribunal-full`
 
-### ❌ 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 Checklist
 
-### ✅ Pre-Flight Self-Audit
 ```
-✅ 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?
+✅ Does animation maintain 60fps/120fps using transform and opacity?
+✅ Is optical mass conserved across state interpolations without volume collapse?
+✅ Is duration capped within micro-interaction budgets (160ms–280ms)?
+✅ Is prefers-reduced-motion respected with graceful instant fallbacks?
+✅ Did I prevent layout thrashing and continuous geometry mutations?
 ```
 
 ### 🛑 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.
+- ✅ **Required:** You are explicitly forbidden from finalizing any task without providing **concrete evidence** (terminal output, passing test suites, compiler success, or equivalent operational proof) that your output works as intended.