tribunal-kit 9.2.4 → 9.2.6

package/.agents/skills/subagent-driven-development/SKILL.md

@@ -1,32 +1,92 @@
 ---
 name: subagent-driven-development
-description: "Use when decomposing tasks, delegating to subagents, executing code in isolation, and reviewing AI-generated output. Integrates tightly with Tribunal OS governance."
-version: 1.0.0
-last-updated: 2026-09-25
+description: "Use when decomposing complex epics into atomic subagent tasks, orchestrating parallel worker waves, isolating context, and synthesizing results with Tribunal reviews. Enforces out-of-band context and human gate approvals."
+version: 6.0.0
+last-updated: 2026-09-29
 skills:
+  - agent-organizer
+  - parallel-agents
   - tdd-workflow
   - verification-before-completion
 tools: Read, Grep, Glob, Bash, Edit, Write
 scripts-binding:
   - .agent/scripts/swarm_dispatcher.js
+  - .agent/scripts/verify_all.js
+  - .agent/scripts/lint_runner.js
 ---
 
-# Subagent-Driven Development (SDD)
+# Subagent-Driven Development (SDD) — Swarm Orchestration Engine
 
-## Core Philosophy
-Monolithic tasks must be broken down into atomic, testable units, delegated to specialized agents, and executed in bounded isolation. No single agent should both write code and approve it for production.
+## Activation Boundaries
+- **Activate when:** Use when decomposing complex epics into atomic subagent tasks, orchestrating parallel worker waves, isolating context, and synthesizing results with Tribunal reviews. Enforces out-of-band context and human gate approvals.
+- **DO NOT activate when:** The task falls outside the `subagent-driven-development` domain or is managed by a different dedicated specialist agent.
 
-## The SDD Lifecycle
-1. **Decomposition**: Break the Epic down into sub-tasks (Waves). No sub-task should touch more than 5 files.
-2. **Delegation**: Assign each sub-task to the agent with the most appropriate profile (e.g., `frontend-specialist`, `database-architect`).
-3. **Execution (Hands)**: The subagent implements the required changes in a localized context.
-4. **Verification**: The subagent runs tests. If tests fail, it iterates.
-5. **Review (Tribunal)**: The code changes are subjected to parallel static analysis reviewers (`/tribunal-full`).
-6. **Handoff**: The subagent reports back to the Orchestrator with concrete proof of verification.
 
-## Mandatory Guardrails
-- **Zero-Trust Delegation**: Never assume a subagent succeeded just because it didn't throw an error. Demand terminal output proof.
-- **Context Isolation**: Do NOT pass the entire conversation history to a subagent. Pass only the required `.md` instructions and relevant file paths.
+## 🔁 Multi-Pass Execution Protocol
 
-## Failure Handling
-If a subagent fails 3 times, the Orchestrator must abort the wave, clean up any uncommitted side-effects, and flag the issue for the Human Gate.
+| Pass | Phase | Core Action | Adaptive Depth |
+|:---|:---|:---|:---|
+| **Pass 1** | **Understand** | Deconstruct the user's explicit objective, implicit requirements, and platform constraints. | Fast / Standard / Deep |
+| **Pass 2** | **Plan** | Decompose task into smallest logical steps; map dependencies, affected files, and tool calls. | Standard / Deep |
+| **Pass 3** | **Execute** | Implement solution with production-grade craft, zero placeholders, and strict typing. | All Modes |
+| **Pass 4** | **Verify** | Run linters, unit tests, or compiler checks to validate structural correctness. | All Modes |
+| **Pass 5** | **Attack & Falsify** | Perform adversarial search for edge-case failures, counterexamples, race conditions, and traps. | Standard / Deep |
+| **Pass 6** | **Harden** | Eliminate discovered friction, optimize performance, and harden error boundaries. | Standard / Deep |
+| **Pass 7** | **Quality Gate** | Enforce Verification-Before-Completion (VBC) with concrete terminal proof before finalizing. | All Modes |
+
+
+## Mandatory Pre-Flight Context Inspection
+1. **Epic Deconstructibility**: Verify the epic can be partitioned into atomic tasks touching disjoint file sets.
+2. **File Ownership Invariant**: Ensure no two concurrent workers in the same wave edit the same target file.
+3. **Context Isolation**: Pass only scoped `task-<N>-brief.md` and file excerpts to subagents; NEVER dump conversation history.
+4. **Verification Criteria**: Every subagent brief must define measurable pass/fail criteria (unit test, compiler check, lint).
+5. **Fan-In Synthesis**: Collect worker outputs via `allSettled`; resolve conflicting findings before writing disk changes.
+
+## 🛠️ Technical Architecture & Reference Recipes
+
+### 1. The 4-Phase SDD Lifecycle
+```
+1. DECOMPOSE: Epic ──► Wave 1 (Independent Workers) ──► Wave 2 (Dependent Workers)
+2. DISPATCH:   Worker A [backend]     Worker B [frontend]     Worker C [database]
+                    │                      │                       │
+3. VERIFY:     Run Tests              Run Tests               Run Tests
+                    │                      │                       │
+4. SYNTHESIZE: Fan-In Aggregation ──► Tribunal Review Wave ──► Human Gate Approval
+```
+
+### 2. Scoped Task Brief Contract (`task-brief.md`)
+```markdown
+# Task Brief: #042 — Auth Middleware Hardening
+- **Assigned Specialist**: `backend-specialist`
+- **Target Files (Exclusive)**: `src/middleware/auth.ts`, `test/middleware/auth.test.ts`
+- **Context Summary**: JWT verification must enforce algorithm whitelist (`HS256`) and check tenant isolation.
+- **Constraints**: Do NOT edit `src/app.ts`. Do NOT install external dependencies without approval.
+- **Required Verification**: `npm test test/middleware/auth.test.ts` must exit 0 with 100% assertions passing.
+```
+
+## 🚨 Edge-Case & Failure Mode Matrix
+
+| Scenario | Risk | Production Mitigation |
+|:---|:---|:---|
+| **Conflicting Edits in Shared Files** | Two subagents edit the same file simultaneously, causing merge conflicts | Strict partitioning: One subagent owns the file; dependent subagents run in subsequent waves |
+| **Worker Failure / Infinite Loop** | A subagent gets stuck repeating the same failing command | Hard limit of 3 retries; if worker fails on attempt 3, mark as BLOCKED and escalate to supervisor |
+| **Context Window Saturation** | Subagents consume millions of tokens by re-reading identical files | Orchestrator distributes pre-computed context excerpts via `context_broker.js` |
+
+## 🏛️ Tribunal Verification & Guardrails
+
+### 🔬 Evidence Standard (Tri-State Verification)
+Every finding, audit statement, or completion claim must classify its factual certainty:
+- **`[OBSERVED]`**: Directly confirmed in the codebase or verified via executed terminal command.
+- **`[INFERRED]`**: Logically deduced from code patterns, architectural data flow, or schema relations.
+- **`[UNVERIFIED]`**: Speculative hypothesis or runtime possibility requiring active testing or measurement.
+
+- **Active Reviewers:** `orchestrator`, `agent-organizer`, `resilience-reviewer`
+- **Evidence Standard:** All subagent completion claims require verified terminal test output.
+
+## 🤖 LLM-Specific Traps Table
+
+| Anti-Pattern | What AI Commonly Does Wrong | What Is Actually Correct |
+|:---|:---|:---|
+| **Hallucinated Tool Capabilities** | Assuming an external library or CLI command exists without verification | Run a verification check or verify package.json before referencing tools |
+| **Premature Completion Claim** | Declaring a task finished because code was generated without verification | Execute tests, linters, or terminal commands to provide concrete proof |
+| **Context Bloat Dumping** | Pasting entire multi-thousand-line files into prompt context | Extract targeted excerpts, symbols, and signatures to preserve tokens |

package/.agents/skills/supabase-postgres-best-practices/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: supabase-postgres-best-practices
-description: "Use when Database architect expert in Supabase and PostgreSQL. Focuses on Row Level Security (RLS), edge functions, real-time setups, and performant schema design."
-version: 5.0.0
-last-updated: 2026-09-13
+description: "Use when designing schemas, querying, indexing, optimizing, and securing supabase postgres best practices databases and data models."
+version: 6.0.0
+last-updated: 2026-09-29
 skills:
   - database-design
   - sql-pro
@@ -15,43 +15,104 @@ scripts-binding:
 
 # Supabase & Postgres Best Practices
 
----
+## Mandatory Pre-Flight Context Inspection
+Before reading, generating, or refactoring code in the `supabase-postgres-best-practices` 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).
 
-## 🛠️ Technical Architecture & Reference Recipes
 
----
+## Activation Boundaries
+- **Activate when:** Use when designing schemas, querying, indexing, optimizing, and securing supabase postgres best practices databases and data models.
+- **DO NOT activate when:** The task falls outside the `supabase-postgres-best-practices` domain or is managed by a different dedicated specialist agent.
 
-## Hallucination Traps (Read First)
 
-- ❌ Using Supabase without enabling Row Level Security (RLS) -> ✅ ALL tables MUST have RLS enabled; without it, data is publicly accessible
-- ❌ `supabase.from('users').select('*')` in client-side code without RLS -> ✅ This exposes ALL rows to ALL users; add RLS policies first
-- ❌ Storing API keys in client-side JavaScript -> ✅ The `anon` key is public by design; protect data with RLS, not key secrecy
-- ❌ Using Supabase Edge Functions for compute-heavy tasks -> ✅ Edge Functions have 150ms CPU time limit; use server functions for heavy work
+## 🔁 Multi-Pass Execution Protocol
 
----
+| Pass | Phase | Core Action | Adaptive Depth |
+|:---|:---|:---|:---|
+| **Pass 1** | **Understand** | Deconstruct the user's explicit objective, implicit requirements, and platform constraints. | Fast / Standard / Deep |
+| **Pass 2** | **Plan** | Decompose task into smallest logical steps; map dependencies, affected files, and tool calls. | Standard / Deep |
+| **Pass 3** | **Execute** | Implement solution with production-grade craft, zero placeholders, and strict typing. | All Modes |
+| **Pass 4** | **Verify** | Run linters, unit tests, or compiler checks to validate structural correctness. | All Modes |
+| **Pass 5** | **Attack & Falsify** | Perform adversarial search for edge-case failures, counterexamples, race conditions, and traps. | Standard / Deep |
+| **Pass 6** | **Harden** | Eliminate discovered friction, optimize performance, and harden error boundaries. | Standard / Deep |
+| **Pass 7** | **Quality Gate** | Enforce Verification-Before-Completion (VBC) with concrete terminal proof before finalizing. | All Modes |
+
+
+---
+
+## 🛠️ Technical Architecture & Reference Recipes
 
-You are a Supabase Data Architect. You understand how to leverage PostgreSQL features alongside the Supabase ecosystem to build secure, scalable backend architectures.
+## Hallucination Traps (Read First)
+
+- ❌ Using Supabase without enabling Row Level Security (RLS) -> ✅ ALL tables MUST have RLS enabled; without it, data is publicly accessible
+- ❌ `supabase.from('users').select('*')` in client-side code without RLS -> ✅ This exposes ALL rows to ALL users; add RLS policies first
+- ❌ Storing API keys in client-side JavaScript -> ✅ The `anon` key is public by design; protect data with RLS, not key secrecy
+- ❌ Using Supabase Edge Functions for compute-heavy tasks -> ✅ Edge Functions have 150ms CPU time limit; use server functions for heavy work
+
+---
+
+You are a Supabase Data Architect. You understand how to leverage PostgreSQL features alongside the Supabase ecosystem to build secure, scalable backend architectures.
+
+## Core Directives
+
+1. **Row Level Security (RLS) is Mandatory:**
+   - Never create a table accessible from the public API without enabling RLS.
+   - Write strict, performant RLS policies:
+     ```sql
+     alter table documents enable row level security;
+     create policy "Users can view their own documents"
+     on documents for select using (auth.uid() = user_id);
+     ```
+   - Avoid slow `IN` subqueries inside RLS policies; use direct equality or simpler joins when possible.
+
+2. **Supabase Schema Management:**
+   - Always map schema changes into standard SQL migration files (`supabase/migrations/...`).
+   - Do not hallucinate GUI operations; provide explicit SQL commands to achieve the task.
+
+3. **Performance & Indexing:**
+   - Generate indexes for foreign keys and frequently queried columns.
+   - Recommend vector indexes (pgvector/HNSW) if generating embeddings or performing AI-based similarity searches.
+
+4. **Edge Functions & Real-time:**
+   - Use Deno for Edge Functions when creating webhooks or external integrations.
+   - Clearly delineate which tables need `replica identity full` or replication enabled for real-time subscriptions.
 
-## Core Directives
+## 🚨 Edge-Case & Failure Mode Matrix
 
-1. **Row Level Security (RLS) is Mandatory:**
-   - Never create a table accessible from the public API without enabling RLS.
-   - Write strict, performant RLS policies:
-     ```sql
-     alter table documents enable row level security;
-     create policy "Users can view their own documents"
-     on documents for select using (auth.uid() = user_id);
-     ```
-   - Avoid slow `IN` subqueries inside RLS policies; use direct equality or simpler joins when possible.
+| Scenario | Risk | Production Mitigation |
+|:---|:---|:---|
+| **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 |
 
-2. **Supabase Schema Management:**
-   - Always map schema changes into standard SQL migration files (`supabase/migrations/...`).
-   - Do not hallucinate GUI operations; provide explicit SQL commands to achieve the task.
 
-3. **Performance & Indexing:**
-   - Generate indexes for foreign keys and frequently queried columns.
-   - Recommend vector indexes (pgvector/HNSW) if generating embeddings or performing AI-based similarity searches.
+## 🏛️ Tribunal Verification & Guardrails
 
-4. **Edge Functions & Real-time:**
-   - Use Deno for Edge Functions when creating webhooks or external integrations.
-   - Clearly delineate which tables need `replica identity full` or replication enabled for real-time subscriptions.
+**Active Reviewers:** `database-architect` · `sql-pro` · `security-auditor` · `schema-validator`
+**Slash Command:** `/review` or `/tribunal-full`
+
+### 🔬 Evidence Standard (Tri-State Verification)
+Every finding, audit statement, or completion claim must classify its factual certainty:
+- **`[OBSERVED]`**: Directly confirmed in the codebase or verified via executed terminal command.
+- **`[INFERRED]`**: Logically deduced from code patterns, architectural data flow, or schema relations.
+- **`[UNVERIFIED]`**: Speculative hypothesis or runtime possibility requiring active testing or measurement.
+
+### ✅ Pre-Flight Self-Audit Checklist
+```
+✅ Are all queries parameterized against SQL injection vulnerabilities?
+✅ Are composite indexes ordered by Equality, Sort, then Range (ESR)?
+✅ Are multi-table writes wrapped in atomic transactions with rollback handlers?
+✅ Are schema migrations backwards-compatible (expand-and-contract pattern)?
+✅ Did I verify table and column names against active schema definitions?
+```
+
+### 🛑 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 test suites, compiler success, or equivalent operational proof) that your output works as intended.