tribunal-kit 6.0.0 → 7.0.0

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

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before applying animation principles to web components, you MUST inspect:
+
 1. Target interaction pattern → Identify applicability of Squash & Stretch, Anticipation, Slow In/Out, or Follow Through
 2. Volume-Preservation Rule (Section 26) → Keep UI squash/stretch subtle (max 2%-4%); if height scales to 0.97, width MUST scale to 1.03
 3. Staging Rules (Section 31) → Direct user focus with sequential motion rather than competing simultaneous animations
@@ -31,22 +32,28 @@ Translate Disney's 12 classic principles of animation into modern CSS, Web API,
 ## The 6 Essential Web Principles
 
 ### 1. Squash & Stretch (Scale Elasticity)
+
 - Compress elements slightly on impact (e.g. button press down `scale(0.97)`), then stretch slightly on release (`scale(1.02)` -> `scale(1)`).
 - **Rule**: Preserve overall volume. If height decreases by 5%, width must expand by 5%.
 
 ### 2. Anticipation (Pre-Motion Cue)
+
 - Before a major movement (e.g. modal sliding up), perform a micro-backwards movement (e.g. shift down `2px` for `40ms`) to prepare the user's eye.
 
 ### 3. Staging (Focus & Spatial Hierarchy)
+
 - Direct user attention to one primary animation at a time. Never animate competing layout elements across different regions simultaneously.
 
 ### 4. Slow In & Slow Out (Easing Curves)
+
 - Objects in nature start slow, accelerate, and decelerate gradually. Use strong ease-out curves (`cubic-bezier(0.16, 1, 0.3, 1)`) for UI entrances.
 
 ### 5. Arcs (Natural Curvilinear Trajectories)
+
 - Human arms and physical objects move in curved arcs rather than mechanical straight lines. When moving elements across 2D space, use parabolic bezier curves or `offset-path`.
 
 ### 6. Follow Through & Overlapping Action
+
 - Secondary elements (e.g. badge text inside a sliding card) lag slightly behind the main container (stagger delay 30ms - 50ms), creating organic physical realism.
 
 ---

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

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before writing animation CSS or JS, you MUST inspect:
+
 1. Target animated properties → Strictly enforce GPU compositor-only properties (`transform`, `opacity`) and ban layout-triggering properties (`width`, `height`, `top`, `left`)
 2. Scale Math Replacement (Section 29) → Use `transform: scaleX(2)` instead of animating `width`
 3. `will-change` VRAM Management (Section 45) → Apply `will-change` dynamically during active animation and remove upon completion
@@ -31,12 +32,16 @@ Eliminate jank, layout thrashing, and frame drops to achieve locked 60fps / 120f
 ## 4 Performance Rules
 
 ### 1. Compositor-Only Animation Pipeline
+
 Only animate properties handled strictly by the GPU compositor layer:
+
 - ✅ **Compositor Properties** (Zero Layout / Zero Paint): `transform` (`translate3d`, `scale`, `rotate`) and `opacity`.
 - ❌ **Forbidden Animating Properties** (Triggers Full Layout Re-calculation): `width`, `height`, `margin`, `padding`, `top`, `left`, `border-width`.
 
 ### 2. Replacing Width/Height Transitions with Scale Math
+
 Instead of animating `width: 100px` to `200px`:
+
 ```css
 /* BAD: Triggers Layout recalculation on every frame */
 .box-bad {
@@ -52,10 +57,12 @@ Instead of animating `width: 100px` to `200px`:
 ```
 
 ### 3. `will-change` Management
+
 - Apply `will-change: transform, opacity` ONLY right before or during active animation.
 - Remove `will-change` when animation completes to free up GPU VRAM memory!
 
 ### 4. Layout Thrashing Prevention in JS
+
 - Never interleave DOM reads (`element.offsetHeight`) with DOM writes (`element.style.height = ...`) inside requestAnimationFrame or scroll handlers. Batch all reads first, then perform all writes.
 
 ---

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

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before implementing UI animation code, you MUST inspect:
+
 1. CSS stylesheets → Verify presence of `@media (prefers-reduced-motion: reduce)` rules
 2. Framer Motion / GSAP components → Query `useReducedMotion()` or `matchMedia('(prefers-reduced-motion: reduce)')`
 3. Vestibular Trigger Replacement (Section 57) → Replace parallax scroll and 3D rotations with instant opacity cross-fades (`0 -> 1`)
@@ -31,6 +32,7 @@ Ensure UI motion respects user accessibility preferences (`prefers-reduced-motio
 ## 3 Tiered Reduced-Motion Rules
 
 ### Tier 1: CSS Reduced Motion Media Query
+
 ```css
 @media (prefers-reduced-motion: reduce) {
   *,
@@ -45,8 +47,9 @@ Ensure UI motion respects user accessibility preferences (`prefers-reduced-motio
 ```
 
 ### Tier 2: React & Framer Motion Hook (`useReducedMotion`)
+
 ```tsx
-import { useReducedMotion, motion } from "framer-motion";
+import { useReducedMotion, motion } from 'framer-motion';
 
 export function AccessibleCard({ children }) {
   const shouldReduceMotion = useReducedMotion();
@@ -64,6 +67,7 @@ export function AccessibleCard({ children }) {
 ```
 
 ### Tier 3: Replacing Parallax & Vestibular Triggers with Instant Fades
+
 - Disorienting motions (parallax scrolling, 3D rotations, zoom scaling) MUST be converted into instant cross-fades (`opacity: 0 -> 1`) when `prefers-reduced-motion: reduce` is active.
 
 ---

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

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before engineering responsive layouts or cross-device UIs, you MUST inspect:
+
 1. Container Queries (`@container`) over Viewport Media Queries (Section 24) → Adapt component layouts based on parent container width (`container-type: inline-size`)
 2. Touch Target Sizing (Section 39) → Ensure interactive controls meet min `44x44px` target size on touch devices
 3. Fluid Clamp Scaling (Section 45) → Use `clamp()` for smooth fluid typography and spacing without abrupt media query jumps
@@ -31,7 +32,9 @@ Architect UIs that adapt fluidly to screen dimensions, container boundaries, inp
 ## 4 Adaptation Mechanics
 
 ### 1. Container Queries (`@container`) over Viewport Media Queries (`@media`)
+
 - Components should adapt based on their parent container's width, NOT the global browser window size:
+
 ```css
 .card-container {
   container-type: inline-size;
@@ -46,14 +49,17 @@ Architect UIs that adapt fluidly to screen dimensions, container boundaries, inp
 ```
 
 ### 2. Touch Target Sizing (Min 44x44px)
+
 - Interactive targets on mobile/touch interfaces MUST maintain a minimum tap target size of `44x44px` (or `48x48px` for Android), even if the visual icon is smaller (`16px`).
 
 ### 3. Drawer on Mobile -> Modal on Desktop
+
 - Complex popovers or dialogs on mobile screens should render as bottom sheets (drawers) with drag-to-dismiss handles, automatically morphing into centered modals on desktop viewports ($\ge 768\text{px}$).
 
 ### 4. Fluid Typography & Spacing
+
 - Use `clamp()` for fluid scaling without abrupt media query jumps:
-$$\text{FontSize} = \text{clamp}(1\text{rem}, 0.8\text{rem} + 1\text{vw}, 1.75\text{rem})$$
+  $$\text{FontSize} = \text{clamp}(1\text{rem}, 0.8\text{rem} + 1\text{vw}, 1.75\text{rem})$$
 
 ---
 

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

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before building RAG pipelines or vector search components, you MUST inspect:
+
 1. Hybrid Search Requirement (Section 16) → Always combine Dense Vector Search with Sparse BM25 Search to catch exact keyword matches (IDs, versions)
 2. Two-Stage Reranking Pipeline (Section 29) → Retrieve top ~50 candidate chunks, then rerank with a Cross-Encoder down to top 3-5 before feeding the LLM
 3. Context XML Framing (Section 59) → Wrap retrieved chunks inside explicit `<context>` XML tags in the prompt to prevent indirect prompt injection

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

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before dispatching multi-agent tasks, you MUST inspect:
+
 1. `swarm-worker-registry.md` / `task.md` → Verify target worker agents and global execution state
 2. Context Window Budget rules (Section 1) → Trim worker payload context to max 3 files per dispatch
 3. Handoff state signals (`COMPLETE`, `BLOCKED`, `ERROR`) → Verify terminal status handling rules

package/.agent/skills/agentic-patterns/SKILL.md

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before designing agentic loops, tool schemas, or memory architectures, you MUST inspect:
+
 1. `package.json` / LLM SDK definitions → Check tool calling syntax (Zod schemas, OpenAI/Anthropic function calling API)
 2. Agent Loop boundaries (Section 1) → Define hard caps on `MAX_STEPS` (default: 10) and explicit termination reasons
 3. Human-in-the-loop gates (Section 5) → Ensure approval gates for destructive, data-deleting, or high-cost API calls
@@ -45,7 +46,7 @@ PERCEIVE → PLAN → ACT → OBSERVE → (repeat or terminate)
 ```ts
 // The three termination conditions — always define all three
 type AgentResult = {
-  reason: "goal_reached" | "max_steps_exceeded" | "human_escalation";
+  reason: 'goal_reached' | 'max_steps_exceeded' | 'human_escalation';
   steps: number;
   result: string;
 };
@@ -63,23 +64,24 @@ Tools are the agent's interface to the real world. Design them defensively:
 // Tool definition — what the LLM sees and how to call it
 const tools = [
   {
-    type: "function",
+    type: 'function',
     function: {
-      name: "search_database",
-      description: "Search the product database. Use this before creating a new record to avoid duplicates.",
+      name: 'search_database',
+      description:
+        'Search the product database. Use this before creating a new record to avoid duplicates.',
       parameters: {
-        type: "object",
+        type: 'object',
         properties: {
           query: {
-            type: "string",
-            description: "Search terms — be specific",
+            type: 'string',
+            description: 'Search terms — be specific',
           },
           limit: {
-            type: "number",
-            description: "Max results to return. Default: 5, max: 20",
+            type: 'number',
+            description: 'Max results to return. Default: 5, max: 20',
           },
         },
-        required: ["query"],
+        required: ['query'],
       },
     },
   },
@@ -145,10 +147,13 @@ async function buildContext(userId: string, currentQuery: string) {
   });
 
   return [
-    { role: "system", content: systemPrompt },
+    { role: 'system', content: systemPrompt },
     // Inject relevant past context — NOT entire history
-    { role: "system", content: `Relevant past context:\n${pastMemories.map((m) => m.content).join("\n")}` },
-    { role: "user", content: currentQuery },
+    {
+      role: 'system',
+      content: `Relevant past context:\n${pastMemories.map(m => m.content).join('\n')}`,
+    },
+    { role: 'user', content: currentQuery },
   ];
 }
 ```
@@ -175,7 +180,10 @@ Supervisor agent ─→ breaks task into subtasks
 
 ```ts
 // Two independent agents answer the same question — supervisor resolves disagreement
-const [answerA, answerB] = await Promise.all([agentA.complete(question), agentB.complete(question)]);
+const [answerA, answerB] = await Promise.all([
+  agentA.complete(question),
+  agentB.complete(question),
+]);
 
 if (answerA.answer === answerB.answer) {
   return answerA; // Agreement — high confidence
@@ -209,13 +217,13 @@ async function agentLoop(task: string) {
         reason: planned.reasoning,
         confidence: planned.confidence,
       });
-      if (!approved) return { reason: "human_rejected", step };
+      if (!approved) return { reason: 'human_rejected', step };
     }
 
     // ✅ Confidence gate — don't act when uncertain
     if (planned.confidence < 0.7) {
       return {
-        reason: "human_escalation",
+        reason: 'human_escalation',
         message: `Low confidence (${planned.confidence}) on: ${planned.action.description}`,
       };
     }
@@ -238,23 +246,23 @@ Every production agent needs:
 const guardrails = {
   // Input guardrails — reject bad prompts before they reach the agent
   input: [
-    { check: "no_prompt_injection", action: "reject" },
-    { check: "within_scope", action: "reject" }, // Off-topic requests
-    { check: "pii_detection", action: "redact" }, // Redact before processing
+    { check: 'no_prompt_injection', action: 'reject' },
+    { check: 'within_scope', action: 'reject' }, // Off-topic requests
+    { check: 'pii_detection', action: 'redact' }, // Redact before processing
   ],
 
   // Output guardrails — validate before returning
   output: [
-    { check: "no_hallucinated_citations", action: "flag" },
-    { check: "schema_valid", action: "retry_once" },
-    { check: "no_pii_leaked", action: "reject" },
+    { check: 'no_hallucinated_citations', action: 'flag' },
+    { check: 'schema_valid', action: 'retry_once' },
+    { check: 'no_pii_leaked', action: 'reject' },
   ],
 
   // Resource guardrails — prevent runaway cost/loops
   resource: [
-    { check: "max_tokens_per_session", limit: 100_000 },
-    { check: "max_tool_calls_per_session", limit: 50 },
-    { check: "max_cost_per_session_usd", limit: 1.0 },
+    { check: 'max_tokens_per_session', limit: 100_000 },
+    { check: 'max_tool_calls_per_session', limit: 50 },
+    { check: 'max_cost_per_session_usd', limit: 1.0 },
   ],
 };
 ```

package/.agent/skills/agentic-workflows-2026/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: agentic-workflows-2026
+description: Advanced 2026-2027 AI agent loops, ReAct planning, structured tool calling via Zod/Pydantic, streaming generative UI, and human-in-the-loop gates.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/swarm_dispatcher.js
+scripts-binding:
+  - .agent/scripts/swarm_dispatcher.js
+  - .agent/scripts/context_broker.js
+skills:
+  - agentic-patterns
+  - generative-ui-expert
+  - parallel-agents
+---
+
+# Agentic Workflows 2026 — Multi-Agent Architecture
+
+## Mandatory Pre-Flight Context Inspection
+
+Before designing autonomous agent loops:
+
+1. Tool Contract Validation → Enforce strict JSON Schema / Zod validation for every tool call
+2. Hard Execution Limit → Enforce a maximum iteration cap (max 10 turns) to prevent infinite loops
+3. Human-in-the-Loop Gate → Require human approval for destructive operations (file deletion, production deploy, DB writes)
+
+## Core ReAct Loop Pattern (Zod + TypeScript)
+
+```typescript
+import { z } from 'zod';
+
+export const ToolCallSchema = z.object({
+  toolName: z.enum(['read_file', 'write_file', 'run_test']),
+  args: z.record(z.unknown()),
+  reasoning: z.string().min(10),
+});
+
+export type ToolCall = z.infer<typeof ToolCallSchema>;
+
+export async function runAgentLoop(task: string, maxTurns = 10) {
+  let turn = 0;
+  const history: Array<{ role: string; content: string }> = [{ role: 'user', content: task }];
+
+  while (turn < maxTurns) {
+    turn++;
+    const response = await callLLM(history);
+    const parsed = ToolCallSchema.safeParse(response);
+
+    if (!parsed.success) {
+      history.push({
+        role: 'system',
+        content: `Invalid tool call payload: ${parsed.error.message}`,
+      });
+      continue;
+    }
+
+    if (parsed.data.toolName === 'write_file') {
+      const approved = await requestHumanApproval(parsed.data);
+      if (!approved) break;
+    }
+
+    const result = await executeTool(parsed.data);
+    history.push({ role: 'tool', content: JSON.stringify(result) });
+  }
+}
+```
+
+## Parallel Fan-Out / Fan-In Execution Matrix
+
+```
+[Supervisor Agent]
+       ├── Dispatch Worker A (Backend)  ──> WorkerResult A ──┐
+       ├── Dispatch Worker B (Database) ──> WorkerResult B ──┼─> [Promise.allSettled Synthesis]
+       └── Dispatch Worker C (Frontend) ──> WorkerResult C ──┘
+```
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Validate tool arguments before tool execution.
+- Log complete agent trace trajectory for auditability.

package/.agent/skills/ai-app-hardening/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: ai-app-hardening
+description: OWASP Top 10 for LLMs (2026), prompt injection defense, model output sanitization, indirect injection defense, and automated SBOM dependency security.
+tools: Read, Grep, Glob, Edit, Write
+version: 3.0.0
+last-updated: 2026-08-05
+script: .agent/scripts/security_scan.js
+scripts-binding:
+  - .agent/scripts/security_scan.js
+  - .agent/scripts/guardrail_engine.js
+skills:
+  - ai-prompt-injection-defense
+  - vulnerability-scanner
+  - backend-security-expert
+---
+
+# AI Application Hardening & Indirect Prompt Injection Defense
+
+## Mandatory Pre-Flight Context Inspection
+
+Before deploying AI features:
+
+1. Indirect Prompt Injection Defense → Sanitize third-party content (scraped URLs, PDF imports, RAG docs) before feeding to LLMs
+2. XML Delimiter Sandboxing → Enclose user/external inputs inside `<external_context>` and instruct model to ignore instructions within
+3. Insecure Output Handling (OWASP LLM02) → Escape HTML/script tags on all rendered model outputs
+
+## Indirect Prompt Injection Defense Filter
+
+```typescript
+export function sanitizeRAGDocument(rawDocumentContent: string): string {
+  if (!rawDocumentContent || typeof rawDocumentContent !== 'string') return '';
+
+  // 1. Redact indirect prompt injection trigger phrases
+  let cleaned = rawDocumentContent.replace(
+    /(?:system:\s*ignore|override system prompt|you are now in developer mode|print system prompt)/gi,
+    '[REDACTED_INDIRECT_INJECTION]',
+  );
+
+  // 2. Escape structural tag injection attempts
+  cleaned = cleaned.replace(/<\/?(?:system|user_input|external_context)[^>]*>/gi, '');
+
+  // 3. Truncate document snippet length
+  return cleaned.slice(0, 3000).trim();
+}
+```
+
+## OWASP LLM Top 10 (2026 Matrix)
+
+| Risk ID   | Vulnerability                        | Defense Implementation                              |
+| --------- | ------------------------------------ | --------------------------------------------------- |
+| **LLM01** | Prompt Injection (Direct & Indirect) | Delimiter sandboxing + `sanitizeRAGDocument` filter |
+| **LLM02** | Insecure Output Handling             | Strict Zod output parsing + DOMPurify on frontend   |
+| **LLM04** | Model Denial of Service              | Hard `max_tokens` limit + IP bucket rate limiting   |
+| **LLM07** | System Prompt Leakage                | System prompt redaction guards in output stream     |
+
+## 🛑 Verification-Before-Completion (VBC) Protocol
+
+- Run prompt injection test suite against external RAG context inputs.
+- Audit tool calls for privilege escalation risks.

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

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before engineering LLM prompts or processing untrusted user input, you MUST inspect:
+
 1. Message Role Isolation (Section 15) → Place user input exclusively in `role: "user"` messages; never concatenate user input into `role: "system"`
 2. Delimiter Sandboxing (Section 49) → Frame untrusted input inside XML tags (`<user_input>`) or randomized nonces (`<data_a8b4f1c9>`)
 3. Human-in-the-Loop Gate (Section 119) → Require explicit human approval before executing state-changing tool operations (`delete_user`, `process_payment`)
@@ -74,9 +75,9 @@ ${userInput}
 If an attacker guesses your delimiter (`</user_input> Ignore that.`), they can escape the sandbox. Generating random delimit tokens prevents this.
 
 ```typescript
-import crypto from "crypto";
+import crypto from 'crypto';
 
-const nonce = crypto.randomBytes(8).toString("hex"); // e.g., "a8b4f1c9"
+const nonce = crypto.randomBytes(8).toString('hex'); // e.g., "a8b4f1c9"
 const startTag = `<data_${nonce}>`;
 const endTag = `</data_${nonce}>`;
 
@@ -106,12 +107,12 @@ ${userInput}
 </text>`;
 
   const response = await scanWithFastModel(checkPrompt);
-  return response.trim().includes("MALICIOUS");
+  return response.trim().includes('MALICIOUS');
 }
 
 // Flow:
 if (await detectInjection(req.body.text)) {
-  return res.status(400).json({ error: "Input violates security policy." });
+  return res.status(400).json({ error: 'Input violates security policy.' });
 }
 // Proceed to main agent
 ```
@@ -136,8 +137,8 @@ If the LLM has tools (Function Calling):
 ```typescript
 // ❌ VULNERABLE TOOL DEFINITION
 const deleteUserTool = {
-  name: "delete_user",
-  description: "Deletes a user account from the DB",
+  name: 'delete_user',
+  description: 'Deletes a user account from the DB',
 }; // An injected prompt can trigger this autonomously
 
 // ✅ PREVENTATIVE ARCHITECTURE

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

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before implementing scroll-driven animations, you MUST inspect:
+
 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
@@ -31,6 +32,7 @@ Architect performant scroll-linked motion and scrollytelling sequences that feel
 ## 3 Scroll-Driven Architecture Patterns
 
 ### 1. Modern Pure CSS `view-timeline` (No JavaScript Required)
+
 ```css
 @keyframes reveal-on-scroll {
   from {
@@ -51,30 +53,37 @@ Architect performant scroll-linked motion and scrollytelling sequences that feel
 ```
 
 ### 2. Sticky Canvas / Section Pinned Storytelling (GSAP ScrollTrigger)
+
 ```javascript
-import { gsap } from "gsap";
-import { ScrollTrigger } from "gsap/ScrollTrigger";
+import { gsap } from 'gsap';
+import { ScrollTrigger } from 'gsap/ScrollTrigger';
 
 gsap.registerPlugin(ScrollTrigger);
 
-gsap.timeline({
-  scrollTrigger: {
-    trigger: ".story-container",
-    start: "top top",
-    end: "+=200%",
-    pin: true,
-    scrub: 1, // Smooth scrub delay
-  }
-})
-.to(".story-step-1", { opacity: 0, y: -20 })
-.from(".story-step-2", { opacity: 0, y: 20 });
+gsap
+  .timeline({
+    scrollTrigger: {
+      trigger: '.story-container',
+      start: 'top top',
+      end: '+=200%',
+      pin: true,
+      scrub: 1, // Smooth scrub delay
+    },
+  })
+  .to('.story-step-1', { opacity: 0, y: -20 })
+  .from('.story-step-2', { opacity: 0, y: 20 });
 ```
 
 ### 3. Scroll Progress Indicator Bar
+
 ```css
 @keyframes grow-progress {
-  from { transform: scaleX(0); }
-  to { transform: scaleX(1); }
+  from {
+    transform: scaleX(0);
+  }
+  to {
+    transform: scaleX(1);
+  }
 }
 
 .scroll-progress-bar {

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

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before defining animation tokens or styling transitions, you MUST inspect:
+
 1. `index.css` / `DESIGN.md` → Verify presence of centralized `--duration-*` and `--ease-*` CSS custom properties
 2. Centralized Motion Tokens Schema (Section 26) → Enforce standardized duration tiers (80ms instant to 500ms delight)
 3. Anti-Ad-Hoc Easing Rule (Section 48) → Strictly prohibit inline custom cubic-bezier curves; reference motion tokens instead
@@ -35,18 +36,18 @@ Define standardized design tokens for motion in global CSS or Tailwind config:
 ```css
 :root {
   /* Duration Scale */
-  --duration-instant:  80ms;  /* Micro feedback, toggle switches */
-  --duration-fast:    150ms;  /* Tooltips, hover states, press feedback */
-  --duration-normal:  220ms;  /* Dropdowns, menus, tab switching */
-  --duration-slow:    320ms;  /* Modals, drawers, page reveals */
-  --duration-delight: 500ms;  /* Milestone celebrations, toasts */
+  --duration-instant: 80ms; /* Micro feedback, toggle switches */
+  --duration-fast: 150ms; /* Tooltips, hover states, press feedback */
+  --duration-normal: 220ms; /* Dropdowns, menus, tab switching */
+  --duration-slow: 320ms; /* Modals, drawers, page reveals */
+  --duration-delight: 500ms; /* Milestone celebrations, toasts */
 
   /* Standardized Easing Curves */
-  --ease-snappy:  cubic-bezier(0.2, 0, 0, 1);       /* Quick response for press/active */
-  --ease-out-ui:  cubic-bezier(0.16, 1, 0.3, 1);     /* Smooth entrance for popovers/modals */
-  --ease-in-ui:   cubic-bezier(0.7, 0, 0.84, 0);     /* Smooth exit for modals */
-  --ease-spring:  cubic-bezier(0.34, 1.56, 0.64, 1);/* Subtle spring overshoot */
-  --ease-in-out:  cubic-bezier(0.65, 0, 0.35, 1);    /* Morphing layout changes */
+  --ease-snappy: cubic-bezier(0.2, 0, 0, 1); /* Quick response for press/active */
+  --ease-out-ui: cubic-bezier(0.16, 1, 0.3, 1); /* Smooth entrance for popovers/modals */
+  --ease-in-ui: cubic-bezier(0.7, 0, 0.84, 0); /* Smooth exit for modals */
+  --ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1); /* Subtle spring overshoot */
+  --ease-in-out: cubic-bezier(0.65, 0, 0.35, 1); /* Morphing layout changes */
 }
 ```
 

package/.agent/skills/antfu-conventions/SKILL.md

@@ -20,6 +20,7 @@ scripts-binding:
 ## Mandatory Pre-Flight Context Inspection
 
 Before configuring JS/TS tooling or lint rules, you MUST inspect:
+
 1. Pure ESM-First Requirement (Section 24) → Set `"type": "module"` in `package.json`; ban CommonJS `require()` or `module.exports`
 2. ESLint Flat Config (`eslint.config.js`) (Section 28) → Use `@antfu/eslint-config` with flat config format; ban legacy `.eslintrc.json`
 3. Explicit Type Imports (`import type`) (Section 45) → Enforce `import type` for type-only symbols to allow clean tree-shaking compilation
@@ -33,27 +34,31 @@ Enforce Anthony Fu's modern JavaScript/TypeScript engineering conventions: ESM-f
 ## 4 Core Tooling Conventions
 
 ### 1. ESM-First Standards
+
 - Use pure ES Modules (`"type": "module"` in `package.json`).
 - Avoid CommonJS `require()` or `module.exports`. Use explicit `.js` extension in relative imports when building Node ESM modules.
 
 ### 2. Single ESLint Flat Config (`eslint.config.js`)
+
 - Use `@antfu/eslint-config` for unified linting across TypeScript, Vue, React, JSON, and Markdown in 1 simple config file.
 
 ```javascript
 // eslint.config.js
-import antfu from '@antfu/eslint-config'
+import antfu from '@antfu/eslint-config';
 
 export default antfu({
   typescript: true,
   vue: true,
   react: true,
-})
+});
 ```
 
 ### 3. PNPM Catalog & Workspace Monorepo
+
 - Use `pnpm-workspace.yaml` with PNPM catalogs (`catalog:`) to lock unified dependency versions across monorepos.
 
 ### 4. Explicit Type Imports (`import type`)
+
 - Enforce `import type { User } from './types'` to allow tree-shaking compilers (esbuild/tsdown) to strip type imports cleanly without runtime side effects.
 
 ---