tribunal-kit 9.2.5 → 9.2.7

package/.agent/workflows/arch.md

@@ -0,0 +1,96 @@
+---
+description: Tribunal Architecture Intelligence — Autonomous architecture extraction, zero-trust verification, blast radius simulation, semantic diffing, and health auditing.
+---
+
+# /arch — Tribunal Architecture Intelligence
+
+Execute deterministic architecture intelligence, verification, and blast radius simulation.
+
+## Overview
+
+Unlike superficial diagramming tools that only generate static pictures, `/arch` treats architecture as an **executable, verifiable Evidence Graph**.
+
+```
+SOURCE CODE
+    ↓ (AST & pattern extraction)
+FACT MODEL (.agent/history/architecture-model.json)
+    ↓ (Zero-trust provenance verification)
+CONFIDENCE & CONTRADICTION GATES (L1-L5)
+    ↓ (Downstream dependency closure)
+BLAST RADIUS & RISK SIMULATION
+    ↓ (Projections: Topology, Security, Failure, Impact)
+INTERACTIVE STANDALONE EXPLORER & AUDIT REPORT
+```
+
+---
+
+## Subcommands
+
+### 1. Extract Architectural Fact Model
+
+```bash
+tk arch map
+# or: node .agent/scripts/architecture_extractor.js
+```
+
+Scans repository AST, route definitions, database models, queues, events, and auth middleware. Emits the canonical `.agent/history/architecture-model.json`.
+
+### 2. Zero-Trust Verification
+
+```bash
+tk arch verify [--strict]
+# or: node .agent/scripts/architecture_verifier.js
+```
+
+Verifies that all entity code locations, lines, symbols, and hashes match ground truth. Surfaces any architectural contradictions or drifted/stale evidence.
+
+### 3. Change Blast Radius & Impact Simulation
+
+```bash
+tk arch impact <component-id-or-file>
+# or: node .agent/scripts/blast_radius_engine.js <query>
+```
+
+Simulates the impact of changing a component: direct callers, transitive dependents across concentric depth rings, impacted API routes, affected test suites, and risk tier (LOW/MEDIUM/HIGH/CRITICAL).
+
+### 4. Semantic Architecture Diff (PR Gate)
+
+```bash
+tk arch diff <base-model.json> <head-model.json>
+# or: node .agent/scripts/architecture_diff.js <base> <head>
+```
+
+Calculates true architectural shifts:
+
+- Trust boundaries crossed (e.g. public route directly accessing isolated database)
+- Resilience regressions (e.g. timeouts removed from external API calls)
+- Blast radius expansions (components whose downstream impact grew >25%)
+- New external SaaS/cloud dependencies introduced
+
+### 5. Architectural Health Audit
+
+```bash
+tk arch audit
+# or: node .agent/scripts/architecture_health.js
+```
+
+Audits structural risks:
+
+- Circular dependencies (exact cycle chains)
+- Single Points of Failure (SPOFs / High Fan-In bottlenecks)
+- Excessive Coupling (God Modules / High Fan-Out)
+- Test coverage gaps on critical components
+
+### 6. Multi-Projection Interactive Explorer
+
+```bash
+tk arch project [--open]
+# or: node .agent/scripts/architecture_visualizer.js
+```
+
+Generates a zero-dependency, standalone HTML explorer at `.agent/history/architecture-intelligence.html` with 4 interactive projections:
+
+1. **Topology**: Services, routes, datastores, queues
+2. **Security**: Trust zones & authentication gates
+3. **Failure Modes**: Timeouts, retries, fallbacks
+4. **Blast Radius Simulator**: Click any node to visualize live concentric blast rings

package/.agent/workflows/assimilate.md

@@ -1,15 +1,17 @@
 ---
 name: assimilate
-description: "Trigger the learning pipeline to extract, validate, and store Tribunal Instincts."
+description: 'Trigger the learning pipeline to extract, validate, and store Tribunal Instincts.'
 version: 1.0.0
 ---
 
 # ASSIMILATE (LEARNING PIPELINE)
 
 ## Invocation
+
 `/assimilate` or `/learn`
 
 ## Behavior
+
 Instead of learning in real-time and bloating the execution path, learning is an offline batch job.
 
 1. **Extraction**: Invokes the `memory_archivist.js` which reads the most recent session logs.
@@ -18,4 +20,5 @@ Instead of learning in real-time and bloating the execution path, learning is an
 4. **Storage**: Saves the verified evidence-backed instinct into `instincts.json` where `context_broker.js` can retrieve it for future related tasks.
 
 ## Limits
+
 Do not trigger this workflow automatically after every prompt. Use it specifically after a long debugging session or a complex architectural setup to persist the hard-earned lessons.

package/.agent/workflows/audit.md

@@ -166,7 +166,6 @@ No files are modified without explicit approval.
 
 ---
 
-
 ## Harness vs Application Auditing
 
 The `/audit` command now explicitly distinguishes between Application Security (OWASP, SQLi) and Harness Security (AgentShield prompt injection, MCP configuration risks).

package/.agent/workflows/generate.md

@@ -60,10 +60,10 @@ Your request
     │
     ▼
 Context scan (MANDATORY before first line of code)
-├── Read package.json → verify all imports exist
-├── Read tsconfig.json → understand strictness, paths aliases
-├── Read referenced files → understand actual data shapes
-└── Read .env.example → know available environment variables
+├── Search package.json (via grep) → verify specifically required dependencies only. Do NOT read the entire file.
+├── Search tsconfig.json (via grep) → verify specific strictness or path aliases. Do NOT read the entire file.
+├── Read only relevant excerpts of referenced files → understand actual data shapes
+└── Search .env.example (via grep) → verify specifically required environment variables
     │
     ▼
 Maker generates at temperature 0.1
@@ -115,30 +115,36 @@ When unsure: write `// VERIFY: [specific reason]` instead of hallucinating.
 
 ## Reviewer Auto-Selection
 
-**Always active:**
+**System-1 Fast-Pass Routing (MANDATORY)**
+
+Before selecting reviewers, you MUST run `tk impact-tier` to determine the risk level:
+
+- **Tier 0 (Fast-Pass) & Tier 1 (Express Pass):** Bypass ALL LLM Tribunal Reviewers. Run deterministic scripts only. Show Human Gate (or auto-apply if configured).
+- **Tier 2 (Targeted Audit):** Run deterministic scripts + max 1-2 specialized domain reviewers.
+- **Tier 3 (Full Gauntlet):** Run full suite + Human Gate.
+
+**Always active (For Tier 2+):**
 
 ```
 precedence-reviewer→ Enforces repository Case Law and past rejections (Runs First)
-logic-reviewer     → Hallucinated methods, undefined refs, impossible logic
 security-auditor   → OWASP vulnerabilities, hardcoded secrets, injection
-complexity-reviewer→ Enforces the Dependency Ladder to prevent over-engineering
 ```
 
 **Auto-activated by keywords:**
 
-| Keyword in request                                          | Additional Reviewers                                           |
-| :---------------------------------------------------------- | :------------------------------------------------------------- |
-| `api`, `route`, `endpoint`, `handler`, `server action`      | `dependency-reviewer` + `type-safety-reviewer`                 |
-| `sql`, `query`, `database`, `prisma`, `drizzle`, `orm`      | `sql-reviewer`                                                 |
-| `component`, `hook`, `react`, `vue`, `jsx`, `tsx`           | `frontend-reviewer` + `type-safety-reviewer` + `ui-ux-auditor` |
-| `ui`, `design`, `landing`, `page`, `layout`, `style`, `css` | `ui-ux-auditor` + `accessibility-reviewer`                     |
-| `animation`, `gsap`, `framer`, `motion`, `scroll`           | `frontend-reviewer` + `performance-reviewer` + `ui-ux-auditor` |
-| `test`, `spec`, `vitest`, `jest`, `playwright`              | `test-coverage-reviewer`                                       |
-| `slow`, `optimize`, `cache`, `performance`, `bundle`        | `performance-reviewer`                                         |
-| `mobile`, `react native`, `expo`                            | `mobile-reviewer`                                              |
-| `llm`, `openai`, `anthropic`, `gemini`, `embedding`, `ai`   | `ai-code-reviewer`                                             |
-| `aria`, `wcag`, `a11y`, `accessibility`                     | `accessibility-reviewer` + `ui-ux-auditor`                     |
-| `import`, `package`, `npm`, `require`                       | `dependency-reviewer`                                          |
+| Keyword in request                                          | Additional Reviewers (Max 2 for Tier 2)        |
+| :---------------------------------------------------------- | :--------------------------------------------- |
+| `api`, `route`, `endpoint`, `handler`, `server action`      | `backend-specialist` + `type-safety-reviewer`  |
+| `sql`, `query`, `database`, `prisma`, `drizzle`, `orm`      | `sql-reviewer`                                 |
+| `component`, `hook`, `react`, `vue`, `jsx`, `tsx`           | `frontend-reviewer` + `type-safety-reviewer`   |
+| `ui`, `design`, `landing`, `page`, `layout`, `style`, `css` | `frontend-reviewer` + `accessibility-reviewer` |
+| `animation`, `gsap`, `framer`, `motion`, `scroll`           | `frontend-reviewer` + `performance-reviewer`   |
+| `test`, `spec`, `vitest`, `jest`, `playwright`              | `test-coverage-reviewer`                       |
+| `slow`, `optimize`, `cache`, `performance`, `bundle`        | `performance-reviewer`                         |
+| `mobile`, `react native`, `expo`                            | `mobile-reviewer`                              |
+| `llm`, `openai`, `anthropic`, `gemini`, `embedding`, `ai`   | `ai-code-reviewer`                             |
+| `aria`, `wcag`, `a11y`, `accessibility`                     | `accessibility-reviewer`                       |
+| `import`, `package`, `npm`, `require`                       | `dependency-reviewer`                          |
 
 > For maximum safety on critical code: use `/tribunal-full` for all 28 reviewers simultaneously.
 
@@ -210,7 +216,6 @@ Write to disk?  Y = approve | N = discard | R = revise with feedback
 /generate an OpenAI structured output call with Zod schema validation
 ```
 
-
 ## Brain-Hands Separation & Durable Logging
 
 During code generation, the model (Brain) issues tool requests, and the harness (Hands) executes them. Every tool execution is recorded in the durable log. Verification must complete before Human Gate approval.

package/.agent/workflows/htop.md

@@ -1,22 +1,26 @@
 ---
 name: htop
-description: "Inspect active agent execution metrics, task telemetry, and syscall status."
+description: 'Inspect active agent execution metrics, task telemetry, and syscall status.'
 version: 1.0.0
 ---
 
 # HTOP (SYSCALL MONITOR)
 
 ## Invocation
+
 `/htop` or `/syscall-monitor`
 
 ## Behavior
+
 Provides a real-time (or checkpointed) readout of the agent harness execution state.
 
 When invoked, the system reads from `session_logger.js` and `harness_manager.js` to report:
+
 1. **Active Syscalls**: Which commands are currently executing in the background.
 2. **Token Usage**: Aggregate token consumption for the current session.
 3. **Task Status**: Which nodes in the DAG orchestrator are `PENDING`, `RUNNING`, or `DONE`.
 4. **Timeouts**: Any tools approaching their 5-minute kill threshold.
 
 ## Usage
+
 Use this command when a marathon agent appears to be stuck, to inspect whether it is waiting on a slow `npm install` or if it has entered an infinite loop.

package/.agent/workflows/marathon.md

@@ -285,7 +285,6 @@ node .agent/scripts/marathon_harness.js reset
 
 ---
 
-
 ## Long-Running State & Interruption
 
 Marathon workflows maintain long-running task state via frequent checkpoints. If interrupted, the workflow can be restarted cleanly using `/resume` without losing validated state.

package/.agent/workflows/resume.md

@@ -1,15 +1,17 @@
 ---
 name: resume
-description: "Resume a recoverable Tribunal Kit session from the durable event log."
+description: 'Resume a recoverable Tribunal Kit session from the durable event log.'
 version: 1.0.0
 ---
 
 # RESUME WORKFLOW
 
 ## Invocation
+
 `/resume [session_id]`
 
 ## Behavior
+
 Tribunal Kit now uses a durable JSONL event log via `session_logger.js`. If a process is killed (OOM, timeout, user interrupt), the state is not lost.
 
 1. **Validation**: Locates the session events in `.agent_session.json`.
@@ -17,4 +19,5 @@ Tribunal Kit now uses a durable JSONL event log via `session_logger.js`. If a pr
 3. **Resumption**: Skips over completed tasks and automatically restarts the task that was interrupted, pulling in the precise context needed for that specific wave.
 
 ## Safety Boundaries
-The `/resume` workflow will NEVER blindly replay non-idempotent side effects (e.g., executing a POST request or DROP TABLE) without Human Gate confirmation. 
+
+The `/resume` workflow will NEVER blindly replay non-idempotent side effects (e.g., executing a POST request or DROP TABLE) without Human Gate confirmation.

package/.agent/workflows/skill-enhancement-engine.md

@@ -59,7 +59,7 @@ node runners/skill_enhancement_engine.js --skill <skill-name> --fix
 # Enhance all skills within a domain cluster (motion, frontend, backend, security, devops, database, testing, mobile)
 node runners/skill_enhancement_engine.js --domain motion --fix
 
-# Enhance all 185 skills and mirror changes to workspace root
+# Enhance all 235 skills and mirror changes to workspace root
 node runners/skill_enhancement_engine.js --all --fix --sync-to-root
 
 # Validate payload and SDO triggers

package/.agent/workflows/skill-intelligence.md

@@ -0,0 +1,216 @@
+---
+description: Autonomous Skill Intelligence Engine for Tribunal Kit. Discover, compose, gate, and verify capabilities across 235+ engineering skills. Enforces Discover First, Compose Second, Create Only When Necessary, Verify Always.
+tools: Read, Grep, Glob, Bash, Edit, Write
+version: 1.0.0
+last-updated: 2026-10-01
+required-skills:
+  - agent-organizer
+  - skill-creator
+  - clean-code
+scripts-binding:
+  - .agent/scripts/skill_intelligence.js
+  - .agent/scripts/swarm_dispatcher.js
+  - .agent/scripts/verify_all.js
+---
+
+# /skill-intelligence — Tribunal Skill Intelligence Engine
+
+```text
+DISCOVER FIRST.
+COMPOSE SECOND.
+CREATE ONLY WHEN NECESSARY.
+VERIFY ALWAYS.
+```
+
+The Skill Intelligence Engine determines the minimal sufficient set of capabilities required to produce a robust, production-grade outcome for any task without unnecessary skill generation or redundant analysis.
+
+---
+
+## Operating Protocol
+
+### Phase 1 — Discovery (Broad Search)
+
+Before writing or changing code:
+
+1. Parse explicit user requirements and desired outcome.
+2. Extract technical concepts, implicit constraints, and likely failure modes.
+3. Discover existing skills in the 235+ repository (`node .agent/scripts/skill_intelligence.js --query "<task>"`).
+4. Evaluate relevance:
+   - **MANDATORY**: Critical safety, correctness, or transaction requirements.
+   - **RECOMMENDED**: Observability, performance, or hygiene additions.
+   - **OPTIONAL**: Ancillary optimizations.
+   - **IRRELEVANT**: Discard.
+
+### Phase 2 — Concept & Engineering Consideration Extraction
+
+1. Extract explicit and implicit concepts from the 35-category taxonomy.
+2. Formulate the **Engineering Consideration Matrix**:
+   - Categorize by severity: `[CRITICAL]`, `[HIGH]`, `[MEDIUM]`, `[LOW]`.
+   - Surface cross-domain risks (e.g. distributed transactions, concurrency race conditions, prompt injection).
+   - Enforce **The Consideration Invariant**: _Knowledge Availability ≠ Consideration Coverage_.
+
+### Phase 3 — Skill Coverage & Composition (Pipeline DAG)
+
+1. Measure concept-to-skill coverage: `FULL`, `PARTIAL`, or `NONE`.
+2. Automatically promote candidate skills into the execution pipeline DAG.
+3. Build an ordered execution DAG (e.g. Contract → Validation → State/DB → Logic → Tests → Security).
+4. Establish a **shared task context** (AST nodes, schema models, API types) to eliminate duplicate passes.
+
+### Phase 4 — Creation Gate (The 11-Point Audit)
+
+A new skill may **only** be created if all 11 checks pass:
+
+- [x] Existing skill searched
+- [x] Semantic matches searched
+- [x] Related skills checked
+- [x] Composition attempted & proved insufficient
+- [x] Duplicate capability checked
+- [x] Material capability gap confirmed
+- [x] Long-term reusability justified
+- [x] Concept coverage checked
+- [x] Failure-mode coverage checked
+- [x] Verification capability checked
+- [x] Existing skill improvement evaluated
+      _Decision Hierarchy: USE → COMPOSE → IMPROVE → EXTEND → CREATE._
+
+### Phase 5 — Materiality Engine & Outcome Contract Generation
+
+1. Evaluate each discovered consideration as `MATERIAL`, `NON_MATERIAL`, or `OPTIONAL` with technical rationale.
+2. Enforce **Minimum Sufficient Engineering** to prevent overengineering and respect the **Outcome Budget**.
+3. Generate the formal **Outcome Contract** specifying:
+   - Objective & Constraints
+   - Material Considerations & Tailored Quality Attributes
+   - Success Conditions (e.g. single side-effect under duplicate retries)
+   - Non-Goals (explicit anti-overengineering bounds)
+
+### Phase 6 — Verification, Post-Implementation Outcome Audit & Regression Analysis
+
+1. Execute concept-aligned verification tests (idempotency safety, atomic rollbacks, concurrency locks).
+2. Execute post-execution outcome audit via `auditOutcome`:
+   - Categorize outcome into `satisfied`, `partially_satisfied`, `unsatisfied`, `unverified`, `new_risks`, `unnecessary_complexity`.
+   - Distinguish **Task Completion** (code exists / tests pass) from **Outcome Completion** (all material considerations satisfied, zero regressions, zero overengineering).
+3. Analyze systemic architectural decisions via `detectTradeoffs` (e.g. Concurrency Locking vs Throughput/Latency).
+4. Guard against regressions via `evaluateOutcomeRegression`:
+   - Enforce: _A fix is only an improvement if the overall outcome improves_.
+5. Emit structured corrective actions and re-verify before declaring completion.
+
+### Phase 7 — Engineering Judgment, Uncertainty & Adaptive Execution
+
+1. Evaluate evidence across the 8-tier **Evidence Hierarchy** (Runtime > Tests > Static > Benchmarks > Repo > Config > Docs > Model).
+2. Track explicit **Uncertainty** (`verified`, `assumed`, `inferred`, `unknown`, `contradicted`) and calculate **Expected Information Value** before launching expensive investigations.
+3. Manage execution state transitions via the **Engineering Judgment State Machine** (`PROCEED`, `INVESTIGATE`, `REPLAN`, `CORRECT`, `ESCALATE`, `DEFER`, `STOP`, `COMPLETE`).
+4. Classify **Reversibility** and block irreversible operations (data drops, breaking API changes) using the **Escalation Engine**.
+5. Detect **Requirement Conflicts** (e.g. CAP / PACELC bounds, Low Cost vs Multi-Region, Caching vs Freshness) and surface them explicitly.
+6. Support **Dynamic Capability Graphs** (`DynamicCapabilityGraph`) to mutate pipelines (`ADD`, `REMOVE`, `REORDER`, `RETRY`, `SKIP`, `BRANCH`, `MERGE`) based on runtime signals (e.g. dynamic SSRF defense injection).
+7. Audit **Architectural Anti-Slop** to detect overengineering (premature microservices/Kafka) and underengineering (missing transaction boundaries/idempotency).
+
+### Phase 8 — Engineering Memory & Continuous Capability Evolution (Phase 5)
+
+1. Invariants:
+   - `SOLVE ONCE. VERIFY ONCE. LEARN ONCE. REUSE SAFELY.`
+   - `MEMORY MUST EARN TRUST THROUGH EVIDENCE.`
+   - `CURRENT EVIDENCE > STALE MEMORY.`
+   - `MEMORY → HYPOTHESIS → CURRENT EVIDENCE → DECISION.`
+   - `DO NOT REPEAT VERIFIED FAILURES. NEGATIVE KNOWLEDGE IS KNOWLEDGE.`
+   - `ZERO SILENT SELF-MODIFICATION.`
+2. Retrieve typed engineering memories (`pattern`, `failure`, `decision`, `verification`, `anti_pattern`, `skill_performance`, `concept_relationship`, `capability_gap`) as hypotheses.
+3. Validate contextual applicability to prevent false transfer across disparate technologies or scales.
+4. Promote verified hypotheses into considerations and enhance verification plans with proven strategies.
+5. Capture empirical failures into the negative knowledge vault so future executions avoid repeating them.
+6. Generate governed **Skill Improvement Proposals** (SIPs) when repeated weaknesses occur, requiring explicit human/governance approval.
+
+### Phase 9 — System Simulation & Pre-Mortem Intelligence (Phase 6)
+
+1. Core Invariants:
+   - `PREDICT BEFORE IMPLEMENTATION.`
+   - `IF A FAILURE CAN BE REASONED ABOUT BEFORE IMPLEMENTATION, IT SHOULD BE IDENTIFIED.`
+   - `PREDICTION IS NOT EVIDENCE. PREDICTION MUST BE VERIFIED.`
+2. Canonical 30-Category Failure Taxonomy:
+   - Evaluates Functional, Data Integrity, Concurrency, Distributed Systems, Network, Dependency, Security, Auth, Availability, Performance, Scalability, Capacity, Cost, Deployment, Configuration, Observability, Recovery, Human Error, Data Corruption, Consistency, Caching, Messaging, Storage, AI/Agent, Tool, and Supply Chain failures.
+3. Causal Failure Chain Modeling:
+   - Maps `Trigger → Propagation → Failure → Impact → Detection → Recovery` across multi-domain boundaries.
+4. Blast-Radius Analysis (8 Tiers):
+   - Categorizes potential fallout: `LOCAL`, `COMPONENT`, `SERVICE`, `WORKFLOW`, `DATASET`, `REGION`, `SYSTEM`, `MULTI_SYSTEM`.
+5. Multi-Domain Pre-Mortem Simulators:
+   - Dependencies (timeouts, partial/malformed responses, network partitions).
+   - Concurrency & Race Conditions (inventory decrement, double spend, lost updates).
+   - Retry Amplification & Storms (exponential backoff, jitter, idempotency violations).
+   - Queues & Poison Pills (message duplication, poison pill crash loops, lag).
+   - Database Failures (distinguishing slow-DB from dead-DB, connection pool exhaustion, replication lag).
+   - Cache Stampedes (thundering herd, cold starts, and cache-as-availability-dependency).
+   - Load, Capacity & Queueing Analysis (Little's Law arrival rate λ > μ service rate sustainability).
+   - Latency Budget (p50/p95/p99 tail latency decomposition).
+   - Security Pre-Mortem (SSRF, SQLi, command injection, auth bypass, privilege escalation).
+   - AI & Agent Failure Modes (hallucination, infinite loops, context poisoning, prompt injection).
+   - Runaway Cost Loops (agent retry spirals, token burn, high-cardinality telemetry).
+   - Deployment Version Skew & Rollback Failure (coexistence, schema drift).
+   - Chaos Scenario Generation (with strict sandbox/mock boundaries).
+6. Simulation Depth Hierarchy (Levels 0–5):
+   - LEVEL 0 (Static Reasoning) → LEVEL 1 (Architecture Simulation) → LEVEL 2 (Deterministic Test Simulation) → LEVEL 3 (Load Simulation) → LEVEL 4 (Fault Injection) → LEVEL 5 (Chaos Testing).
+   - Enforces **Minimum Sufficient Simulation Depth** proportional to task complexity and risk.
+7. Prediction Contract & Unsupported Claim Detection:
+   - Strict separation of unverified `PREDICTION` from empirical `FINDING`.
+   - Flags unsupported absolute claims ("exactly once", "impossible race conditions", "infinitely scalable").
+8. Post-Implementation Prediction vs Observed Verification:
+   - Compares predicted hazards against observed execution evidence (`VERIFIED` vs `DISPROVED`).
+   - Automatically stores verified outcomes into Phase 5 Engineering Memory to prevent regression.
+
+---
+
+## CLI Integration
+
+```bash
+# Discover relevant concepts, considerations, skill coverage, and pipeline DAG
+node .agent/scripts/skill_intelligence.js --query "Build payment API with idempotency and retry"
+
+# Surface relevant engineering memories, hypotheses, and failures to avoid
+node .agent/scripts/skill_intelligence.js --query "Build payment API with idempotency and retry" --memory
+
+# Run Phase 6 Pre-Mortem & Simulation Analysis
+node .agent/scripts/skill_intelligence.js --query "Build payment API with idempotency and retry" --pre-mortem
+tk pre-mortem "Build payment processing API with retries"
+
+# Inspect Causal Failure Chains
+node .agent/scripts/skill_intelligence.js --query "Build payment API with retries" --chains
+tk pre-mortem "Build payment API" --chains
+
+# Detect Unsupported Architectural Claims
+node .agent/scripts/skill_intelligence.js --query "Build API with guaranteed exactly once delivery and impossible race conditions" --claims
+tk pre-mortem "Build API with guaranteed exactly once delivery" --claims
+
+# Simulate Architecture against Pre-Mortem Engine
+tk simulate --architecture architecture.json
+
+# Compare Predictions against Observed Evidence and Update Engineering Memory
+tk simulate --verify evidence.json
+
+# Inspect historical failures and negative knowledge vault
+node .agent/scripts/skill_intelligence.js --failures
+
+# Inspect continuous capability improvement proposals
+node .agent/scripts/skill_intelligence.js --proposals
+
+# Inspect skill performance telemetry and precision ratios
+node .agent/scripts/skill_intelligence.js --telemetry
+
+# Inspect the formal Phase 3 Outcome Contract
+node .agent/scripts/skill_intelligence.js --query "Build payment API with idempotency and retry" --contract
+
+# Inspect Phase 4 Engineering Judgment, Reversibility, and Requirement Conflicts
+node .agent/scripts/skill_intelligence.js --query "Global API with < 50ms latency, strong cross-region consistency, and zero infrastructure cost" --judgment
+
+# Run Architectural Anti-Slop Audit (detects overengineering / underengineering)
+node .agent/scripts/skill_intelligence.js --query "Build simple static documentation website with kafka and kubernetes" --anti-slop
+
+# Output machine-readable JSON (includes memories, outcome_contract, judgment, pre_mortem, and predictions)
+node .agent/scripts/skill_intelligence.js --query "Build payment API with idempotency and retry" --json
+
+# Check if creating a new skill satisfies the 11-check creation gate
+node .agent/scripts/skill_intelligence.js --gate --need "webhook-reconciliation"
+
+# Post-execution outcome & verification audit against implementation evidence
+node .agent/scripts/skill_intelligence.js --query "Build payment API with idempotency and retry" --evidence evidence.json
+
+# Audit discovery readiness of all registered skills
+node .agent/scripts/skill_intelligence.js --audit
+```

package/.agent/workflows/team-mode.md

@@ -1,15 +1,17 @@
 ---
 name: team-mode
-description: "Enable dynamic multi-agent task execution, DAG routing, and parallel reviews."
+description: 'Enable dynamic multi-agent task execution, DAG routing, and parallel reviews.'
 version: 1.0.0
 ---
 
 # TEAM MODE (DAG ORCHESTRATION)
 
 ## Invocation
+
 `/team-mode [task_prompt]`
 
 ## Behavior
+
 Activates the `swarm_dispatcher.js` using the `--mode dag` flag to execute highly complex, multi-domain tasks.
 
 1. **Decomposition**: The Orchestrator agent splits the `task_prompt` into a Topological DAG.
@@ -19,4 +21,5 @@ Activates the `swarm_dispatcher.js` using the `--mode dag` flag to execute highl
 5. **Review**: The entire output is passed through `/tribunal-full` before being marked complete.
 
 ## Guardrails
+
 Team Mode cannot bypass the Human Gate. If any subagent proposes a destructive action, the entire DAG is paused, and the Human Gate Negotiator is summoned.

package/.agent/workflows/tribunal-backend.md

@@ -8,9 +8,13 @@ required-skills:
   - nodejs-best-practices
   - api-patterns
 scripts-binding:
+  - .agent/scripts/backend_audit.js
   - .agent/scripts/security_scan.js
   - .agent/scripts/dependency_analyzer.js
   - .agent/scripts/schema_validator.js
+  - .agent/scripts/cross_agent_correlator.js
+  - .agent/scripts/validation_engine.js
+  - .agent/scripts/backend_report_generator.js
 ---
 
 # /tribunal-backend — Backend Code Audit
@@ -27,10 +31,17 @@ Before auditing backend routes or server logic, you MUST inspect:
 2. Dependencies & Environment (`package.json`, `.env.example`) → Check backend framework versions, secret key placeholders, and ORM schemas
 3. 28-Reviewer Parallel Gate → Execute logic-reviewer, security-auditor, dependency-analyzer, type-safety, resilience-reviewer, and schema-reviewer before approving diffs
 
-4. Required Skills → Before executing, load and follow procedural rules from:
-   - `backend-security-expert` (.agent/skills/backend-security-expert/SKILL.md): Server-side security, auth, JWT, ORM injection, RBAC
-   - `nodejs-best-practices` (.agent/skills/nodejs-best-practices/SKILL.md): Node.js patterns, async handling, and error management
-   - `api-patterns` (.agent/skills/api-patterns/SKILL.md): REST/GraphQL API design, versioning, and error contracts
+4. Required Skills → Before executing, run \`.agent/scripts/backend_audit.js\` to detect the backend stack (Python, FastAPI, Node.js, databases) and load the specific dynamically recommended skills from the script output.
+   - You MUST load every skill output by \`backend_audit.js\`.
+   - Examples of dynamically loaded skills include \`fastapi-pro\`, \`backend-postgresql\`, \`backend-architecture-auditor\`, etc.
+
+5. Backend Correlation & Validation Pipeline →
+   - Output all your findings across agents into Evidence-First JSON format.
+   - Save to files (e.g., `findings_sec.json`, `findings_db.json`).
+   - Run \`.agent/scripts/cross_agent_correlator.js findings_sec.json findings_db.json --out=correlated.json\`.
+   - Run \`.agent/scripts/validation_engine.js --in=correlated.json --out=validated.json\`.
+   - Run \`.agent/scripts/backend_report_generator.js --in=validated.json --out=backend_report.md\`.
+   - Present \`backend_report.md\` to the user as the final outcome.
 
 ---
 
@@ -46,13 +57,13 @@ Before auditing backend routes or server logic, you MUST inspect:
 
 ---
 
-## 6 Active Reviewers (All Run Simultaneously)
+## 8 Active Reviewers (All Run Simultaneously)
 
 ### precedence-reviewer → Checks local repo Case Law for past rejections
 
-logic-reviewer
+### logic-reviewer
 
-- Hallucinated Express/Hono/Fastify methods
+- Hallucinated Express/Hono/Fastify/FastAPI methods
 - Missing awaits on async operations
 - Unreachable code after return statements
 - Race conditions in sequential state mutations
@@ -143,6 +154,7 @@ const payload = jwt.verify(token, secret); // Correct
 | :--------------------------- | :------------------------------------------------ |
 | All checks pass              | → `/deploy` or merge code                         |
 | Reviewers reject with fixes  | → Apply fixes, then run `/tribunal-backend` again |
+| Architecture concerns raised | → `/plan` to propose a structural refactor        |
 | Performance concerns raised  | → `/tribunal-performance` for deep profiling      |
 | Need test coverage for logic | → `/test` to generate backend tests               |
 

package/.agent/workflows/tribunal-frontend.md

@@ -96,6 +96,12 @@ Before auditing React components or frontend UI logic, you MUST inspect:
 - Elements appearing from `scale(0)` instead of `0.95`
 - Non-interruptible motion or missing hover/active states
 
+### anti-slop-auditor (Wave 3)
+
+- Enforces the Purpose-Gate (requires explicit reason for gradients, glassmorphism, etc.)
+- Enforces the Liveliness Dials (Energy, Rhythm, Motion must be declared)
+- Rejects generic AI clichés, fake statistics, and card-in-card mud
+
 ---
 
 ## Verdict System

package/.agent/workflows/tribunal-ui.md

@@ -86,6 +86,11 @@ Before executing dedicated UI/UX audits or design-system reviews, you MUST inspe
 - **Focus:** Screenshot or DOM layout verification.
 - **Check:** Checks vertical overflow, layout shifts (CLS), alignment shifts, and contrast ratios.
 
+### 8. anti-slop-auditor (Wave 3)
+
+- **Focus:** Enforcing Purpose-Gates and Liveliness Dials.
+- **Check:** Rejects generic AI clichés and blocks Purpose-Gated techniques (gradients, glassmorphism) if a justification is missing.
+
 ---
 
 ## Verdict System