tribunal-kit 9.2.6 → 9.2.7

package/.agent/workflows/arch.md

@@ -1,80 +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
+---
+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/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/CONTRIBUTING.md

@@ -42,9 +42,9 @@ tribunal-kit/
 │   └── index.d.ts          # TypeScript declarations
 ├── crates/core/            # Rust core engine (Tokio-based)
 ├── .agent/                 # The intelligence payload (agents, skills, workflows)
-│   ├── agents/             # 58 specialist and reviewer agent definitions
+│   ├── agents/             # 60 specialist and reviewer agent definitions
 │   ├── skills/             # Reusable skill packs
-│   ├── workflows/          # 49 workflow definitions
+│   ├── workflows/          # 51 workflow definitions
 │   └── scripts/            # Automation scripts
 ├── test/
 │   ├── unit/               # Unit tests (Jest)

package/README.md

@@ -15,7 +15,7 @@
   <!-- BADGES -->
   <div style="margin-bottom: 25px;">
     <a href="https://github.com/Harmitx7/tribunal-kit/releases">
-      <img src="https://img.shields.io/badge/Release-v9.2.6-blue?style=for-the-badge" alt="Release" />
+      <img src="https://img.shields.io/badge/Release-v9.2.7-blue?style=for-the-badge" alt="Release" />
     </a>
     <a href="https://www.npmjs.com/package/tribunal-kit">
       <img src="https://img.shields.io/npm/v/tribunal-kit?style=for-the-badge&logo=npm&logoColor=white&color=ff1637" alt="NPM Version" />
@@ -53,19 +53,19 @@ Tribunal Kit acts as a **neurosymbolic verification envelope**. It intercepts AI
 
 ---
 
-## ⚡ What's New in v9.2.6
+## ⚡ What's New in v9.2.7
 
+- **Skill Intelligence Engine (`tk skill-intel`):** Autonomous discovery, composition, and gating across 235+ engineering skills with concept extraction, DAG pipeline compilation, and 11-point creation gate.
+- **System-1 Expansion Core:** Added specialized processing modules including browser intelligence, deterministic decision & evidence engines, and adaptive evolution pipeline.
+- **Cross-Domain & Outcome Optimization:** Real-time second-order effect detection, emergent failure prediction, and non-downgrade monotonic security invariants.
 - **Backend Intelligence Trust Boundary:** Strict validation engine output isolation. LLMs can no longer self-authorize findings; evidence requires verifiable provenance hashes and terminal command records.
-- **Universal 18-Section Governance Standard:** All 235 modular skills upgraded to enforce Tri-State Evidence classification (`[OBSERVED]`, `[INFERRED]`, `[UNVERIFIED]`) and non-negotiable **Verification-Before-Completion (VBC)** gates.
-- **Anti-Slop Purpose-Gate:** Added the dedicated `anti-slop-auditor` (Wave 3) and `anti-slop-enforcement` skill to eradicate cliché AI design copy, gratuitous animations, and generic purple gradients.
-- **System-1 Concurrency & Isolation:** Atomic directory-based installation locks, isolated dependency packaging (~150MB overhead eliminated), and SHA-256 model verification for local ONNX inference.
-- **Zero-Trust Architecture Intelligence (`tk arch`):** Deterministic fact extraction (TAFE), blast-radius computation, circular dependency detection, and interactive HTML architecture projections.
+- **Universal 18-Section Governance Standard:** All 235 modular skills enforce Tri-State Evidence classification (`[OBSERVED]`, `[INFERRED]`, `[UNVERIFIED]`) and non-negotiable **Verification-Before-Completion (VBC)** gates.
 
 ---
 
 ## ⚡ Core Capabilities
 
-- **Parallel Review Pipeline:** 28 domain-specific reviewers analyze generated code simultaneously across 3 waves (Logic, Security, Domain) before writing to disk.
+- **Parallel Review Pipeline:** 31 domain-specific reviewers analyze generated code simultaneously across 3 waves (Logic, Security, Domain) before writing to disk.
 - **Compiled Rust Core:** Sub-10ms AST parsing, semantic graph extraction, and file synchronization using SHA-256 diffs.
 - **Phantom Package Guardrails:** Blocks "slopsquatting" and non-existent npm package imports during code generation.
 - **Cross-Session Memory:** "Supreme Court Case Law" (`tk case`) and key-value memory (`tk memory`) record past AI mistake precedents.
@@ -83,7 +83,7 @@ Tribunal Kit operates as a fast, intercepting middleware layer between the AI ge
 graph LR
     A[User Request] --> B[Context Broker]
     B --> C[Compiled Rust Core<br/>AST / Graph Extraction]
-    C --> D[28 Parallel Reviewers<br/>Waves 1, 2 & 3]
+    C --> D[31 Parallel Reviewers<br/>Waves 1, 2 & 3]
     D -->|Violation| E[Inner-Loop Auto-Correct]
     E -.-> B
     D -->|Passed| F[Human Gate]
@@ -131,22 +131,22 @@ npx tribunal-kit tk-adapt aider
 
 Tribunal Kit CLI operations are routed through the compiled Rust binary when supported, falling back to the JavaScript engine gracefully.
 
-| Command     | Arguments                   | Description                                                      |
-| :---------- | :-------------------------- | :--------------------------------------------------------------- |
-| `init`      | `[--force]`                 | Initializes the `.agent/` configuration payload.                 |
-| `sync`      | —                           | Syncs rules with IDEs (.cursorrules, .windsurfrules).            |
-| `status`    | —                           | Evaluates workspace rules and checks for violations.             |
-| `validate`  | `[--file <path>]`           | Validates `.agent/` payload structure with live reviewer swarm.  |
-| `guardrail` | `[--file <path>]`           | Scans changes for phantom packages and `// VERIFY` tags.         |
-| `arch`      | `map \| verify \| impact \| diff \| audit \| project` | Verifiable Architecture Intelligence & Blast Radius engine. |
-| `system1`   | `enable \| disable \| status` | Manages local ONNX neural tier assessment and model weights.     |
-| `sdd`       | `run \| status`             | Subagent-Driven Development execution with reviewer waves.       |
-| `minimal`   | `[--prompt <text>]`         | Analyzes change requests for minimal viable diffs (Decision 0-7).|
-| `contract`  | `init \| verify \| list`    | AI agent behavioral contract validation and trace replay.        |
-| `memory`    | `store \| recall \| gc`     | Manages persistent cross-session AI memory.                      |
-| `case`      | `add \| search <q>`         | Records or searches for AI mistake precedents.                   |
-| `tk-adapt`  | `[claude\|aider\|--global]` | Installs universal CLI agent adapters.                           |
-| `hook`      | —                           | Installs the automated Git pre-push governance hook.             |
+| Command     | Arguments                                             | Description                                                       |
+| :---------- | :---------------------------------------------------- | :---------------------------------------------------------------- |
+| `init`      | `[--force]`                                           | Initializes the `.agent/` configuration payload.                  |
+| `sync`      | —                                                     | Syncs rules with IDEs (.cursorrules, .windsurfrules).             |
+| `status`    | —                                                     | Evaluates workspace rules and checks for violations.              |
+| `validate`  | `[--file <path>]`                                     | Validates `.agent/` payload structure with live reviewer swarm.   |
+| `guardrail` | `[--file <path>]`                                     | Scans changes for phantom packages and `// VERIFY` tags.          |
+| `arch`      | `map \| verify \| impact \| diff \| audit \| project` | Verifiable Architecture Intelligence & Blast Radius engine.       |
+| `system1`   | `enable \| disable \| status`                         | Manages local ONNX neural tier assessment and model weights.      |
+| `sdd`       | `run \| status`                                       | Subagent-Driven Development execution with reviewer waves.        |
+| `minimal`   | `[--prompt <text>]`                                   | Analyzes change requests for minimal viable diffs (Decision 0-7). |
+| `contract`  | `init \| verify \| list`                              | AI agent behavioral contract validation and trace replay.         |
+| `memory`    | `store \| recall \| gc`                               | Manages persistent cross-session AI memory.                       |
+| `case`      | `add \| search <q>`                                   | Records or searches for AI mistake precedents.                    |
+| `tk-adapt`  | `[claude\|aider\|--global]`                           | Installs universal CLI agent adapters.                            |
+| `hook`      | —                                                     | Installs the automated Git pre-push governance hook.              |
 
 _(For workflow execution, Tribunal Kit monitors for slash commands like `/orchestrate`, `/audit`, `/sdd`, or `/deploy` inside your AI context)._
 

package/bin/adapter-install.js

@@ -204,7 +204,7 @@ function main() {
   console.log('');
   console.log('┌─────────────────────────────────────────────┐');
   console.log('│  🔱 Tribunal Kit — Universal Agent Adapter  │');
-  console.log('│  v9.2.6 · 52 specialists · 185 skills       │');
+  console.log('│  v9.2.7 · 52 specialists · 185 skills       │');
   console.log('└─────────────────────────────────────────────┘');
   console.log('');
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tribunal-kit",
-  "version": "9.2.6",
+  "version": "9.2.7",
   "description": "Tribunal Kit is the governance layer for AI coding agents that stops AI hallucinations and npm ghost packages before they hit disk. Works with Cursor, Windsurf, Claude Code, and Aider.",
   "keywords": [
     "ai",
@@ -142,16 +142,15 @@
     "onnxruntime-node": "^1.22.0",
     "prettier": "^3.2.5",
     "typescript": "^5.4.5",
-    "ws": "^8.21.3",
-    "zod": "^4.5.4"
+    "ws": "^8.21.3"
   },
   "optionalDependencies": {
-    "@tribunal-kit/core-darwin-arm64": "^9.2.6",
-    "@tribunal-kit/core-darwin-x64": "^9.2.6",
-    "@tribunal-kit/core-linux-arm64": "^9.2.6",
-    "@tribunal-kit/core-linux-x64": "^9.2.6",
-    "@tribunal-kit/core-win32-arm64": "^9.2.6",
-    "@tribunal-kit/core-win32-x64": "^9.2.6"
+    "@tribunal-kit/core-darwin-arm64": "^9.2.7",
+    "@tribunal-kit/core-darwin-x64": "^9.2.7",
+    "@tribunal-kit/core-linux-arm64": "^9.2.7",
+    "@tribunal-kit/core-linux-x64": "^9.2.7",
+    "@tribunal-kit/core-win32-arm64": "^9.2.7",
+    "@tribunal-kit/core-win32-x64": "^9.2.7"
   },
   "jest": {
     "testMatch": [

package/plugins/core-plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "tribunal-kit",
   "description": "Enterprise-grade governance layer and anti-hallucination engine for AI coding agents: 52 specialists, 28 parallel reviewers, Rust core, Subagent-Driven Development (SDD), and strict TDD workflows.",
-  "version": "9.2.6",
+  "version": "9.2.7",
   "author": {
     "name": "Harmitx7",
     "email": "harmit@tribunalkit.com"

package/plugins/gemini/extension.json

@@ -1,6 +1,6 @@
 {
   "name": "tribunal-kit",
   "description": "Enterprise-grade governance layer and anti-hallucination engine: 52 specialists, 28 parallel reviewers, Rust core, and SDD workflows.",
-  "version": "9.2.6",
+  "version": "9.2.7",
   "contextFileName": ".agent/rules/GEMINI.md"
 }

package/src/browser/index.js

@@ -5,7 +5,7 @@
  */
 
 const { findBrowser, findPinchTabBinary, isPortOpen } = require('./discovery');
-const { launchBrowser, cleanupAll } = require('./launcher');
+const { launchBrowser, cleanupAll, terminateProcessTree } = require('./launcher');
 const { CdpClient, createNewTab, closeTab } = require('./cdp');
 const { trimHTML, toSemanticMarkdown, truncateUTF8Bytes, MAX_TRIMMED_BYTES } = require('./trimmer');
 const { scanContent, sanitizeContent, sandboxWebContent, isDomainAllowed } = require('./idpi');
@@ -66,6 +66,7 @@ module.exports = {
   isPortOpen,
   launchBrowser,
   cleanupAll,
+  terminateProcessTree,
   CdpClient,
   createNewTab,
   closeTab,

package/src/browser/launcher.js

@@ -139,7 +139,7 @@ async function launchBrowser(options = {}) {
 
   const close = async () => {
     activeInstances.delete(proc);
-    proc.kill();
+    terminateProcessTree(proc);
     try {
       fs.rmSync(tempProfileDir, { recursive: true, force: true });
     } catch {
@@ -154,7 +154,47 @@ async function launchBrowser(options = {}) {
   };
 }
 
+/**
+ * Cleanly terminates a process and its child process tree cross-platform.
+ * Handles null, dead, or invalid processes gracefully without throwing.
+ * @param {any} proc - ChildProcess instance or object with pid
+ */
+function terminateProcessTree(proc) {
+  if (!proc || typeof proc !== 'object' || !proc.pid) return;
+  const pid = proc.pid;
+  try {
+    if (process.platform === 'win32') {
+      try {
+        const { execSync } = require('child_process');
+        execSync(`taskkill /pid ${pid} /T /F`, { stdio: 'ignore' });
+      } catch (_) {}
+      try {
+        if (typeof proc.kill === 'function') {
+          proc.kill('SIGKILL');
+        } else {
+          process.kill(pid, 'SIGKILL');
+        }
+      } catch (_) {}
+    } else {
+      try {
+        process.kill(-pid, 'SIGKILL');
+      } catch (_) {
+        try {
+          if (typeof proc.kill === 'function') {
+            proc.kill('SIGKILL');
+          } else {
+            process.kill(pid, 'SIGKILL');
+          }
+        } catch (_) {}
+      }
+    }
+  } catch (_) {
+    // Graceful error handling for missing, invalid, or already-dead process
+  }
+}
+
 module.exports = {
   launchBrowser,
   cleanupAll,
+  terminateProcessTree,
 };

package/src/cli.js

@@ -130,7 +130,9 @@ function cmdHelp(quiet = false) {
     cmd('contract', 'AI Agent Behavioral Contract Testing (init, verify, list, trace, replay)'),
   );
   (0, logger_1.log)(cmd('impact-tier', 'Classify task governance impact tier (0-3)'));
-  (0, logger_1.log)(cmd('context-rank', 'Deterministic evidence-driven context ranking and token budgeting'));
+  (0, logger_1.log)(
+    cmd('context-rank', 'Deterministic evidence-driven context ranking and token budgeting'),
+  );
   (0, logger_1.log)(cmd('browse', 'Token-efficient page reader (pruned to <4k bytes)'));
   (0, logger_1.log)(cmd('audit-web', 'Live browser accessibility, console & vitals auditor'));
   (0, logger_1.log)(cmd('compare-web', 'Visual regression differ for CI & release gating'));