tribunal-kit 5.8.4 → 6.0.0

package/.agent/scripts/skill_evolution.js

@@ -46,11 +46,18 @@ const {
 const { findAgentDir } = require("./_utils");
 
 
-const AGENT_DIR = findAgentDir();
-const SKILL_DIR = path.join(AGENT_DIR, "skills", "project-idioms");
-const SKILL_FILE = path.join(SKILL_DIR, "SKILL.md");
-const HISTORY_DIR = path.join(AGENT_DIR, "history", "skill-evolution");
-const LOG_FILE = path.join(HISTORY_DIR, "digest-log.json");
+function getPaths(startDir = process.cwd()) {
+  const agentDir = findAgentDir(startDir);
+  const skillDir = path.join(agentDir, "skills", "project-idioms");
+  const historyDir = path.join(agentDir, "history", "skill-evolution");
+  return {
+    agentDir,
+    skillDir,
+    skillFile: path.join(skillDir, "SKILL.md"),
+    historyDir,
+    logFile: path.join(historyDir, "digest-log.json"),
+  };
+}
 
 // ── Architectural Weight Patterns ────────────────────────────────────────────
 const HIGH_WEIGHT_PATTERNS = [
@@ -205,8 +212,9 @@ function countTokensEstimate(text) {
 
 // ── Idiom management ──────────────────────────────────────────────────────────
 function loadExistingIdioms() {
-  if (!fs.existsSync(SKILL_FILE)) return [];
-  const content = fs.readFileSync(SKILL_FILE, "utf8");
+  const { skillFile } = getPaths();
+  if (!fs.existsSync(skillFile)) return [];
+  const content = fs.readFileSync(skillFile, "utf8");
   const idioms = [];
   const pattern =
     /\|\s*(\d+)\s*\|\s*`([^`]+)`\s*\|\s*([^|]+)\|\s*([^|]+)\|\s*([^|]+)\|/g;
@@ -346,10 +354,11 @@ function parseLlmYamlResponse(response) {
 
 // ── Log helpers ────────────────────────────────────────────────────────────────
 function loadLog() {
-  fs.mkdirSync(HISTORY_DIR, { recursive: true });
-  if (fs.existsSync(LOG_FILE)) {
+  const { historyDir, logFile } = getPaths();
+  fs.mkdirSync(historyDir, { recursive: true });
+  if (fs.existsSync(logFile)) {
     try {
-      return JSON.parse(fs.readFileSync(LOG_FILE, "utf8"));
+      return JSON.parse(fs.readFileSync(logFile, "utf8"));
     } catch {
       /* fallthrough */
     }
@@ -358,8 +367,9 @@ function loadLog() {
 }
 
 function saveLog(log) {
-  fs.mkdirSync(HISTORY_DIR, { recursive: true });
-  fs.writeFileSync(LOG_FILE, JSON.stringify(log, null, 2), "utf8");
+  const { historyDir, logFile } = getPaths();
+  fs.mkdirSync(historyDir, { recursive: true });
+  fs.writeFileSync(logFile, JSON.stringify(log, null, 2), "utf8");
 }
 
 // ── Auto-LLM API Integration ─────────────────────────────────────────────────
@@ -835,8 +845,9 @@ async function cmdDigest(args) {
   if (added > 0) {
     log.total_idioms = merged.length;
     const skillMd = renderSkillMd(merged, (log.cycles || []).length + 1);
-    fs.mkdirSync(SKILL_DIR, { recursive: true });
-    fs.writeFileSync(SKILL_FILE, skillMd, "utf8");
+    const { skillDir, skillFile } = getPaths();
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(skillFile, skillMd, "utf8");
     console.log(`  ${GREEN}✔ ${added} new idiom(s) added to SKILL.md${RESET}`);
   } else {
     console.log(`  ${DIM}  No new unique idioms added to SKILL.md.${RESET}`);
@@ -932,22 +943,24 @@ async function cmdDigest(args) {
 }
 
 function cmdShow() {
-  if (!fs.existsSync(SKILL_FILE)) {
+  const { skillFile } = getPaths();
+  if (!fs.existsSync(skillFile)) {
     console.log(
       `${YELLOW}No project-idioms skill found. Run 'digest' first.${RESET}`,
     );
     return;
   }
-  console.log(fs.readFileSync(SKILL_FILE, "utf8"));
+  console.log(fs.readFileSync(skillFile, "utf8"));
 }
 
 function cmdReset() {
-  if (fs.existsSync(SKILL_FILE)) {
-    fs.unlinkSync(SKILL_FILE);
+  const { skillFile, logFile } = getPaths();
+  if (fs.existsSync(skillFile)) {
+    fs.unlinkSync(skillFile);
     console.log(`${GREEN}✔ project-idioms/SKILL.md deleted.${RESET}`);
   }
-  if (fs.existsSync(LOG_FILE)) {
-    fs.unlinkSync(LOG_FILE);
+  if (fs.existsSync(logFile)) {
+    fs.unlinkSync(logFile);
     console.log(`${GREEN}✔ Digest log cleared.${RESET}`);
   }
   console.log(`${DIM}Run 'digest' to start a fresh evolution cycle.${RESET}`);
@@ -958,7 +971,8 @@ function cmdStatus() {
   const cycles = log.cycles || [];
   const totalSaved = log.total_tokens_saved || 0;
   const totalIdioms = log.total_idioms || 0;
-  const idiomsExist = fs.existsSync(SKILL_FILE);
+  const { skillFile } = getPaths();
+  const idiomsExist = fs.existsSync(skillFile);
 
   console.log(
     `\n${BOLD}${CYAN}━━━ Skill Evolution Status ━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`,
@@ -1033,6 +1047,7 @@ module.exports = {
   architecturalWeight,
   parseLlmYamlResponse,
   loadExistingIdioms,
+  getPaths,
 };
 
 if (require.main === module) {

package/.agent/scripts/socratic_gate_policy.js

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

package/.agent/scripts/swarm_dispatcher.js

@@ -52,7 +52,7 @@ class SwarmDashboard {
   }
 
   start() {
-    console.clear();
+    this.render();
     this.timer = setInterval(() => this.render(), 80);
   }
 
@@ -89,12 +89,63 @@ const MAX_GOAL_LENGTH = 200;
 const MAX_CONTEXT_LENGTH = 800;
 const MAX_WORKERS_PER_SWARM = 5;
 
-const { findAgentDir } = require("./_utils");
+function getBinaryPath() {
+  if (process.env.TRIBUNAL_FORCE_JS === "1") return null;
+  const isWindows = process.platform === "win32";
+  const ext = isWindows ? ".exe" : "";
+  const candidates = [
+    process.env.TRIBUNAL_CORE_PATH,
+    path.resolve(__dirname, "..", "..", "tribunal-kit", "target", "release", `tribunal-core${ext}`),
+    path.resolve(__dirname, "..", "..", "target", "release", `tribunal-core${ext}`),
+    path.resolve(process.cwd(), "target", "release", `tribunal-core${ext}`),
+    path.resolve(process.cwd(), "tribunal-kit", "target", "release", `tribunal-core${ext}`),
+  ];
+  for (const c of candidates) {
+    if (c && fs.existsSync(c)) return c;
+  }
+  return null;
+}
 
+function nativeValidate(file, schemaType) {
+  const bin = getBinaryPath();
+  if (!bin || !file || !fs.existsSync(file)) return null;
+  try {
+    const { spawnSync } = require("child_process");
+    const res = spawnSync(bin, ["validate", "--file", file, "--schema", schemaType], {
+      encoding: "utf-8",
+    });
+    if (res.status === 0) {
+      return true;
+    }
+  } catch {
+    // fallback to JS engine
+  }
+  return null;
+}
+
+function findAgentDir(startPath) {
+  let current = path.resolve(startPath);
+  const root = path.parse(current).root;
+  while (current !== root) {
+    const agentDir = path.join(current, ".agent");
+    if (fs.existsSync(agentDir) && fs.statSync(agentDir).isDirectory()) {
+      return agentDir;
+    }
+    current = path.dirname(current);
+  }
+  return null;
+}
 
 // ─── Legacy mode: validate orchestrator micro-worker payloads ──────────────────
 
-function validatePayload(payloadData, workspaceRoot, agentsDir) {
+function validatePayload(payloadData, workspaceRoot, agentsDir, payloadFile = null) {
+  if (payloadFile) {
+    const nativeResult = nativeValidate(payloadFile, "micro-worker");
+    if (nativeResult === true) {
+      return true;
+    }
+  }
+
   if (!payloadData.dispatch_micro_workers) {
     console.error(
       "ERROR: Payload missing required 'dispatch_micro_workers' array.",
@@ -301,7 +352,14 @@ function validateWorkerResult(res, index) {
   return errors;
 }
 
-function validateSwarmPayload(payloadData, agentsDir) {
+function validateSwarmPayload(payloadData, agentsDir, payloadFile = null) {
+  if (payloadFile) {
+    const nativeResult = nativeValidate(payloadFile, "swarm");
+    if (nativeResult === true) {
+      return true;
+    }
+  }
+
   let items;
   if (typeof payloadData === "object" && payloadData !== null) {
     if (Array.isArray(payloadData)) {
@@ -417,7 +475,7 @@ function main() {
   }
 
   if (mode === "swarm") {
-    if (!validateSwarmPayload(payloadData, agentsDir)) {
+    if (!validateSwarmPayload(payloadData, agentsDir, file)) {
       console.error("ERROR: Swarm payload validation failed.");
       process.exit(1);
     }
@@ -494,7 +552,7 @@ function main() {
       }
     }
   } else {
-    if (!validatePayload(payloadData, workspaceRoot, agentsDir)) {
+    if (!validatePayload(payloadData, workspaceRoot, agentsDir, file)) {
       console.error("ERROR: Payload validation failed.");
       process.exit(1);
     }
@@ -536,6 +594,7 @@ function main() {
 }
 
 module.exports = {
+  SwarmDashboard,
   validateWorkerRequest,
   validateWorkerResult,
   validateSwarmPayload,

package/.agent/scripts/token_budget_broker.js

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

package/.agent/scripts/verify_all.js

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

package/.agent/scripts/visual_audit.js

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

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

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

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

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

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

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

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

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

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

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