tribunal-kit 9.2.3 → 9.2.5

package/.agents/skills/duckdb-analytical-sql/SKILL.md

@@ -1,51 +1,51 @@
----
-name: duckdb-analytical-sql
-description: "Use when Embedded OLAP analytics, high-speed Parquet/JSON processing, in-memory analytical SQL, and DuckDB integrations in Node.js, Python, and WASM."
-version: 5.0.0
-last-updated: 2026-09-13
-skills:
-  - sql-pro
-  - database-design
-  - performance-profiling
-tools: Read, Grep, Glob, Bash, Edit, Write
-scripts-binding:
-  - .agent/scripts/schema_validator.js
-  - .agent/scripts/lint_runner.js
-  - .agent/scripts/verify_all.js
----
-
-# DuckDB Analytical SQL — Embedded Analytics
-
----
-
-## 🛠️ Technical Architecture & Reference Recipes
-
-## Node.js DuckDB Parquet Query Pattern
-
-```typescript
-import { Database } from 'duckdb-async';
-
-export async function runAnalyticalReport(parquetGlobPath: string) {
-  const db = await Database.create(':memory:');
-
-  // Set memory limits for embedded execution
-  await db.exec("SET max_memory = '2GB'; SET threads = 4;");
-
-  const rows = await db.all(
-    `
-    SELECT 
-        date_trunc('day', timestamp) as event_day,
-        event_type,
-        COUNT(*) as total_count,
-        QUANTILE_CONT(duration_ms, 0.95) as p95_latency
-    FROM read_parquet(?)
-    GROUP BY 1, 2
-    ORDER BY 1 DESC
-    LIMIT 100
-  `,
-    [parquetGlobPath],
-  );
-
-  return rows;
-}
-```
+---
+name: duckdb-analytical-sql
+description: "Use when Embedded OLAP analytics, high-speed Parquet/JSON processing, in-memory analytical SQL, and DuckDB integrations in Node.js, Python, and WASM."
+version: 5.0.0
+last-updated: 2026-09-13
+skills:
+  - sql-pro
+  - database-design
+  - performance-profiling
+tools: Read, Grep, Glob, Bash, Edit, Write
+scripts-binding:
+  - .agent/scripts/schema_validator.js
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
+---
+
+# DuckDB Analytical SQL — Embedded Analytics
+
+---
+
+## 🛠️ Technical Architecture & Reference Recipes
+
+## Node.js DuckDB Parquet Query Pattern
+
+```typescript
+import { Database } from 'duckdb-async';
+
+export async function runAnalyticalReport(parquetGlobPath: string) {
+  const db = await Database.create(':memory:');
+
+  // Set memory limits for embedded execution
+  await db.exec("SET max_memory = '2GB'; SET threads = 4;");
+
+  const rows = await db.all(
+    `
+    SELECT 
+        date_trunc('day', timestamp) as event_day,
+        event_type,
+        COUNT(*) as total_count,
+        QUANTILE_CONT(duration_ms, 0.95) as p95_latency
+    FROM read_parquet(?)
+    GROUP BY 1, 2
+    ORDER BY 1 DESC
+    LIMIT 100
+  `,
+    [parquetGlobPath],
+  );
+
+  return rows;
+}
+```

package/.agents/skills/edge-ai-mobile/SKILL.md

@@ -1,42 +1,42 @@
----
-name: edge-ai-mobile
-description: "Use when On-device mobile AI, CoreML, Android NNAPI, ONNX Runtime Web/Mobile, local LLM execution (SLMs), and sub-10ms privacy-first edge inference."
-version: 5.0.0
-last-updated: 2026-09-13
-skills:
-  - mobile-developer
-  - browser-native-ai
-  - performance-profiling
-tools: Read, Grep, Glob, Bash, Edit, Write
-scripts-binding:
-  - .agent/scripts/bundle_analyzer.js
-  - .agent/scripts/lint_runner.js
-  - .agent/scripts/verify_all.js
----
-
-# Edge AI & On-Device Mobile Machine Learning
-
----
-
-## 🛠️ Technical Architecture & Reference Recipes
-
-## Mobile ONNX Edge Inference Pattern
-
-```typescript
-import * as ort from 'onnxruntime-react-native';
-
-export async function runLocalEmbeddings(textTokens: number[]): Promise<Float32Array> {
-  const session = await ort.InferenceSession.create('model_quantized.onnx', {
-    executionProviders: ['cpu'], // Accelerates via ANE/NNAPI internally
-  });
-
-  const tensor = new ort.Tensor('int64', new BigInt64Array(textTokens.map(BigInt)), [
-    1,
-    textTokens.length,
-  ]);
-  const feeds = { input_ids: tensor };
-
-  const results = await session.run(feeds);
-  return results.embedding.data as Float32Array;
-}
-```
+---
+name: edge-ai-mobile
+description: "Use when On-device mobile AI, CoreML, Android NNAPI, ONNX Runtime Web/Mobile, local LLM execution (SLMs), and sub-10ms privacy-first edge inference."
+version: 5.0.0
+last-updated: 2026-09-13
+skills:
+  - mobile-developer
+  - browser-native-ai
+  - performance-profiling
+tools: Read, Grep, Glob, Bash, Edit, Write
+scripts-binding:
+  - .agent/scripts/bundle_analyzer.js
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
+---
+
+# Edge AI & On-Device Mobile Machine Learning
+
+---
+
+## 🛠️ Technical Architecture & Reference Recipes
+
+## Mobile ONNX Edge Inference Pattern
+
+```typescript
+import * as ort from 'onnxruntime-react-native';
+
+export async function runLocalEmbeddings(textTokens: number[]): Promise<Float32Array> {
+  const session = await ort.InferenceSession.create('model_quantized.onnx', {
+    executionProviders: ['cpu'], // Accelerates via ANE/NNAPI internally
+  });
+
+  const tensor = new ort.Tensor('int64', new BigInt64Array(textTokens.map(BigInt)), [
+    1,
+    textTokens.length,
+  ]);
+  const feeds = { input_ids: tensor };
+
+  const results = await session.run(feeds);
+  return results.embedding.data as Float32Array;
+}
+```

package/.agents/skills/edge-computing/SKILL.md

@@ -1,143 +1,143 @@
----
-name: edge-computing
-description: "Use when Edge computing mastery. Cloudflare Workers, Vercel Edge Functions, Durable Objects, edge-compatible data patterns, cold start elimination, caching policies (Stale-While-Revalidate), and global data locality. Use when designing globally distributed, extreme low-latency applications architectures."
-version: 5.0.0
-last-updated: 2026-09-13
-skills:
-  - nextjs-react-expert
-  - local-first-architecture
-  - backend-security-expert
-tools: Read, Grep, Glob, Bash, Edit, Write
-scripts-binding:
-  - .agent/scripts/lint_runner.js
-  - .agent/scripts/verify_all.js
----
-
-# Edge Computing — Global Latency Mastery
-
----
-
-## 🛠️ Technical Architecture & Reference Recipes
-
----
-
-## Hallucination Traps (Read First)
-
-- ❌ Importing Node.js-only APIs (fs, net, child_process) in edge functions -> ✅ Edge runtime has NO Node.js APIs; use Web APIs only
-- ❌ Using `global` or module-level mutable state in edge -> ✅ Edge functions are stateless across requests; use KV/Durable Objects for state
-- ❌ Assuming edge functions have unlimited execution time -> ✅ Cloudflare Workers: 30s, Vercel Edge: 25s; design for millisecond responses
-
----
-
----
-
-## 1. The Edge Model (V8 Isolates vs Node.js)
-
-Edge functions (Cloudflare Workers, Vercel Edge) run on V8 Isolates, NOT standard Node.js environments.
-
-**What This Means:**
-
-1. Extremely fast cold starts (< 5ms) because there is no underlying OS process bootup.
-2. Hard memory/time limits per request (e.g., 50ms CPU time max).
-3. **NO NATIVE NODE MODULES.** You cannot use `fs`, `child_process`, or heavy native C++ binaries (e.g., standard `bcrypt`, `sharp`).
-
-```typescript
-// ❌ BAD: Attempting to use Node native core modules
-import fs from 'fs';
-import bcrypt from 'bcrypt'; // Has C++ bindings, will instantly crash on V8 edge
-
-// ✅ GOOD: Utilizing standard Web APIs (Fetch, CryptoKey)
-const hashBuffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(password));
-```
-
----
-
-## 2. Advanced Route Caching (Stale-While-Revalidate)
-
-The highest value proposition of the edge is intercepting requests _before_ they cross the ocean.
-
-```typescript
-// Standard Edge Proxy request handling
-export default {
-  async fetch(request, env, ctx) {
-    const url = new URL(request.url);
-
-    // 1. Cache API responses at the edge
-    const cache = caches.default;
-    let response = await cache.match(request);
-
-    if (!response) {
-      // 2. Fetch Origin (The real server in Virginia)
-      response = await fetch(request);
-
-      // 3. Mutate Headers for SWR (Stale-While-Revalidate)
-      // Instructs the Edge CDN: Serve the stale version instantly to the user,
-      // but fire an async request in the background to update the cache for the next user.
-      response = new Response(response.body, response);
-      response.headers.set('Cache-Control', 's-maxage=60, stale-while-revalidate=86400');
-
-      // 4. Store in Cache asynchronously (do not block the user response)
-      ctx.waitUntil(cache.put(request, response.clone()));
-    }
-
-    return response;
-  },
-};
-```
-
----
-
-## 3. Edge Data Locality (The Database Problem)
-
-Running logic globally while querying a monolithic database in `us-east-1` is counter-productive. The latency of establishing a connection across the Atlantic will negate any Edge benefits.
-
-### Solutions:
-
-1. **Edge KV Stores**: (Cloudflare KV, Vercel KV) Eventually consistent, highly localized read-latency configs suitable for configuration routing, user sessions, or feature flags.
-2. **Distributed SQLite**: (Cloudflare D1, Turso) Replicas distributed to edge nodes automatically.
-3. **Connection Pooling**: Use an HTTP/Connection Pool proxy strictly (e.g., Prisma Accelerate, Supabase Edge Pooler). You cannot establish TCP `pg://` connections directly from millions of spinning V8 isolates, you will OOM crash the database.
-
-```typescript
-// ✅ Turso / LibSQL (Distributed Edge DB) usage:
-import { createClient } from '@libsql/client/web';
-
-const client = createClient({
-  url: env.TURSO_DATABASE_URL,
-  authToken: env.TURSO_AUTH_TOKEN,
-});
-
-const result = await client.execute('SELECT * FROM users WHERE id = ?', [userId]);
-```
-
----
-
-## 4. WebSockets at the Edge (Durable Objects)
-
-Standard Edge functions are stateless. To hold persistent state (like a live multiplayer gaming room, or a chat room's WebSocket connections across multiple users), you must funnel those connections into a single point of state: a Durable Object.
-
-```typescript
-// A Durable Object serves as a single source of truth that users globally connect into
-export class ChatRoom {
-  constructor(state, env) {
-    this.state = state;
-    this.sessions = [];
-  }
-
-  async fetch(request) {
-    // Upgrade standard HTTP to WebSocket
-    const pair = new WebSocketPair();
-
-    // Accept connection, store it globally
-    this.sessions.push(pair.server);
-    pair.server.accept();
-
-    // Handle incoming Chat messages
-    pair.server.addEventListener('message', msg => {
-      // Broadcast to all other connected edge users
-      this.sessions.forEach(session => session.send(msg.data));
-    });
-
-    return new Response(null, { status: 101, webSocket: pair.client });
-  }
-}
-```
+---
+name: edge-computing
+description: "Use when Edge computing mastery. Cloudflare Workers, Vercel Edge Functions, Durable Objects, edge-compatible data patterns, cold start elimination, caching policies (Stale-While-Revalidate), and global data locality. Use when designing globally distributed, extreme low-latency applications architectures."
+version: 5.0.0
+last-updated: 2026-09-13
+skills:
+  - nextjs-react-expert
+  - local-first-architecture
+  - backend-security-expert
+tools: Read, Grep, Glob, Bash, Edit, Write
+scripts-binding:
+  - .agent/scripts/lint_runner.js
+  - .agent/scripts/verify_all.js
+---
+
+# Edge Computing — Global Latency Mastery
+
+---
+
+## 🛠️ Technical Architecture & Reference Recipes
+
+---
+
+## Hallucination Traps (Read First)
+
+- ❌ Importing Node.js-only APIs (fs, net, child_process) in edge functions -> ✅ Edge runtime has NO Node.js APIs; use Web APIs only
+- ❌ Using `global` or module-level mutable state in edge -> ✅ Edge functions are stateless across requests; use KV/Durable Objects for state
+- ❌ Assuming edge functions have unlimited execution time -> ✅ Cloudflare Workers: 30s, Vercel Edge: 25s; design for millisecond responses
+
+---
+
+---
+
+## 1. The Edge Model (V8 Isolates vs Node.js)
+
+Edge functions (Cloudflare Workers, Vercel Edge) run on V8 Isolates, NOT standard Node.js environments.
+
+**What This Means:**
+
+1. Extremely fast cold starts (< 5ms) because there is no underlying OS process bootup.
+2. Hard memory/time limits per request (e.g., 50ms CPU time max).
+3. **NO NATIVE NODE MODULES.** You cannot use `fs`, `child_process`, or heavy native C++ binaries (e.g., standard `bcrypt`, `sharp`).
+
+```typescript
+// ❌ BAD: Attempting to use Node native core modules
+import fs from 'fs';
+import bcrypt from 'bcrypt'; // Has C++ bindings, will instantly crash on V8 edge
+
+// ✅ GOOD: Utilizing standard Web APIs (Fetch, CryptoKey)
+const hashBuffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(password));
+```
+
+---
+
+## 2. Advanced Route Caching (Stale-While-Revalidate)
+
+The highest value proposition of the edge is intercepting requests _before_ they cross the ocean.
+
+```typescript
+// Standard Edge Proxy request handling
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+
+    // 1. Cache API responses at the edge
+    const cache = caches.default;
+    let response = await cache.match(request);
+
+    if (!response) {
+      // 2. Fetch Origin (The real server in Virginia)
+      response = await fetch(request);
+
+      // 3. Mutate Headers for SWR (Stale-While-Revalidate)
+      // Instructs the Edge CDN: Serve the stale version instantly to the user,
+      // but fire an async request in the background to update the cache for the next user.
+      response = new Response(response.body, response);
+      response.headers.set('Cache-Control', 's-maxage=60, stale-while-revalidate=86400');
+
+      // 4. Store in Cache asynchronously (do not block the user response)
+      ctx.waitUntil(cache.put(request, response.clone()));
+    }
+
+    return response;
+  },
+};
+```
+
+---
+
+## 3. Edge Data Locality (The Database Problem)
+
+Running logic globally while querying a monolithic database in `us-east-1` is counter-productive. The latency of establishing a connection across the Atlantic will negate any Edge benefits.
+
+### Solutions:
+
+1. **Edge KV Stores**: (Cloudflare KV, Vercel KV) Eventually consistent, highly localized read-latency configs suitable for configuration routing, user sessions, or feature flags.
+2. **Distributed SQLite**: (Cloudflare D1, Turso) Replicas distributed to edge nodes automatically.
+3. **Connection Pooling**: Use an HTTP/Connection Pool proxy strictly (e.g., Prisma Accelerate, Supabase Edge Pooler). You cannot establish TCP `pg://` connections directly from millions of spinning V8 isolates, you will OOM crash the database.
+
+```typescript
+// ✅ Turso / LibSQL (Distributed Edge DB) usage:
+import { createClient } from '@libsql/client/web';
+
+const client = createClient({
+  url: env.TURSO_DATABASE_URL,
+  authToken: env.TURSO_AUTH_TOKEN,
+});
+
+const result = await client.execute('SELECT * FROM users WHERE id = ?', [userId]);
+```
+
+---
+
+## 4. WebSockets at the Edge (Durable Objects)
+
+Standard Edge functions are stateless. To hold persistent state (like a live multiplayer gaming room, or a chat room's WebSocket connections across multiple users), you must funnel those connections into a single point of state: a Durable Object.
+
+```typescript
+// A Durable Object serves as a single source of truth that users globally connect into
+export class ChatRoom {
+  constructor(state, env) {
+    this.state = state;
+    this.sessions = [];
+  }
+
+  async fetch(request) {
+    // Upgrade standard HTTP to WebSocket
+    const pair = new WebSocketPair();
+
+    // Accept connection, store it globally
+    this.sessions.push(pair.server);
+    pair.server.accept();
+
+    // Handle incoming Chat messages
+    pair.server.addEventListener('message', msg => {
+      // Broadcast to all other connected edge users
+      this.sessions.forEach(session => session.send(msg.data));
+    });
+
+    return new Response(null, { status: 101, webSocket: pair.client });
+  }
+}
+```